base/threading/task_runner_handle_unittest.cc - Issue 2042383004: Introduce TaskRunnerHandle.

Side by Side Diff: base/threading/task_runner_handle_unittest.cc

Issue 2042383004: Introduce TaskRunnerHandle. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: tweak comments Created 4 years, 6 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

OLD	NEW
(Empty)
	1 // Copyright 2015 The Chromium Authors. All rights reserved.

	2 // Use of this source code is governed by a BSD-style license that can be

	3 // found in the LICENSE file.

	4

	5 #include "base/threading/task_runner_handle.h"

	6

	7 #include "base/memory/ref_counted.h"

	8 #include "base/sequenced_task_runner.h"

	9 #include "base/single_thread_task_runner.h"

	10 #include "base/task_runner.h"

	11 #include "base/test/test_simple_task_runner.h"

	12 #include "base/threading/sequenced_task_runner_handle.h"

	13 #include "base/threading/thread_task_runner_handle.h"

	14 #include "testing/gtest/include/gtest/gtest.h"

	15

	16 namespace base {

	17 namespace {

	18

	19 } // namespace

	20

	21 TEST(TaskRunnerHandleTest, TaskScope) {

	22 scoped_refptr<TaskRunner> test_task_runner(new TestSimpleTaskRunner);

	23 EXPECT_FALSE(TaskRunnerHandle::HasTaskScope());

	24 EXPECT_FALSE(TaskRunnerHandle::HasSequencedTaskScope());

	25 EXPECT_FALSE(TaskRunnerHandle::HasSingleThreadTaskScope());

	26 {

	27 TaskRunnerHandle::TaskScope task_scope(test_task_runner);

	28

	29 EXPECT_TRUE(TaskRunnerHandle::HasTaskScope());

	30 EXPECT_FALSE(TaskRunnerHandle::HasSequencedTaskScope());

	31 EXPECT_FALSE(TaskRunnerHandle::HasSingleThreadTaskScope());

	32

	33 EXPECT_EQ(test_task_runner, TaskRunnerHandle::Get());

	34 }

	35 EXPECT_FALSE(TaskRunnerHandle::HasTaskScope());

	36 EXPECT_FALSE(TaskRunnerHandle::HasSequencedTaskScope());

	37 EXPECT_FALSE(TaskRunnerHandle::HasSingleThreadTaskScope());

	38 }

	39

	40 TEST(TaskRunnerHandleTest, SequencedTaskScope) {

	41 scoped_refptr<SequencedTaskRunner> test_task_runner(new TestSimpleTaskRunner);

	42 EXPECT_FALSE(TaskRunnerHandle::HasTaskScope());

	43 EXPECT_FALSE(TaskRunnerHandle::HasSequencedTaskScope());

	44 EXPECT_FALSE(TaskRunnerHandle::HasSingleThreadTaskScope());

	45 {

	46 TaskRunnerHandle::SequencedTaskScope task_scope(test_task_runner);

	47

	48 EXPECT_TRUE(TaskRunnerHandle::HasTaskScope());

	49 EXPECT_TRUE(TaskRunnerHandle::HasSequencedTaskScope());

	50 EXPECT_FALSE(TaskRunnerHandle::HasSingleThreadTaskScope());

	51

	52 EXPECT_EQ(test_task_runner, TaskRunnerHandle::Get());

	53 EXPECT_EQ(test_task_runner, TaskRunnerHandle::GetSequenced());

	54 }

	55 EXPECT_FALSE(TaskRunnerHandle::HasTaskScope());

	56 EXPECT_FALSE(TaskRunnerHandle::HasSequencedTaskScope());

	57 EXPECT_FALSE(TaskRunnerHandle::HasSingleThreadTaskScope());

	58 }

	59

	60 TEST(TaskRunnerHandleTest, SingleThreadTaskScope) {

	61 scoped_refptr<SingleThreadTaskRunner> test_task_runner(

	62 new TestSimpleTaskRunner);

	63 EXPECT_FALSE(TaskRunnerHandle::HasTaskScope());

	64 EXPECT_FALSE(TaskRunnerHandle::HasSequencedTaskScope());

	65 EXPECT_FALSE(TaskRunnerHandle::HasSingleThreadTaskScope());

	66 {

	67 TaskRunnerHandle::SingleThreadTaskScope task_scope(test_task_runner);

	68

	69 EXPECT_TRUE(TaskRunnerHandle::HasTaskScope());

	70 EXPECT_TRUE(TaskRunnerHandle::HasSequencedTaskScope());

	71 EXPECT_TRUE(TaskRunnerHandle::HasSingleThreadTaskScope());

	72

	73 EXPECT_EQ(test_task_runner, TaskRunnerHandle::Get());

	74 EXPECT_EQ(test_task_runner, TaskRunnerHandle::GetSequenced());

	75 EXPECT_EQ(test_task_runner, TaskRunnerHandle::GetSingleThreaded());

	76 }

	77 EXPECT_FALSE(TaskRunnerHandle::HasTaskScope());

	78 EXPECT_FALSE(TaskRunnerHandle::HasSequencedTaskScope());

	79 EXPECT_FALSE(TaskRunnerHandle::HasSingleThreadTaskScope());

	80 }

	81

	82 TEST(TaskRunnerHandleTest, SequencedTaskRunnerHandleSupport) {

	83 scoped_refptr<SequencedTaskRunner> test_task_runner(new TestSimpleTaskRunner);

	84 EXPECT_FALSE(TaskRunnerHandle::HasTaskScope());

	85 EXPECT_FALSE(TaskRunnerHandle::HasSequencedTaskScope());

	86 EXPECT_FALSE(TaskRunnerHandle::HasSingleThreadTaskScope());

	87 {

	88 SequencedTaskRunnerHandle handle(test_task_runner);

	89

	90 EXPECT_TRUE(TaskRunnerHandle::HasTaskScope());

	91 EXPECT_TRUE(TaskRunnerHandle::HasSequencedTaskScope());

	92 EXPECT_FALSE(TaskRunnerHandle::HasSingleThreadTaskScope());

	93

	94 EXPECT_EQ(test_task_runner, TaskRunnerHandle::Get());

	95 EXPECT_EQ(test_task_runner, TaskRunnerHandle::GetSequenced());

	96 }

	97 EXPECT_FALSE(TaskRunnerHandle::HasTaskScope());

	98 EXPECT_FALSE(TaskRunnerHandle::HasSequencedTaskScope());

	99 EXPECT_FALSE(TaskRunnerHandle::HasSingleThreadTaskScope());

	100 }

	101

	102 TEST(TaskRunnerHandleTest, ThreadTaskRunnerHandleSupport) {

	103 scoped_refptr<SingleThreadTaskRunner> test_task_runner(

	104 new TestSimpleTaskRunner);

	105 EXPECT_FALSE(TaskRunnerHandle::HasTaskScope());

	106 EXPECT_FALSE(TaskRunnerHandle::HasSequencedTaskScope());

	107 EXPECT_FALSE(TaskRunnerHandle::HasSingleThreadTaskScope());

	108 {

	109 ThreadTaskRunnerHandle handle(test_task_runner);

	110

	111 EXPECT_TRUE(TaskRunnerHandle::HasTaskScope());

	112 EXPECT_TRUE(TaskRunnerHandle::HasSequencedTaskScope());

	113 EXPECT_TRUE(TaskRunnerHandle::HasSingleThreadTaskScope());

	114

	115 EXPECT_EQ(test_task_runner, TaskRunnerHandle::Get());

	116 EXPECT_EQ(test_task_runner, TaskRunnerHandle::GetSequenced());

	117 EXPECT_EQ(test_task_runner, TaskRunnerHandle::GetSingleThreaded());

	118 }

	119 EXPECT_FALSE(TaskRunnerHandle::HasTaskScope());

	120 EXPECT_FALSE(TaskRunnerHandle::HasSequencedTaskScope());

	121 EXPECT_FALSE(TaskRunnerHandle::HasSingleThreadTaskScope());

	122 }

	123

	124 } // namespace base

OLD	NEW