1 /*
2 * Copyright (c) 2024 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 #include <gtest/hwext/gtest-multithread.h>
18
19 #include <atomic>
20 #include <string>
21
22 #include "ws_ffrt_helper.h"
23
24 using namespace testing::ext;
25 using namespace testing::mt;
26
27 namespace OHOS::Rosen {
28 static std::atomic<int> g_taskId(0);
29 static WSFFRTHelper* g_wsFfrtHelper = nullptr;
30 static constexpr size_t TASK_NUM = 1000;
31
32 class WSFFRTHelperTest : public testing::Test {
33 protected:
34 static void SetUpTestCase();
35 static void TearDownTestCase();
36 void SetUp() override;
37 void TearDown() override;
38
39 private:
40 WSFFRTHelper* wsFfrtHelper_;
41 };
42
SetUpTestCase()43 void WSFFRTHelperTest::SetUpTestCase()
44 {
45 }
46
TearDownTestCase()47 void WSFFRTHelperTest::TearDownTestCase()
48 {
49 }
50
SetUp()51 void WSFFRTHelperTest::SetUp()
52 {
53 wsFfrtHelper_ = new WSFFRTHelper();
54 }
55
TearDown()56 void WSFFRTHelperTest::TearDown()
57 {
58 delete wsFfrtHelper_;
59 wsFfrtHelper_ = nullptr;
60 }
61
62 /**
63 * @tc.name: SubmitTask001
64 * @tc.desc: test function SubmitTask
65 * @tc.type: FUNC
66 */
67 HWTEST_F(WSFFRTHelperTest, SubmitTask001, Function | SmallTest | Level2)
68 {
69 ASSERT_NE(wsFfrtHelper_, nullptr);
70
__anon964b526b0102null71 auto mockTask = []{};
72 std::string taskName = "testTask";
73 uint64_t delayTime = 0;
74 TaskQos qos = TaskQos::USER_INTERACTIVE;
75
76 wsFfrtHelper_->SubmitTask(mockTask, taskName, delayTime, qos);
77 bool result = wsFfrtHelper_->IsTaskExisted(taskName);
78 ASSERT_EQ(result, true);
79 }
80
81 /**
82 * @tc.name: SubmitTask002
83 * @tc.desc: test function SubmitTask in a multithreading case
84 * @tc.type: FUNC
85 */
86 HWTEST_F(WSFFRTHelperTest, SubmitTask002, Function | SmallTest | Level2)
87 {
88 g_wsFfrtHelper = wsFfrtHelper_;
89 ASSERT_NE(g_wsFfrtHelper, nullptr);
90
91 constexpr int threadNum = 100;
92 g_taskId.store(0);
93 SET_THREAD_NUM(threadNum);
__anon964b526b0202null94 auto submitTask = [] {
95 for (size_t i = 0; i < TASK_NUM; ++i) {
96 auto mockTask = []{};
97 int id = g_taskId.fetch_add(1);
98 std::string taskName = "testTask" + std::to_string(id);
99 uint64_t delayTime = 0;
100 TaskQos qos = TaskQos::USER_INTERACTIVE;
101 g_wsFfrtHelper->SubmitTask(mockTask, taskName, delayTime, qos);
102 }
103 };
104 GTEST_RUN_TASK(submitTask);
105
106 int result = g_wsFfrtHelper->CountTask();
107 ASSERT_EQ(result, TASK_NUM * threadNum);
108 g_wsFfrtHelper = nullptr;
109 }
110
111 /**
112 * @tc.name: CancelTask001
113 * @tc.desc: test function CancelTask
114 * @tc.type: FUNC
115 */
116 HWTEST_F(WSFFRTHelperTest, CancelTask001, Function | SmallTest | Level2)
117 {
118 ASSERT_NE(wsFfrtHelper_, nullptr);
119
__anon964b526b0402null120 auto mockTask = []{};
121 std::string taskName = "testTask";
122 uint64_t delayTime = 0;
123 TaskQos qos = TaskQos::USER_INTERACTIVE;
124
125 wsFfrtHelper_->SubmitTask(mockTask, taskName, delayTime, qos);
126 wsFfrtHelper_->CancelTask(taskName);
127 bool result = wsFfrtHelper_->IsTaskExisted(taskName);
128 ASSERT_EQ(result, false);
129 }
130
131 /**
132 * @tc.name: CancelTask002
133 * @tc.desc: test function CancelTask in a multithreading case
134 * @tc.type: FUNC
135 */
136 HWTEST_F(WSFFRTHelperTest, CancelTask002, Function | SmallTest | Level2)
137 {
138 g_wsFfrtHelper = wsFfrtHelper_;
139 ASSERT_NE(g_wsFfrtHelper, nullptr);
140
141 constexpr int totalTaskNum = 50000;
__anon964b526b0502null142 auto mockTask = []{};
143 for (size_t i = 0; i < totalTaskNum; ++i) {
144 wsFfrtHelper_->SubmitTask(mockTask, "testTask" + std::to_string(i), 0, TaskQos::USER_INTERACTIVE);
145 }
146
147 constexpr int threadNum = 10;
148 g_taskId.store(0);
149 SET_THREAD_NUM(threadNum);
__anon964b526b0602null150 auto cancelTask = [] {
151 for (size_t i = 0; i < TASK_NUM; ++i) {
152 int id = g_taskId.fetch_add(1);
153 std::string taskName = "testTask" + std::to_string(id);
154 g_wsFfrtHelper->CancelTask(taskName);
155 }
156 };
157 GTEST_RUN_TASK(cancelTask);
158
159 int result = g_wsFfrtHelper->CountTask();
160 ASSERT_EQ(result, totalTaskNum - threadNum * TASK_NUM);
161 g_wsFfrtHelper = nullptr;
162 }
163
164 }