| /* |
| * Copyright 2016 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 <memory> |
| #include <vector> |
| |
| #include "webrtc/base/bind.h" |
| #include "webrtc/base/event.h" |
| #include "webrtc/base/gunit.h" |
| #include "webrtc/base/task_queue.h" |
| #include "webrtc/base/timeutils.h" |
| |
| namespace rtc { |
| |
| namespace { |
| void CheckCurrent(const char* expected_queue, Event* signal, TaskQueue* queue) { |
| EXPECT_TRUE(TaskQueue::IsCurrent(expected_queue)); |
| EXPECT_TRUE(queue->IsCurrent()); |
| if (signal) |
| signal->Set(); |
| } |
| |
| } // namespace |
| |
| TEST(TaskQueueTest, Construct) { |
| static const char kQueueName[] = "Construct"; |
| TaskQueue queue(kQueueName); |
| EXPECT_FALSE(queue.IsCurrent()); |
| } |
| |
| TEST(TaskQueueTest, PostAndCheckCurrent) { |
| static const char kQueueName[] = "PostAndCheckCurrent"; |
| TaskQueue queue(kQueueName); |
| |
| // We're not running a task, so there shouldn't be a current queue. |
| EXPECT_FALSE(queue.IsCurrent()); |
| EXPECT_FALSE(TaskQueue::Current()); |
| |
| Event event(false, false); |
| queue.PostTask(Bind(&CheckCurrent, kQueueName, &event, &queue)); |
| EXPECT_TRUE(event.Wait(1000)); |
| } |
| |
| TEST(TaskQueueTest, PostCustomTask) { |
| static const char kQueueName[] = "PostCustomImplementation"; |
| TaskQueue queue(kQueueName); |
| |
| Event event(false, false); |
| |
| class CustomTask : public QueuedTask { |
| public: |
| explicit CustomTask(Event* event) : event_(event) {} |
| |
| private: |
| bool Run() override { |
| event_->Set(); |
| return false; // Never allows the task to be deleted by the queue. |
| } |
| |
| Event* const event_; |
| } my_task(&event); |
| |
| // Please don't do this in production code! :) |
| queue.PostTask(std::unique_ptr<QueuedTask>(&my_task)); |
| EXPECT_TRUE(event.Wait(1000)); |
| } |
| |
| TEST(TaskQueueTest, PostLambda) { |
| static const char kQueueName[] = "PostLambda"; |
| TaskQueue queue(kQueueName); |
| |
| Event event(false, false); |
| queue.PostTask([&event]() { event.Set(); }); |
| EXPECT_TRUE(event.Wait(1000)); |
| } |
| |
| TEST(TaskQueueTest, PostFromQueue) { |
| static const char kQueueName[] = "PostFromQueue"; |
| TaskQueue queue(kQueueName); |
| |
| Event event(false, false); |
| queue.PostTask( |
| [&event, &queue]() { queue.PostTask([&event]() { event.Set(); }); }); |
| EXPECT_TRUE(event.Wait(1000)); |
| } |
| |
| TEST(TaskQueueTest, PostDelayed) { |
| static const char kQueueName[] = "PostDelayed"; |
| TaskQueue queue(kQueueName); |
| |
| Event event(false, false); |
| uint32_t start = Time(); |
| queue.PostDelayedTask(Bind(&CheckCurrent, kQueueName, &event, &queue), 100); |
| EXPECT_TRUE(event.Wait(1000)); |
| uint32_t end = Time(); |
| EXPECT_GE(end - start, 100u); |
| EXPECT_NEAR(end - start, 200u, 100u); // Accept 100-300. |
| } |
| |
| TEST(TaskQueueTest, PostMultipleDelayed) { |
| static const char kQueueName[] = "PostMultipleDelayed"; |
| TaskQueue queue(kQueueName); |
| |
| std::vector<std::unique_ptr<Event>> events; |
| for (int i = 0; i < 10; ++i) { |
| events.push_back(std::unique_ptr<Event>(new Event(false, false))); |
| queue.PostDelayedTask( |
| Bind(&CheckCurrent, kQueueName, events.back().get(), &queue), 10); |
| } |
| |
| for (const auto& e : events) |
| EXPECT_TRUE(e->Wait(100)); |
| } |
| |
| TEST(TaskQueueTest, PostDelayedAfterDestruct) { |
| static const char kQueueName[] = "PostDelayedAfterDestruct"; |
| Event event(false, false); |
| { |
| TaskQueue queue(kQueueName); |
| queue.PostDelayedTask(Bind(&CheckCurrent, kQueueName, &event, &queue), 100); |
| } |
| EXPECT_FALSE(event.Wait(200)); // Task should not run. |
| } |
| |
| TEST(TaskQueueTest, PostAndReply) { |
| static const char kPostQueue[] = "PostQueue"; |
| static const char kReplyQueue[] = "ReplyQueue"; |
| TaskQueue post_queue(kPostQueue); |
| TaskQueue reply_queue(kReplyQueue); |
| |
| Event event(false, false); |
| post_queue.PostTaskAndReply( |
| Bind(&CheckCurrent, kPostQueue, nullptr, &post_queue), |
| Bind(&CheckCurrent, kReplyQueue, &event, &reply_queue), &reply_queue); |
| EXPECT_TRUE(event.Wait(1000)); |
| } |
| |
| TEST(TaskQueueTest, PostAndReuse) { |
| static const char kPostQueue[] = "PostQueue"; |
| static const char kReplyQueue[] = "ReplyQueue"; |
| TaskQueue post_queue(kPostQueue); |
| TaskQueue reply_queue(kReplyQueue); |
| |
| int call_count = 0; |
| |
| class ReusedTask : public QueuedTask { |
| public: |
| ReusedTask(int* counter, TaskQueue* reply_queue, Event* event) |
| : counter_(counter), reply_queue_(reply_queue), event_(event) { |
| EXPECT_EQ(0, *counter_); |
| } |
| |
| private: |
| bool Run() override { |
| if (++(*counter_) == 1) { |
| std::unique_ptr<QueuedTask> myself(this); |
| reply_queue_->PostTask(std::move(myself)); |
| // At this point, the object is owned by reply_queue_ and it's |
| // theoratically possible that the object has been deleted (e.g. if |
| // posting wasn't possible). So, don't touch any member variables here. |
| |
| // Indicate to the current queue that ownership has been transferred. |
| return false; |
| } else { |
| EXPECT_EQ(2, *counter_); |
| EXPECT_TRUE(reply_queue_->IsCurrent()); |
| event_->Set(); |
| return true; // Indicate that the object should be deleted. |
| } |
| } |
| |
| int* const counter_; |
| TaskQueue* const reply_queue_; |
| Event* const event_; |
| }; |
| |
| Event event(false, false); |
| std::unique_ptr<QueuedTask> task( |
| new ReusedTask(&call_count, &reply_queue, &event)); |
| |
| post_queue.PostTask(std::move(task)); |
| EXPECT_TRUE(event.Wait(1000)); |
| } |
| |
| TEST(TaskQueueTest, PostAndReplyLambda) { |
| static const char kPostQueue[] = "PostQueue"; |
| static const char kReplyQueue[] = "ReplyQueue"; |
| TaskQueue post_queue(kPostQueue); |
| TaskQueue reply_queue(kReplyQueue); |
| |
| Event event(false, false); |
| bool my_flag = false; |
| post_queue.PostTaskAndReply([&my_flag]() { my_flag = true; }, |
| [&event]() { event.Set(); }, &reply_queue); |
| EXPECT_TRUE(event.Wait(1000)); |
| EXPECT_TRUE(my_flag); |
| } |
| |
| void TestPostTaskAndReply(TaskQueue* work_queue, |
| const char* work_queue_name, |
| Event* event) { |
| ASSERT_FALSE(work_queue->IsCurrent()); |
| work_queue->PostTaskAndReply( |
| Bind(&CheckCurrent, work_queue_name, nullptr, work_queue), |
| NewClosure([event]() { event->Set(); })); |
| } |
| |
| // Does a PostTaskAndReply from within a task to post and reply to the current |
| // queue. All in all there will be 3 tasks posted and run. |
| TEST(TaskQueueTest, PostAndReply2) { |
| static const char kQueueName[] = "PostAndReply2"; |
| static const char kWorkQueueName[] = "PostAndReply2_Worker"; |
| TaskQueue queue(kQueueName); |
| TaskQueue work_queue(kWorkQueueName); |
| |
| Event event(false, false); |
| queue.PostTask( |
| Bind(&TestPostTaskAndReply, &work_queue, kWorkQueueName, &event)); |
| EXPECT_TRUE(event.Wait(1000)); |
| } |
| |
| // Tests posting more messages than a queue can queue up. |
| // In situations like that, tasks will get dropped. |
| TEST(TaskQueueTest, PostALot) { |
| // To destruct the event after the queue has gone out of scope. |
| Event event(false, false); |
| |
| int tasks_executed = 0; |
| int tasks_cleaned_up = 0; |
| static const int kTaskCount = 0xffff; |
| |
| { |
| static const char kQueueName[] = "PostALot"; |
| TaskQueue queue(kQueueName); |
| |
| // On linux, the limit of pending bytes in the pipe buffer is 0xffff. |
| // So here we post a total of 0xffff+1 messages, which triggers a failure |
| // case inside of the libevent queue implementation. |
| |
| queue.PostTask([&event]() { event.Wait(Event::kForever); }); |
| for (int i = 0; i < kTaskCount; ++i) |
| queue.PostTask(NewClosure([&tasks_executed]() { ++tasks_executed; }, |
| [&tasks_cleaned_up]() { ++tasks_cleaned_up; })); |
| event.Set(); // Unblock the first task. |
| } |
| |
| EXPECT_GE(tasks_cleaned_up, tasks_executed); |
| EXPECT_EQ(kTaskCount, tasks_cleaned_up); |
| } |
| |
| } // namespace rtc |