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

Use task queue factory factory as parameter for TaskQueueTest

Browse Source 
The new parameter simplify TaskQueueFactory lifetime and
allows insertion of per TestCase state

Bug: webrtc:10191
Change-Id: If4948df2756580957052b2b333b5c12cf4914d55
Reviewed-on: https://webrtc-review.googlesource.com/c/121648
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#26583}
This commit is contained in:
Danil Chapovalov 2019-02-06 16:00:44 +01:00 committed by Commit Bot
parent 0041fe53dc
commit 710f3d3e44
2 changed files with 36 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
api/task_queue/task_queue_test.cc
View File

@ -19,20 +19,22 @@ namespace webrtc {
namespace {
std::unique_ptr<TaskQueueBase, TaskQueueDeleter> CreateTaskQueue(
TaskQueueFactory* factory,
const std::unique_ptr<webrtc::TaskQueueFactory>& factory,
absl::string_view task_queue_name,
TaskQueueFactory::Priority priority = TaskQueueFactory::Priority::NORMAL) {
return factory->CreateTaskQueue(task_queue_name, priority);
}
TEST_P(TaskQueueTest, Construct) {
auto queue = CreateTaskQueue(GetParam(), "Construct");
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
auto queue = CreateTaskQueue(factory, "Construct");
EXPECT_FALSE(queue->IsCurrent());
}
TEST_P(TaskQueueTest, PostAndCheckCurrent) {
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
rtc::Event event;
auto queue = CreateTaskQueue(GetParam(), "PostAndCheckCurrent");
auto queue = CreateTaskQueue(factory, "PostAndCheckCurrent");
// We're not running a task, so there shouldn't be a current queue.
EXPECT_FALSE(queue->IsCurrent());
@ -46,8 +48,9 @@ TEST_P(TaskQueueTest, PostAndCheckCurrent) {
}
TEST_P(TaskQueueTest, PostCustomTask) {
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
rtc::Event ran;
auto queue = CreateTaskQueue(GetParam(), "PostCustomImplementation");
auto queue = CreateTaskQueue(factory, "PostCustomImplementation");
class CustomTask : public QueuedTask {
public:
@ -67,16 +70,18 @@ TEST_P(TaskQueueTest, PostCustomTask) {
}
TEST_P(TaskQueueTest, PostDelayedZero) {
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
rtc::Event event;
auto queue = CreateTaskQueue(GetParam(), "PostDelayedZero");
auto queue = CreateTaskQueue(factory, "PostDelayedZero");
queue->PostDelayedTask(rtc::NewClosure([&event] { event.Set(); }), 0);
EXPECT_TRUE(event.Wait(1000));
}
TEST_P(TaskQueueTest, PostFromQueue) {
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
rtc::Event event;
auto queue = CreateTaskQueue(GetParam(), "PostFromQueue");
auto queue = CreateTaskQueue(factory, "PostFromQueue");
queue->PostTask(rtc::NewClosure([&event, &queue] {
queue->PostTask(rtc::NewClosure([&event] { event.Set(); }));
@ -85,9 +90,10 @@ TEST_P(TaskQueueTest, PostFromQueue) {
}
TEST_P(TaskQueueTest, PostDelayed) {
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
rtc::Event event;
auto queue = CreateTaskQueue(GetParam(), "PostDelayed",
TaskQueueFactory::Priority::HIGH);
auto queue =
CreateTaskQueue(factory, "PostDelayed", TaskQueueFactory::Priority::HIGH);
int64_t start = rtc::TimeMillis();
queue->PostDelayedTask(rtc::NewClosure([&event, &queue] {
@ -105,7 +111,8 @@ TEST_P(TaskQueueTest, PostDelayed) {
}
TEST_P(TaskQueueTest, PostMultipleDelayed) {
auto queue = CreateTaskQueue(GetParam(), "PostMultipleDelayed");
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
auto queue = CreateTaskQueue(factory, "PostMultipleDelayed");
std::vector<rtc::Event> events(100);
for (int i = 0; i < 100; ++i) {
@ -122,9 +129,10 @@ TEST_P(TaskQueueTest, PostMultipleDelayed) {
}
TEST_P(TaskQueueTest, PostDelayedAfterDestruct) {
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
rtc::Event run;
rtc::Event deleted;
auto queue = CreateTaskQueue(GetParam(), "PostDelayedAfterDestruct");
auto queue = CreateTaskQueue(factory, "PostDelayedAfterDestruct");
queue->PostDelayedTask(
rtc::NewClosure([&run] { run.Set(); }, [&deleted] { deleted.Set(); }),
100);
@ -136,9 +144,10 @@ TEST_P(TaskQueueTest, PostDelayedAfterDestruct) {
}
TEST_P(TaskQueueTest, PostAndReuse) {
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
rtc::Event event;
auto post_queue = CreateTaskQueue(GetParam(), "PostQueue");
auto reply_queue = CreateTaskQueue(GetParam(), "ReplyQueue");
auto post_queue = CreateTaskQueue(factory, "PostQueue");
auto reply_queue = CreateTaskQueue(factory, "ReplyQueue");
int call_count = 0;
@ -181,6 +190,7 @@ TEST_P(TaskQueueTest, PostAndReuse) {
// Tests posting more messages than a queue can queue up.
// In situations like that, tasks will get dropped.
TEST_P(TaskQueueTest, PostALot) {
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
// To destruct the event after the queue has gone out of scope.
rtc::Event event;
@ -189,7 +199,7 @@ TEST_P(TaskQueueTest, PostALot) {
static const int kTaskCount = 0xffff;
{
auto queue = CreateTaskQueue(GetParam(), "PostALot");
auto queue = CreateTaskQueue(factory, "PostALot");
// 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
@ -219,12 +229,13 @@ TEST_P(TaskQueueTest, PostALot) {
// unit test, run it under TSan or some other tool that is able to
// directly detect data races.
TEST_P(TaskQueueTest, PostTwoWithSharedUnprotectedState) {
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
struct SharedState {
// First task will set this value to 1 and second will assert it.
int state = 0;
} state;
auto queue = CreateTaskQueue(GetParam(), "PostTwoWithSharedUnprotectedState");
auto queue = CreateTaskQueue(factory, "PostTwoWithSharedUnprotectedState");
rtc::Event done;
queue->PostTask(rtc::NewClosure([&state, &queue, &done] {
// Post tasks from queue to guarantee, that 1st task won't be

14
api/task_queue/task_queue_test.h
View File

@ -10,6 +10,9 @@
#ifndef API_TASK_QUEUE_TASK_QUEUE_TEST_H_
#define API_TASK_QUEUE_TASK_QUEUE_TEST_H_
#include <functional>
#include <memory>
#include "api/task_queue/task_queue_factory.h"
#include "test/gtest.h"
@ -20,12 +23,17 @@ namespace webrtc {
//
// namespace {
//
// using ::testing::Values;
// using ::webrtc::TaskQueueTest;
// webrtc::TaskQueueFactory* MyFactory();
// INSTANTIATE_TEST_SUITE_P(My, TaskQueueTest, ::testing::Values(MyFactory()));
//
// std::unique_ptr<webrtc::TaskQueueFactory> CreateMyFactory();
//
// INSTANTIATE_TEST_SUITE_P(My, TaskQueueTest, Values(CreateMyFactory));
//
// } // namespace
class TaskQueueTest : public ::testing::TestWithParam<TaskQueueFactory*> {};
class TaskQueueTest : public ::testing::TestWithParam<
std::function<std::unique_ptr<TaskQueueFactory>()>> {
};
} // namespace webrtc