1 /*
2 * Copyright (c) 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 <benchmark/benchmark.h>
17 #include <unistd.h>
18 #include <queue>
19
20 #include "ability_manager_client.h"
21 #include "hilog_wrapper.h"
22 #include "mission_listener_stub.h"
23 #include "mock_native_token.h"
24
25 using namespace std;
26 using namespace OHOS;
27 using namespace OHOS::AAFwk;
28
29 namespace {
30 class BenchmarkMissionListener : public MissionListenerStub {
31 public:
32 BenchmarkMissionListener() = default;
33
34 ~BenchmarkMissionListener() override = default;
35
OnMissionCreated(int32_t missionId)36 void OnMissionCreated(int32_t missionId) override
37 {
38 }
39
OnMissionDestroyed(int32_t missionId)40 void OnMissionDestroyed(int32_t missionId) override
41 {
42 }
43
OnMissionSnapshotChanged(int32_t missionId)44 void OnMissionSnapshotChanged(int32_t missionId) override
45 {
46 }
47
OnMissionMovedToFront(int32_t missionId)48 void OnMissionMovedToFront(int32_t missionId) override
49 {
50 }
51
OnMissionIconUpdated(int32_t missionId,const std::shared_ptr<OHOS::Media::PixelMap> & icon)52 void OnMissionIconUpdated(int32_t missionId, const std::shared_ptr<OHOS::Media::PixelMap> &icon) override
53 {
54 }
55
OnMissionClosed(int32_t missionId)56 void OnMissionClosed(int32_t missionId) override
57 {
58 }
59
OnMissionLabelUpdated(int32_t missionId)60 void OnMissionLabelUpdated(int32_t missionId) override
61 {
62 }
63 };
64
65 class MissionManagerTest : public benchmark::Fixture {
66 public:
MissionManagerTest()67 MissionManagerTest()
68 {
69 Iterations(iterations);
70 Repetitions(repetitions);
71 ReportAggregatesOnly();
72 }
73
74 ~MissionManagerTest() override = default;
75
SetUp(const::benchmark::State & state)76 void SetUp(const ::benchmark::State &state) override
77 {
78 OHOS::AppExecFwk::MockNativeToken::SetNativeToken();
79 AbilityManagerClient::GetInstance()->CleanAllMissions();
80 usleep(usleepTime);
81 }
82
TearDown(const::benchmark::State & state)83 void TearDown(const ::benchmark::State &state) override
84 {
85 AbilityManagerClient::GetInstance()->CleanAllMissions();
86 usleep(usleepTime);
87 }
88
89 protected:
90 const int32_t repetitions = 3;
91 const int32_t iterations = 1000;
92 const int32_t upperLimit = 32;
93 // sleep 1000ms
94 const int32_t usleepTime = 1000 * 1000;
95 };
96
97 class MissionManagerTestReg : public MissionManagerTest {
98 public:
TearDown(const::benchmark::State & state)99 void TearDown(const ::benchmark::State &state) override
100 {
101 AbilityManagerClient::GetInstance()->CleanAllMissions();
102 while (!missionListeners.empty()) {
103 sptr<BenchmarkMissionListener> missionListener = missionListeners.front();
104 AbilityManagerClient::GetInstance()->UnRegisterMissionListener(missionListener);
105 missionListeners.pop();
106 }
107 usleep(usleepTime);
108 }
109
110 protected:
111 std::queue<sptr<BenchmarkMissionListener>> missionListeners {};
112 };
113
114 class MissionManagerTestUnReg : public MissionManagerTest {
115 public:
SetUp(const::benchmark::State & state)116 void SetUp(const ::benchmark::State &state) override
117 {
118 AbilityManagerClient::GetInstance()->CleanAllMissions();
119 for (int32_t i = 0; i < iterations; i++) {
120 sptr<BenchmarkMissionListener> missionListener = new BenchmarkMissionListener();
121 AbilityManagerClient::GetInstance()->RegisterMissionListener(missionListener);
122 missionListeners.push(missionListener);
123 }
124 usleep(usleepTime);
125 }
126
TearDown(const::benchmark::State & state)127 void TearDown(const ::benchmark::State &state) override
128 {
129 AbilityManagerClient::GetInstance()->CleanAllMissions();
130 while (!missionListeners.empty()) {
131 sptr<BenchmarkMissionListener> missionListener = missionListeners.front();
132 AbilityManagerClient::GetInstance()->UnRegisterMissionListener(missionListener);
133 missionListeners.pop();
134 }
135 usleep(usleepTime);
136 }
137
138 protected:
139 std::queue<sptr<BenchmarkMissionListener>> missionListeners {};
140 };
141
142 class MissionManagerTestWithAbility : public MissionManagerTest {
143 public:
SetUp(const::benchmark::State & state)144 void SetUp(const ::benchmark::State &state) override
145 {
146 AbilityManagerClient::GetInstance()->CleanAllMissions();
147 usleep(usleepTime);
148 Want want;
149 want.SetElementName(deviceId, bundleName, abilityName);
150 AbilityManagerClient::GetInstance()->StartAbility(want);
151 std::vector<MissionInfo> info {};
152 AbilityManagerClient::GetInstance()->GetMissionInfos("", upperLimit, info);
153 if (!info.empty()) {
154 missionId = info.front().id;
155 }
156 }
157
TearDown(const::benchmark::State & state)158 void TearDown(const ::benchmark::State &state) override
159 {
160 AbilityManagerClient::GetInstance()->CleanAllMissions();
161 usleep(usleepTime);
162 }
163
164 protected:
165 const string deviceId;
166 const string bundleName = "ohos.samples.FormApplication";
167 const string abilityName = "ohos.samples.FormApplication.MainAbility";
168 int32_t missionId = 0;
169 };
170
BENCHMARK_F(MissionManagerTestReg,RegisterMissionListenerTestCase)171 BENCHMARK_F(MissionManagerTestReg, RegisterMissionListenerTestCase)(
172 benchmark::State &state)
173 {
174 while (state.KeepRunning()) {
175 sptr<BenchmarkMissionListener> missionListener = new BenchmarkMissionListener();
176 ErrCode errCode = AbilityManagerClient::GetInstance()->RegisterMissionListener(missionListener);
177 if (errCode != ERR_OK) {
178 state.SkipWithError("RegisterMissionListenerTestCase failed.");
179 }
180 missionListeners.push(missionListener);
181 }
182 }
183
BENCHMARK_F(MissionManagerTestUnReg,UnregisterMissionListenerTestCase)184 BENCHMARK_F(MissionManagerTestUnReg, UnregisterMissionListenerTestCase)(
185 benchmark::State &state)
186 {
187 while (state.KeepRunning()) {
188 if (missionListeners.empty()) {
189 state.SkipWithError("UnregisterMissionListenerTestCase failed, no missionListener");
190 }
191 sptr<BenchmarkMissionListener> missionListener = missionListeners.front();
192 ErrCode errCode = AbilityManagerClient::GetInstance()->UnRegisterMissionListener(missionListener);
193 if (errCode != ERR_OK) {
194 state.SkipWithError("UnregisterMissionListenerTestCase failed.");
195 }
196 missionListeners.pop();
197 }
198 }
199
BENCHMARK_F(MissionManagerTest,GetMissionInfosTestCase)200 BENCHMARK_F(MissionManagerTest, GetMissionInfosTestCase)(
201 benchmark::State &state)
202 {
203 while (state.KeepRunning()) {
204 std::vector<MissionInfo> info {};
205 ErrCode errCode = AbilityManagerClient::GetInstance()->GetMissionInfos("", upperLimit, info);
206 if (errCode != ERR_OK) {
207 state.SkipWithError("GetMissionInfosTestCase failed.");
208 }
209 }
210 }
211
BENCHMARK_F(MissionManagerTestWithAbility,GetMissionInfoTestCase)212 BENCHMARK_F(MissionManagerTestWithAbility, GetMissionInfoTestCase)(
213 benchmark::State &state)
214 {
215 while (state.KeepRunning()) {
216 MissionInfo missionInfo {};
217 ErrCode errCode = AbilityManagerClient::GetInstance()->GetMissionInfo("", missionId, missionInfo);
218 if (errCode != ERR_OK) {
219 state.SkipWithError("GetMissionInfoTestCase failed.");
220 }
221 }
222 }
223
BENCHMARK_F(MissionManagerTestWithAbility,LockMissionForCleanupTestCase)224 BENCHMARK_F(MissionManagerTestWithAbility, LockMissionForCleanupTestCase)(
225 benchmark::State &state)
226 {
227 while (state.KeepRunning()) {
228 ErrCode errCode = AbilityManagerClient::GetInstance()->LockMissionForCleanup(missionId);
229 if (errCode != ERR_OK) {
230 state.SkipWithError("LockMissionForCleanupTestCase failed.");
231 }
232 state.PauseTiming();
233 errCode = AbilityManagerClient::GetInstance()->UnlockMissionForCleanup(missionId);
234 if (errCode != ERR_OK) {
235 state.SkipWithError("LockMissionForCleanupTestCase failed.");
236 }
237 state.ResumeTiming();
238 }
239 }
240
BENCHMARK_F(MissionManagerTestWithAbility,UnlockMissionForCleanupTestCase)241 BENCHMARK_F(MissionManagerTestWithAbility, UnlockMissionForCleanupTestCase)(
242 benchmark::State &state)
243 {
244 while (state.KeepRunning()) {
245 state.PauseTiming();
246 ErrCode errCode = AbilityManagerClient::GetInstance()->LockMissionForCleanup(missionId);
247 if (errCode != ERR_OK) {
248 state.SkipWithError("UnlockMissionForCleanupTestCase failed.");
249 }
250 state.ResumeTiming();
251 errCode = AbilityManagerClient::GetInstance()->UnlockMissionForCleanup(missionId);
252 if (errCode != ERR_OK) {
253 state.SkipWithError("UnlockMissionForCleanupTestCase failed.");
254 }
255 }
256 }
257
BENCHMARK_F(MissionManagerTestWithAbility,CleanMissionTestCase)258 BENCHMARK_F(MissionManagerTestWithAbility, CleanMissionTestCase)(
259 benchmark::State &state)
260 {
261 while (state.KeepRunning()) {
262 MissionSnapshot snapshot {};
263 ErrCode errCode = AbilityManagerClient::GetInstance()->CleanMission(missionId);
264 if (errCode != ERR_OK) {
265 state.SkipWithError("CleanMissionTestCase failed.");
266 }
267 }
268 }
269
BENCHMARK_F(MissionManagerTest,CleanAllMissionsTestCase)270 BENCHMARK_F(MissionManagerTest, CleanAllMissionsTestCase)(
271 benchmark::State &state)
272 {
273 while (state.KeepRunning()) {
274 ErrCode errCode = AbilityManagerClient::GetInstance()->CleanAllMissions();
275 if (errCode != ERR_OK) {
276 state.SkipWithError("CleanAllMissionsTestCase failed.");
277 }
278 }
279 }
280 }
281
282 // Run the benchmark
283 BENCHMARK_MAIN();
284