Source code

Revision control

Other Tools

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* vim: set ts=8 sts=2 et sw=2 tw=80:
*/
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "jsapi-tests/tests.h"
#include "threading/ConditionVariable.h"
#include "threading/Thread.h"
#include "vm/MutexIDs.h"
struct TestState {
js::Mutex mutex;
js::ConditionVariable condition;
bool flag;
js::Thread testThread;
explicit TestState(bool createThread = true)
: mutex(js::mutexid::TestMutex), flag(false) {
if (createThread) {
MOZ_RELEASE_ASSERT(testThread.init(setFlag, this));
}
}
static void setFlag(TestState* state) {
js::UniqueLock<js::Mutex> lock(state->mutex);
state->flag = true;
state->condition.notify_one();
}
void join() { testThread.join(); }
};
BEGIN_TEST(testThreadingConditionVariable) {
auto state = mozilla::MakeUnique<TestState>();
{
js::UniqueLock<js::Mutex> lock(state->mutex);
while (!state->flag) {
state->condition.wait(lock);
}
}
state->join();
CHECK(state->flag);
return true;
}
END_TEST(testThreadingConditionVariable)
BEGIN_TEST(testThreadingConditionVariablePredicate) {
auto state = mozilla::MakeUnique<TestState>();
{
js::UniqueLock<js::Mutex> lock(state->mutex);
state->condition.wait(lock, [&state]() { return state->flag; });
}
state->join();
CHECK(state->flag);
return true;
}
END_TEST(testThreadingConditionVariablePredicate)
BEGIN_TEST(testThreadingConditionVariableUntilOkay) {
auto state = mozilla::MakeUnique<TestState>();
{
js::UniqueLock<js::Mutex> lock(state->mutex);
while (!state->flag) {
auto to =
mozilla::TimeStamp::Now() + mozilla::TimeDuration::FromSeconds(600);
js::CVStatus res = state->condition.wait_until(lock, to);
CHECK(res == js::CVStatus::NoTimeout);
}
}
state->join();
CHECK(state->flag);
return true;
}
END_TEST(testThreadingConditionVariableUntilOkay)
BEGIN_TEST(testThreadingConditionVariableUntilTimeout) {
auto state = mozilla::MakeUnique<TestState>(false);
{
js::UniqueLock<js::Mutex> lock(state->mutex);
while (!state->flag) {
auto to = mozilla::TimeStamp::Now() +
mozilla::TimeDuration::FromMilliseconds(10);
js::CVStatus res = state->condition.wait_until(lock, to);
if (res == js::CVStatus::Timeout) {
break;
}
}
}
CHECK(!state->flag);
// Timeout in the past should return with timeout immediately.
{
js::UniqueLock<js::Mutex> lock(state->mutex);
auto to =
mozilla::TimeStamp::Now() - mozilla::TimeDuration::FromMilliseconds(10);
js::CVStatus res = state->condition.wait_until(lock, to);
CHECK(res == js::CVStatus::Timeout);
}
return true;
}
END_TEST(testThreadingConditionVariableUntilTimeout)
BEGIN_TEST(testThreadingConditionVariableUntilOkayPredicate) {
auto state = mozilla::MakeUnique<TestState>();
{
js::UniqueLock<js::Mutex> lock(state->mutex);
auto to =
mozilla::TimeStamp::Now() + mozilla::TimeDuration::FromSeconds(600);
bool res = state->condition.wait_until(lock, to,
[&state]() { return state->flag; });
CHECK(res);
}
state->join();
CHECK(state->flag);
return true;
}
END_TEST(testThreadingConditionVariableUntilOkayPredicate)
BEGIN_TEST(testThreadingConditionVariableUntilTimeoutPredicate) {
auto state = mozilla::MakeUnique<TestState>(false);
{
js::UniqueLock<js::Mutex> lock(state->mutex);
auto to =
mozilla::TimeStamp::Now() + mozilla::TimeDuration::FromMilliseconds(10);
bool res = state->condition.wait_until(lock, to,
[&state]() { return state->flag; });
CHECK(!res);
}
CHECK(!state->flag);
return true;
}
END_TEST(testThreadingConditionVariableUntilTimeoutPredicate)
BEGIN_TEST(testThreadingConditionVariableForOkay) {
auto state = mozilla::MakeUnique<TestState>();
{
js::UniqueLock<js::Mutex> lock(state->mutex);
while (!state->flag) {
auto duration = mozilla::TimeDuration::FromSeconds(600);
js::CVStatus res = state->condition.wait_for(lock, duration);
CHECK(res == js::CVStatus::NoTimeout);
}
}
state->join();
CHECK(state->flag);
return true;
}
END_TEST(testThreadingConditionVariableForOkay)
BEGIN_TEST(testThreadingConditionVariableForTimeout) {
auto state = mozilla::MakeUnique<TestState>(false);
{
js::UniqueLock<js::Mutex> lock(state->mutex);
while (!state->flag) {
auto duration = mozilla::TimeDuration::FromMilliseconds(10);
js::CVStatus res = state->condition.wait_for(lock, duration);
if (res == js::CVStatus::Timeout) {
break;
}
}
}
CHECK(!state->flag);
// Timeout in the past should return with timeout immediately.
{
js::UniqueLock<js::Mutex> lock(state->mutex);
auto duration = mozilla::TimeDuration::FromMilliseconds(-10);
js::CVStatus res = state->condition.wait_for(lock, duration);
CHECK(res == js::CVStatus::Timeout);
}
return true;
}
END_TEST(testThreadingConditionVariableForTimeout)
BEGIN_TEST(testThreadingConditionVariableForOkayPredicate) {
auto state = mozilla::MakeUnique<TestState>();
{
js::UniqueLock<js::Mutex> lock(state->mutex);
auto duration = mozilla::TimeDuration::FromSeconds(600);
bool res = state->condition.wait_for(lock, duration,
[&state]() { return state->flag; });
CHECK(res);
}
state->join();
CHECK(state->flag);
return true;
}
END_TEST(testThreadingConditionVariableForOkayPredicate)
BEGIN_TEST(testThreadingConditionVariableForTimeoutPredicate) {
auto state = mozilla::MakeUnique<TestState>(false);
{
js::UniqueLock<js::Mutex> lock(state->mutex);
auto duration = mozilla::TimeDuration::FromMilliseconds(10);
bool res = state->condition.wait_for(lock, duration,
[&state]() { return state->flag; });
CHECK(!res);
}
CHECK(!state->flag);
return true;
}
END_TEST(testThreadingConditionVariableForTimeoutPredicate)