rhubarb-lip-sync/lib/webrtc-8d2248ff/webrtc/system_wrappers/source/critical_section_unittest.cc

138 lines
4.0 KiB
C++

/*
* Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/system_wrappers/include/sleep.h"
#include "webrtc/base/platform_thread.h"
#include "webrtc/system_wrappers/include/trace.h"
namespace webrtc {
namespace {
// Cause a process switch. Needed to avoid depending on
// busy-wait in tests.
static void SwitchProcess() {
// Note - sched_yield has been tried as process switch. This does
// not cause a process switch enough of the time for reliability.
SleepMs(1);
}
class ProtectedCount {
public:
explicit ProtectedCount(CriticalSectionWrapper* crit_sect)
: crit_sect_(crit_sect),
count_(0) {
}
void Increment() {
CriticalSectionScoped cs(crit_sect_);
++count_;
}
int Count() const {
CriticalSectionScoped cs(crit_sect_);
return count_;
}
private:
CriticalSectionWrapper* crit_sect_;
int count_;
};
class CritSectTest : public ::testing::Test {
public:
CritSectTest() {}
// Waits a number of cycles for the count to reach a given value.
// Returns true if the target is reached or passed.
bool WaitForCount(int target, ProtectedCount* count) {
int loop_counter = 0;
// On Posix, this SwitchProcess() needs to be in a loop to make the
// test both fast and non-flaky.
// With 1 us wait as the switch, up to 7 rounds have been observed.
while (count->Count() < target && loop_counter < 100 * target) {
++loop_counter;
SwitchProcess();
}
return (count->Count() >= target);
}
};
bool LockUnlockThenStopRunFunction(void* obj) {
ProtectedCount* the_count = static_cast<ProtectedCount*>(obj);
the_count->Increment();
return false;
}
TEST_F(CritSectTest, ThreadWakesOnce) NO_THREAD_SAFETY_ANALYSIS {
CriticalSectionWrapper* crit_sect =
CriticalSectionWrapper::CreateCriticalSection();
ProtectedCount count(crit_sect);
rtc::PlatformThread thread(
&LockUnlockThenStopRunFunction, &count, "ThreadWakesOnce");
crit_sect->Enter();
thread.Start();
SwitchProcess();
// The critical section is of reentrant mode, so this should not release
// the lock, even though count.Count() locks and unlocks the critical section
// again.
// Thus, the thread should not be able to increment the count
ASSERT_EQ(0, count.Count());
crit_sect->Leave(); // This frees the thread to act.
EXPECT_TRUE(WaitForCount(1, &count));
thread.Stop();
delete crit_sect;
}
bool LockUnlockRunFunction(void* obj) {
ProtectedCount* the_count = static_cast<ProtectedCount*>(obj);
the_count->Increment();
SwitchProcess();
return true;
}
TEST_F(CritSectTest, ThreadWakesTwice) NO_THREAD_SAFETY_ANALYSIS {
CriticalSectionWrapper* crit_sect =
CriticalSectionWrapper::CreateCriticalSection();
ProtectedCount count(crit_sect);
rtc::PlatformThread thread(
&LockUnlockRunFunction, &count, "ThreadWakesTwice");
crit_sect->Enter(); // Make sure counter stays 0 until we wait for it.
thread.Start();
crit_sect->Leave();
// The thread is capable of grabbing the lock multiple times,
// incrementing counter once each time.
// It's possible for the count to be incremented by more than 2.
EXPECT_TRUE(WaitForCount(2, &count));
EXPECT_LE(2, count.Count());
// The thread does not increment while lock is held.
crit_sect->Enter();
int count_before = count.Count();
for (int i = 0; i < 10; i++) {
SwitchProcess();
}
EXPECT_EQ(count_before, count.Count());
crit_sect->Leave();
SwitchProcess();
EXPECT_TRUE(WaitForCount(count_before + 1, &count));
thread.Stop();
delete crit_sect;
}
} // anonymous namespace
} // namespace webrtc