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
TearDownTestCase()45 void WSFFRTHelperTest::TearDownTestCase() {}
46
SetUp()47 void WSFFRTHelperTest::SetUp()
48 {
49 wsFfrtHelper_ = new WSFFRTHelper();
50 }
51
TearDown()52 void WSFFRTHelperTest::TearDown()
53 {
54 delete wsFfrtHelper_;
55 wsFfrtHelper_ = nullptr;
56 }
57
58 /**
59 * @tc.name: SubmitTask001
60 * @tc.desc: test function SubmitTask
61 * @tc.type: FUNC
62 */
63 HWTEST_F(WSFFRTHelperTest, SubmitTask001, TestSize.Level1)
64 {
65 ASSERT_NE(wsFfrtHelper_, nullptr);
66
__anonf7d6b3150102null67 auto mockTask = [] {};
68 std::string taskName = "testTask";
69 uint64_t delayTime = 0;
70 TaskQos qos = TaskQos::USER_INTERACTIVE;
71
72 wsFfrtHelper_->SubmitTask(mockTask, taskName, delayTime, qos);
73 bool result = wsFfrtHelper_->IsTaskExisted(taskName);
74 ASSERT_EQ(result, true);
75 }
76
77 /**
78 * @tc.name: SubmitTask002
79 * @tc.desc: test function SubmitTask in a multithreading case
80 * @tc.type: FUNC
81 */
82 HWTEST_F(WSFFRTHelperTest, SubmitTask002, TestSize.Level1)
83 {
84 g_wsFfrtHelper = wsFfrtHelper_;
85 ASSERT_NE(g_wsFfrtHelper, nullptr);
86
87 constexpr int threadNum = 100;
88 g_taskId.store(0);
89 SET_THREAD_NUM(threadNum);
__anonf7d6b3150202null90 auto submitTask = [] {
91 for (size_t i = 0; i < TASK_NUM; ++i) {
92 auto mockTask = [] {};
93 int id = g_taskId.fetch_add(1);
94 std::string taskName = "testTask" + std::to_string(id);
95 uint64_t delayTime = 0;
96 TaskQos qos = TaskQos::USER_INTERACTIVE;
97 g_wsFfrtHelper->SubmitTask(mockTask, taskName, delayTime, qos);
98 }
99 };
100 GTEST_RUN_TASK(submitTask);
101
102 int result = g_wsFfrtHelper->CountTask();
103 ASSERT_EQ(result, TASK_NUM * threadNum);
104 g_wsFfrtHelper = nullptr;
105 }
106
107 /**
108 * @tc.name: CancelTask001
109 * @tc.desc: test function CancelTask
110 * @tc.type: FUNC
111 */
112 HWTEST_F(WSFFRTHelperTest, CancelTask001, TestSize.Level1)
113 {
114 ASSERT_NE(wsFfrtHelper_, nullptr);
115
__anonf7d6b3150402null116 auto mockTask = [] {};
117 std::string taskName = "testTask";
118 uint64_t delayTime = 0;
119 TaskQos qos = TaskQos::USER_INTERACTIVE;
120
121 wsFfrtHelper_->SubmitTask(mockTask, taskName, delayTime, qos);
122 wsFfrtHelper_->CancelTask(taskName);
123 bool result = wsFfrtHelper_->IsTaskExisted(taskName);
124 ASSERT_EQ(result, false);
125 }
126
127 /**
128 * @tc.name: CancelTask002
129 * @tc.desc: test function CancelTask in a multithreading case
130 * @tc.type: FUNC
131 */
132 HWTEST_F(WSFFRTHelperTest, CancelTask002, TestSize.Level1)
133 {
134 g_wsFfrtHelper = wsFfrtHelper_;
135 ASSERT_NE(g_wsFfrtHelper, nullptr);
136
137 constexpr int totalTaskNum = 50000;
__anonf7d6b3150502null138 auto mockTask = [] {};
139 for (size_t i = 0; i < totalTaskNum; ++i) {
140 wsFfrtHelper_->SubmitTask(mockTask, "testTask" + std::to_string(i), 0, TaskQos::USER_INTERACTIVE);
141 }
142
143 constexpr int threadNum = 10;
144 g_taskId.store(0);
145 SET_THREAD_NUM(threadNum);
__anonf7d6b3150602null146 auto cancelTask = [] {
147 for (size_t i = 0; i < TASK_NUM; ++i) {
148 int id = g_taskId.fetch_add(1);
149 std::string taskName = "testTask" + std::to_string(id);
150 g_wsFfrtHelper->CancelTask(taskName);
151 }
152 };
153 GTEST_RUN_TASK(cancelTask);
154
155 int result = g_wsFfrtHelper->CountTask();
156 ASSERT_EQ(result, totalTaskNum - threadNum * TASK_NUM);
157 g_wsFfrtHelper = nullptr;
158 }
159
160 } // namespace OHOS::Rosen