1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #define private public
18 #include "barrier_handler.h"
19 #undef private
20 #include "appexecfwk_errors.h"
21 #include "default_worker_pool_config.h"
22
23 using namespace testing;
24 using namespace testing::ext;
25 using namespace OHOS::AppExecFwk;
26 using namespace OHOS;
27
28 class BarrierHandlerTest : public testing::Test {
29 public:
30 static void SetUpTestCase();
31 static void TearDownTestCase();
32 void SetUp();
33 void TearDown();
34 };
35
SetUpTestCase()36 void BarrierHandlerTest::SetUpTestCase()
37 {}
38
TearDownTestCase()39 void BarrierHandlerTest::TearDownTestCase()
40 {}
41
SetUp()42 void BarrierHandlerTest::SetUp()
43 {}
44
TearDown()45 void BarrierHandlerTest::TearDown()
46 {}
47
CreateBarrierHandler()48 std::shared_ptr<BarrierHandler> CreateBarrierHandler()
49 {
50 std::shared_ptr<DefaultWorkerPoolConfig> config_ = std::make_shared<DefaultWorkerPoolConfig>();
51 std::shared_ptr<TaskExecutor> executor = std::make_shared<TaskExecutor>(config_);
52 std::shared_ptr<BarrierHandler> barrierHandler = std::make_shared<BarrierHandler>(executor);
53 return barrierHandler;
54 }
55 /**
56 * @tc.number: BarrierHandler_ConstructorTest_001
57 * @tc.name: Constructor
58 * @tc.desc: Test BarrierHandlerTest Constructor.
59 */
60 HWTEST(BarrierHandlerTest, BarrierHandler_ConstructorTest_001, TestSize.Level0)
61 {
62 auto name = std::string("BarrierHandler_ConstructorTest_001");
63 GTEST_LOG_(INFO) << name << " start";
64 std::shared_ptr<BarrierHandler> barrierHandler = CreateBarrierHandler();
65 EXPECT_NE(barrierHandler, nullptr);
66 GTEST_LOG_(INFO) << name << " end";
67 }
68
69 /**
70 * @tc.number: BarrierHandler_interceptTest_001
71 * @tc.name: intercept
72 * @tc.desc: Test BarrierHandler intercept.
73 */
74 HWTEST(BarrierHandlerTest, BarrierHandler_interceptTest_001, TestSize.Level0)
75 {
76 auto name = std::string("BarrierHandler_interceptTest_001");
77 GTEST_LOG_(INFO) << name << " start";
78 std::shared_ptr<BarrierHandler> barrierHandler = CreateBarrierHandler();
__anon238147110102() 79 std::shared_ptr<Runnable> runnable = std::make_shared<Runnable>([&]() { GTEST_LOG_(INFO) << name << " Runnable"; });
80 std::shared_ptr<Task> task = std::make_shared<Task>(runnable, TaskPriority::DEFAULT, nullptr);
81 ErrCode result = barrierHandler->Intercept(task);
82 task->Run();
83 task->AfterTaskExecute();
84 EXPECT_TRUE(result);
85 GTEST_LOG_(INFO) << name << " end";
86 }
87
88 /**
89 * @tc.number: BarrierHandler_interceptTest_002
90 * @tc.name: intercept
91 * @tc.desc: Test BarrierHandler intercept.
92 */
93 HWTEST(BarrierHandlerTest, BarrierHandler_interceptTest_002, TestSize.Level0)
94 {
95 auto name = std::string("BarrierHandler_interceptTest_002");
96 GTEST_LOG_(INFO) << name << " start";
97 std::shared_ptr<BarrierHandler> barrierHandler = CreateBarrierHandler();
98 // add task
__anon238147110202() 99 std::shared_ptr<Runnable> runnable = std::make_shared<Runnable>([&]() {
100 std::this_thread::sleep_for(std::chrono::milliseconds(500));
101 GTEST_LOG_(INFO) << name << " Runnable";
102 });
103 std::shared_ptr<Task> task = std::make_shared<Task>(runnable, TaskPriority::DEFAULT, nullptr);
104 barrierHandler->Intercept(task);
105 // add barrier
106 std::shared_ptr<Runnable> barrierRunnable =
__anon238147110302() 107 std::make_shared<Runnable>([&]() { GTEST_LOG_(INFO) << name << " barrierTask "; });
108 std::shared_ptr<Task> barrierTask = std::make_shared<Task>(barrierRunnable, TaskPriority::DEFAULT, nullptr);
109 barrierHandler->AddBarrier(barrierTask);
110 // add interceptTask
111 std::shared_ptr<Runnable> interceptRunnable =
__anon238147110402() 112 std::make_shared<Runnable>([&]() { GTEST_LOG_(INFO) << name << " interceptRunnable"; });
113 std::shared_ptr<Task> interceptTask = std::make_shared<Task>(interceptRunnable, TaskPriority::DEFAULT, nullptr);
114 // intercept result
115 bool result = barrierHandler->Intercept(interceptTask);
116 EXPECT_TRUE(result);
117 GTEST_LOG_(INFO) << name << " end";
118 }
119
120 /**
121 * @tc.number: BarrierHandler_addBarrierTest_001
122 * @tc.name: addBarrier
123 * @tc.desc: Test BarrierHandler addBarrier.
124 */
125 HWTEST(BarrierHandlerTest, BarrierHandler_addBarrierTest_001, TestSize.Level0)
126 {
127 auto name = std::string("BarrierHandler_interceptTest_002");
128 GTEST_LOG_(INFO) << name << " start";
129 std::shared_ptr<BarrierHandler> barrierHandler = CreateBarrierHandler();
130
131 std::atomic<int> count(0);
132
__anon238147110502() 133 std::shared_ptr<Runnable> barrierRunnable = std::make_shared<Runnable>([&]() {
134 std::this_thread::sleep_for(std::chrono::milliseconds(300));
135 count.fetch_add(1);
136 GTEST_LOG_(INFO) << name << " add barrier Task ";
137 });
138 std::shared_ptr<Task> barrierTask = std::make_shared<Task>(barrierRunnable, TaskPriority::DEFAULT, nullptr);
139 barrierHandler->AddBarrier(barrierTask);
140 EXPECT_EQ(count.load(), 0);
141 std::this_thread::sleep_for(std::chrono::milliseconds(600));
142 EXPECT_EQ(count.load(), 1);
143 GTEST_LOG_(INFO) << name << " end";
144 }
145
146 /**
147 * @tc.number: BarrierHandler_addBarrierTest_002
148 * @tc.name: addBarrier
149 * @tc.desc: Test BarrierHandler barrier not execute now.
150 */
151 HWTEST(BarrierHandlerTest, BarrierHandler_addBarrierTest_002, TestSize.Level0)
152 {
153 auto name = std::string("BarrierHandler_addBarrierTest_002");
154 GTEST_LOG_(INFO) << name << " start";
155 std::shared_ptr<BarrierHandler> barrierHandler = CreateBarrierHandler();
156
157 std::atomic<int> count(0);
158
__anon238147110602() 159 std::shared_ptr<Runnable> taskRun1 = std::make_shared<Runnable>([&]() {
160 std::this_thread::sleep_for(std::chrono::milliseconds(300));
161 count.fetch_add(1);
162 GTEST_LOG_(INFO) << name << " add barrier Task ";
163 });
164 std::shared_ptr<Task> task1 = std::make_shared<Task>(taskRun1, TaskPriority::DEFAULT, nullptr);
165 barrierHandler->Intercept(task1);
__anon238147110702() 166 std::shared_ptr<Runnable> taskRun2 = std::make_shared<Runnable>([&]() {
167 count.fetch_add(1);
168 GTEST_LOG_(INFO) << name << " add barrier Task ";
169 });
170 std::shared_ptr<Task> task2 = std::make_shared<Task>(taskRun2, TaskPriority::DEFAULT, nullptr);
171 barrierHandler->Intercept(task2);
172
__anon238147110802() 173 std::shared_ptr<Runnable> barrierRunnable = std::make_shared<Runnable>([&]() {
174 std::this_thread::sleep_for(std::chrono::milliseconds(300));
175 EXPECT_EQ(count.load(), 2);
176 GTEST_LOG_(INFO) << name << " add barrier Task ";
177 });
178 std::shared_ptr<Task> barrierTask = std::make_shared<Task>(barrierRunnable, TaskPriority::DEFAULT, nullptr);
179 barrierHandler->AddBarrier(barrierTask);
180 GTEST_LOG_(INFO) << name << " end";
181 }