admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove usage of rtc::TaskQueue in TimeController unittests

Browse Source 
Bug: webrtc:14169
Change-Id: Ib3769bffe4642d9466c65dee3d46d81049642f40
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/333803
Auto-Submit: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Artem Titov <titovartem@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#41486}
This commit is contained in:
Danil Chapovalov 2024-01-08 17:57:32 +01:00 committed by WebRTC LUCI CQ
parent b9405c4748
commit 956879d86f
3 changed files with 40 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
test/time_controller/BUILD.gn
View File

@ -58,10 +58,10 @@ if (rtc_include_tests) {
":time_controller", ":time_controller",
"../:test_support", "../:test_support",
"../../api:time_controller", "../../api:time_controller",
"../../api/task_queue",
"../../api/units:time_delta", "../../api/units:time_delta",
"../../rtc_base:macromagic", "../../rtc_base:macromagic",
"../../rtc_base:rtc_event", "../../rtc_base:rtc_event",
"../../rtc_base:rtc_task_queue",
"../../rtc_base:task_queue_for_test", "../../rtc_base:task_queue_for_test",
"../../rtc_base:threading", "../../rtc_base:threading",
"../../rtc_base/synchronization:mutex", "../../rtc_base/synchronization:mutex",

42
test/time_controller/external_time_controller_unittest.cc
View File

@ -14,8 +14,8 @@
#include <memory> #include <memory>
#include <utility> #include <utility>
#include "api/task_queue/task_queue_base.h"
#include "rtc_base/event.h" #include "rtc_base/event.h"
#include "rtc_base/task_queue.h"
#include "rtc_base/task_utils/repeating_task.h" #include "rtc_base/task_utils/repeating_task.h"
#include "test/gmock.h" #include "test/gmock.h"
#include "test/gtest.h" #include "test/gtest.h"
@ -88,11 +88,11 @@ TEST(ExternalTimeControllerTest, TaskIsStoppedOnStop) {
const int kMargin = 1; const int kMargin = 1;
FakeAlarm alarm(kStartTime); FakeAlarm alarm(kStartTime);
ExternalTimeController time_simulation(&alarm); ExternalTimeController time_simulation(&alarm);
rtc::TaskQueue task_queue( std::unique_ptr<TaskQueueBase, TaskQueueDeleter> task_queue =
time_simulation.GetTaskQueueFactory()->CreateTaskQueue( time_simulation.GetTaskQueueFactory()->CreateTaskQueue(
"TestQueue", TaskQueueFactory::Priority::NORMAL)); "TestQueue", TaskQueueFactory::Priority::NORMAL);
std::atomic_int counter(0); std::atomic_int counter(0);
auto handle = RepeatingTaskHandle::Start(task_queue.Get(), [&] { auto handle = RepeatingTaskHandle::Start(task_queue.get(), [&] {
if (++counter >= kShortIntervalCount) if (++counter >= kShortIntervalCount)
return kLongInterval; return kLongInterval;
return kShortInterval; return kShortInterval;
@ -101,7 +101,7 @@ TEST(ExternalTimeControllerTest, TaskIsStoppedOnStop) {
time_simulation.AdvanceTime(kShortInterval * (kShortIntervalCount + kMargin)); time_simulation.AdvanceTime(kShortInterval * (kShortIntervalCount + kMargin));
EXPECT_EQ(counter.load(), kShortIntervalCount); EXPECT_EQ(counter.load(), kShortIntervalCount);
task_queue.PostTask( task_queue->PostTask(
[handle = std::move(handle)]() mutable { handle.Stop(); }); [handle = std::move(handle)]() mutable { handle.Stop(); });
// Sleep long enough that the task would run at least once more if not // Sleep long enough that the task would run at least once more if not
@ -114,13 +114,13 @@ TEST(ExternalTimeControllerTest, TaskCanStopItself) {
std::atomic_int counter(0); std::atomic_int counter(0);
FakeAlarm alarm(kStartTime); FakeAlarm alarm(kStartTime);
ExternalTimeController time_simulation(&alarm); ExternalTimeController time_simulation(&alarm);
rtc::TaskQueue task_queue( std::unique_ptr<TaskQueueBase, TaskQueueDeleter> task_queue =
time_simulation.GetTaskQueueFactory()->CreateTaskQueue( time_simulation.GetTaskQueueFactory()->CreateTaskQueue(
"TestQueue", TaskQueueFactory::Priority::NORMAL)); "TestQueue", TaskQueueFactory::Priority::NORMAL);
RepeatingTaskHandle handle; RepeatingTaskHandle handle;
task_queue.PostTask([&] { task_queue->PostTask([&] {
handle = RepeatingTaskHandle::Start(task_queue.Get(), [&] { handle = RepeatingTaskHandle::Start(task_queue.get(), [&] {
++counter; ++counter;
handle.Stop(); handle.Stop();
return TimeDelta::Millis(2); return TimeDelta::Millis(2);
@ -134,12 +134,12 @@ TEST(ExternalTimeControllerTest, YieldForTask) {
FakeAlarm alarm(kStartTime); FakeAlarm alarm(kStartTime);
ExternalTimeController time_simulation(&alarm); ExternalTimeController time_simulation(&alarm);
rtc::TaskQueue task_queue( std::unique_ptr<TaskQueueBase, TaskQueueDeleter> task_queue =
time_simulation.GetTaskQueueFactory()->CreateTaskQueue( time_simulation.GetTaskQueueFactory()->CreateTaskQueue(
"TestQueue", TaskQueueFactory::Priority::NORMAL)); "TestQueue", TaskQueueFactory::Priority::NORMAL);
rtc::Event event; rtc::Event event;
task_queue.PostTask([&] { event.Set(); }); task_queue->PostTask([&] { event.Set(); });
EXPECT_TRUE(event.Wait(TimeDelta::Millis(200))); EXPECT_TRUE(event.Wait(TimeDelta::Millis(200)));
} }
@ -147,16 +147,16 @@ TEST(ExternalTimeControllerTest, TasksYieldToEachOther) {
FakeAlarm alarm(kStartTime); FakeAlarm alarm(kStartTime);
ExternalTimeController time_simulation(&alarm); ExternalTimeController time_simulation(&alarm);
rtc::TaskQueue task_queue( std::unique_ptr<TaskQueueBase, TaskQueueDeleter> task_queue =
time_simulation.GetTaskQueueFactory()->CreateTaskQueue( time_simulation.GetTaskQueueFactory()->CreateTaskQueue(
"TestQueue", TaskQueueFactory::Priority::NORMAL)); "TestQueue", TaskQueueFactory::Priority::NORMAL);
rtc::TaskQueue other_queue( std::unique_ptr<TaskQueueBase, TaskQueueDeleter> other_queue =
time_simulation.GetTaskQueueFactory()->CreateTaskQueue( time_simulation.GetTaskQueueFactory()->CreateTaskQueue(
"OtherQueue", TaskQueueFactory::Priority::NORMAL)); "OtherQueue", TaskQueueFactory::Priority::NORMAL);
task_queue.PostTask([&] { task_queue->PostTask([&] {
rtc::Event event; rtc::Event event;
other_queue.PostTask([&] { event.Set(); }); other_queue->PostTask([&] { event.Set(); });
EXPECT_TRUE(event.Wait(TimeDelta::Millis(200))); EXPECT_TRUE(event.Wait(TimeDelta::Millis(200)));
}); });
@ -167,11 +167,11 @@ TEST(ExternalTimeControllerTest, CurrentTaskQueue) {
FakeAlarm alarm(kStartTime); FakeAlarm alarm(kStartTime);
ExternalTimeController time_simulation(&alarm); ExternalTimeController time_simulation(&alarm);
rtc::TaskQueue task_queue( std::unique_ptr<TaskQueueBase, TaskQueueDeleter> task_queue =
time_simulation.GetTaskQueueFactory()->CreateTaskQueue( time_simulation.GetTaskQueueFactory()->CreateTaskQueue(
"TestQueue", TaskQueueFactory::Priority::NORMAL)); "TestQueue", TaskQueueFactory::Priority::NORMAL);
task_queue.PostTask([&] { EXPECT_TRUE(task_queue.IsCurrent()); }); task_queue->PostTask([&] { EXPECT_TRUE(task_queue->IsCurrent()); });
time_simulation.AdvanceTime(TimeDelta::Millis(10)); time_simulation.AdvanceTime(TimeDelta::Millis(10));
} }

36
test/time_controller/simulated_time_controller_unittest.cc
View File

@ -13,9 +13,9 @@
#include <atomic> #include <atomic>
#include <memory> #include <memory>
#include "api/task_queue/task_queue_base.h"
#include "api/units/time_delta.h" #include "api/units/time_delta.h"
#include "rtc_base/event.h" #include "rtc_base/event.h"
#include "rtc_base/task_queue.h"
#include "rtc_base/task_queue_for_test.h" #include "rtc_base/task_queue_for_test.h"
#include "rtc_base/task_utils/repeating_task.h" #include "rtc_base/task_utils/repeating_task.h"
#include "test/gmock.h" #include "test/gmock.h"
@ -39,11 +39,11 @@ TEST(SimulatedTimeControllerTest, TaskIsStoppedOnStop) {
const int kShortIntervalCount = 4; const int kShortIntervalCount = 4;
const int kMargin = 1; const int kMargin = 1;
GlobalSimulatedTimeController time_simulation(kStartTime); GlobalSimulatedTimeController time_simulation(kStartTime);
rtc::TaskQueue task_queue( std::unique_ptr<TaskQueueBase, TaskQueueDeleter> task_queue =
time_simulation.GetTaskQueueFactory()->CreateTaskQueue( time_simulation.GetTaskQueueFactory()->CreateTaskQueue(
"TestQueue", TaskQueueFactory::Priority::NORMAL)); "TestQueue", TaskQueueFactory::Priority::NORMAL);
std::atomic_int counter(0); std::atomic_int counter(0);
auto handle = RepeatingTaskHandle::Start(task_queue.Get(), [&] { auto handle = RepeatingTaskHandle::Start(task_queue.get(), [&] {
if (++counter >= kShortIntervalCount) if (++counter >= kShortIntervalCount)
return kLongInterval; return kLongInterval;
return kShortInterval; return kShortInterval;
@ -52,7 +52,7 @@ TEST(SimulatedTimeControllerTest, TaskIsStoppedOnStop) {
time_simulation.AdvanceTime(kShortInterval * (kShortIntervalCount + kMargin)); time_simulation.AdvanceTime(kShortInterval * (kShortIntervalCount + kMargin));
EXPECT_EQ(counter.load(), kShortIntervalCount); EXPECT_EQ(counter.load(), kShortIntervalCount);
task_queue.PostTask( task_queue->PostTask(
[handle = std::move(handle)]() mutable { handle.Stop(); }); [handle = std::move(handle)]() mutable { handle.Stop(); });
// Sleep long enough that the task would run at least once more if not // Sleep long enough that the task would run at least once more if not
@ -64,13 +64,13 @@ TEST(SimulatedTimeControllerTest, TaskIsStoppedOnStop) {
TEST(SimulatedTimeControllerTest, TaskCanStopItself) { TEST(SimulatedTimeControllerTest, TaskCanStopItself) {
std::atomic_int counter(0); std::atomic_int counter(0);
GlobalSimulatedTimeController time_simulation(kStartTime); GlobalSimulatedTimeController time_simulation(kStartTime);
rtc::TaskQueue task_queue( std::unique_ptr<TaskQueueBase, TaskQueueDeleter> task_queue =
time_simulation.GetTaskQueueFactory()->CreateTaskQueue( time_simulation.GetTaskQueueFactory()->CreateTaskQueue(
"TestQueue", TaskQueueFactory::Priority::NORMAL)); "TestQueue", TaskQueueFactory::Priority::NORMAL);
RepeatingTaskHandle handle; RepeatingTaskHandle handle;
task_queue.PostTask([&] { task_queue->PostTask([&] {
handle = RepeatingTaskHandle::Start(task_queue.Get(), [&] { handle = RepeatingTaskHandle::Start(task_queue.get(), [&] {
++counter; ++counter;
handle.Stop(); handle.Stop();
return TimeDelta::Millis(2); return TimeDelta::Millis(2);
@ -86,29 +86,29 @@ TEST(SimulatedTimeControllerTest, Example) {
void DoPeriodicTask() {} void DoPeriodicTask() {}
TimeDelta TimeUntilNextRun() { return TimeDelta::Millis(100); } TimeDelta TimeUntilNextRun() { return TimeDelta::Millis(100); }
void StartPeriodicTask(RepeatingTaskHandle* handle, void StartPeriodicTask(RepeatingTaskHandle* handle,
rtc::TaskQueue* task_queue) { TaskQueueBase* task_queue) {
*handle = RepeatingTaskHandle::Start(task_queue->Get(), [this] { *handle = RepeatingTaskHandle::Start(task_queue, [this] {
DoPeriodicTask(); DoPeriodicTask();
return TimeUntilNextRun(); return TimeUntilNextRun();
}); });
} }
}; };
GlobalSimulatedTimeController time_simulation(kStartTime); GlobalSimulatedTimeController time_simulation(kStartTime);
rtc::TaskQueue task_queue( std::unique_ptr<TaskQueueBase, TaskQueueDeleter> task_queue =
time_simulation.GetTaskQueueFactory()->CreateTaskQueue( time_simulation.GetTaskQueueFactory()->CreateTaskQueue(
"TestQueue", TaskQueueFactory::Priority::NORMAL)); "TestQueue", TaskQueueFactory::Priority::NORMAL);
auto object = std::make_unique<ObjectOnTaskQueue>(); auto object = std::make_unique<ObjectOnTaskQueue>();
// Create and start the periodic task. // Create and start the periodic task.
RepeatingTaskHandle handle; RepeatingTaskHandle handle;
object->StartPeriodicTask(&handle, &task_queue); object->StartPeriodicTask(&handle, task_queue.get());
// Restart the task // Restart the task
task_queue.PostTask( task_queue->PostTask(
[handle = std::move(handle)]() mutable { handle.Stop(); }); [handle = std::move(handle)]() mutable { handle.Stop(); });
object->StartPeriodicTask(&handle, &task_queue); object->StartPeriodicTask(&handle, task_queue.get());
task_queue.PostTask( task_queue->PostTask(
[handle = std::move(handle)]() mutable { handle.Stop(); }); [handle = std::move(handle)]() mutable { handle.Stop(); });
task_queue.PostTask([object = std::move(object)] {}); task_queue->PostTask([object = std::move(object)] {});
} }
TEST(SimulatedTimeControllerTest, DelayTaskRunOnTime) { TEST(SimulatedTimeControllerTest, DelayTaskRunOnTime) {