1 /*
2 * Copyright (c) 2021 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
18 #include "perf_profile.h"
19
20 using namespace testing::ext;
21 using namespace OHOS::AppExecFwk;
22
23 namespace {
24 const int64_t INVALID_TIME = -1;
25
26 const int64_t BMS_LOAD_INIT_START_TIME = 0;
27 const int64_t BMS_LOAD_SET_START_TIME = 10;
28 const int64_t BMS_LOAD_INIT_END_TIME = 0;
29 const int64_t BMS_LOAD_SET_END_TIME = 120;
30
31 const int64_t BUNDLE_SCAN_INIT_START_TIME = 0;
32 const int64_t BUNDLE_SCAN_SET_START_TIME = 100;
33 const int64_t BUNDLE_SCAN_INIT_END_TIME = 0;
34 const int64_t BUNDLE_SCAN_SET_END_TIME = 150;
35
36 const int64_t BUNDLE_DOWNLOAD_INIT_START_TIME = 0;
37 const int64_t BUNDLE_DOWNLOAD_SET_START_TIME = 50;
38 const int64_t BUNDLE_DOWNLOAD_INIT_END_TIME = 0;
39 const int64_t BUNDLE_DOWNLOAD_SET_END_TIME = 500;
40
41 const int64_t BUNDLE_INSTALL_INIT_START_TIME = 0;
42 const int64_t BUNDLE_INSTALL_SET_START_TIME = 50;
43 const int64_t BUNDLE_INSTALL_SET_START_TIME_SECOND = 400;
44 const int64_t BUNDLE_INSTALL_INIT_END_TIME = 0;
45 const int64_t BUNDLE_INSTALL_SET_END_TIME = 300;
46 const int64_t BUNDLE_INSTALL_SET_END_TIME_SECOND = 500;
47 const int64_t BUNDLE_INSTALL_INIT_TOTAL_TIME = 0;
48
49 const int64_t BUNDLE_UNINSTALL_INIT_START_TIME = 0;
50 const int64_t BUNDLE_UNINSTALL_SET_START_TIME = 30;
51 const int64_t BUNDLE_UNINSTALL_INIT_END_TIME = 0;
52 const int64_t BUNDLE_UNINSTALL_SET_END_TIME = 130;
53
54 const int64_t BUNDLE_PARSE_INIT_START_TIME = 0;
55 const int64_t BUNDLE_PARSE_SET_START_TIME = 50;
56 const int64_t BUNDLE_PARSE_INIT_END_TIME = 0;
57 const int64_t BUNDLE_PARSE_SET_END_TIME = 250;
58
59 const int64_t AMS_LOAD_INIT_START_TIME = 0;
60 const int64_t AMS_LOAD_SET_START_TIME = 10;
61 const int64_t AMS_LOAD_INIT_END_TIME = 0;
62 const int64_t AMS_LOAD_SET_END_TIME = 90;
63
64 const int64_t ABILITY_LOAD_INIT_START_TIME = 0;
65 const int64_t ABILITY_LOAD_SET_START_TIME = 50;
66 const int64_t ABILITY_LOAD_INIT_END_TIME = 0;
67 const int64_t ABILITY_LOAD_SET_END_TIME = 1000;
68
69 const int64_t APP_FORK_INIT_START_TIME = 0;
70 const int64_t APP_FORK_SET_START_TIME = 50;
71 const int64_t APP_FORK_INIT_END_TIME = 0;
72 const int64_t APP_FORK_SET_END_TIME = 100;
73 } // namespace
74
75 class CommonPerfProfileTest : public testing::Test {
76 public:
77 CommonPerfProfileTest();
78 ~CommonPerfProfileTest();
79 static void SetUpTestCase();
80 static void TearDownTestCase();
81 void SetUp();
82 void TearDown();
83 };
84
CommonPerfProfileTest()85 CommonPerfProfileTest::CommonPerfProfileTest()
86 {}
87
~CommonPerfProfileTest()88 CommonPerfProfileTest::~CommonPerfProfileTest()
89 {}
90
SetUpTestCase()91 void CommonPerfProfileTest::SetUpTestCase()
92 {}
93
TearDownTestCase()94 void CommonPerfProfileTest::TearDownTestCase()
95 {}
96
SetUp()97 void CommonPerfProfileTest::SetUp()
98 {
99 PerfProfile::GetInstance().Reset();
100 }
101
TearDown()102 void CommonPerfProfileTest::TearDown()
103 {}
104
105 /*
106 * Feature: CommonPerfProfileTest
107 * Function: SetBmsLoadTime
108 * SubFunction: NA
109 * FunctionPoints: SetBmsLoadTime
110 * EnvConditions: NA
111 * CaseDescription: verify bms load time can set correct when set the valid start and end time
112 */
113 HWTEST_F(CommonPerfProfileTest, SetBmsLoadTime_001, TestSize.Level0)
114 {
115 PerfProfile::GetInstance().SetBmsLoadStartTime(BMS_LOAD_SET_START_TIME);
116 int64_t bmsLoadStartTime = PerfProfile::GetInstance().GetBmsLoadStartTime();
117 EXPECT_EQ(bmsLoadStartTime, BMS_LOAD_SET_START_TIME) << "bms load start time " << bmsLoadStartTime;
118
119 PerfProfile::GetInstance().SetBmsLoadEndTime(BMS_LOAD_SET_END_TIME);
120 PerfProfile::GetInstance().Dump();
121 int64_t bmsLoadEndTime = PerfProfile::GetInstance().GetBmsLoadEndTime();
122 EXPECT_EQ(bmsLoadEndTime, BMS_LOAD_SET_END_TIME) << "bms load end time " << bmsLoadEndTime;
123
124 // after reset the perf profile, the bms load start and end time should be zero
125 PerfProfile::GetInstance().Reset();
126 int64_t initBmsLoadStartTime = PerfProfile::GetInstance().GetBmsLoadStartTime();
127 int64_t initBmsLoadEndTime = PerfProfile::GetInstance().GetBmsLoadEndTime();
128 EXPECT_EQ(initBmsLoadStartTime, BMS_LOAD_INIT_START_TIME) << "bms init load start time " << initBmsLoadStartTime;
129 EXPECT_EQ(initBmsLoadEndTime, BMS_LOAD_INIT_END_TIME) << "bms init load end time " << initBmsLoadEndTime;
130 }
131
132 /*
133 * Feature: CommonPerfProfileTest
134 * Function: SetBmsLoadTime
135 * SubFunction: NA
136 * FunctionPoints: SetBmsLoadTime
137 * EnvConditions: NA
138 * CaseDescription: verify bms load time can set correct when set invalid start or end time
139 */
140 HWTEST_F(CommonPerfProfileTest, SetBmsLoadTime_002, TestSize.Level0)
141 {
142 int64_t bmsLoadStartTime = 0;
143 int64_t bmsLoadEndTime = 0;
144
145 PerfProfile::GetInstance().SetBmsLoadStartTime(INVALID_TIME);
146 bmsLoadStartTime = PerfProfile::GetInstance().GetBmsLoadStartTime();
147 EXPECT_EQ(bmsLoadStartTime, BMS_LOAD_INIT_START_TIME) << "bms load start time " << bmsLoadStartTime;
148
149 PerfProfile::GetInstance().SetBmsLoadStartTime(BMS_LOAD_SET_START_TIME);
150
151 // set the invalid end time less than zero
152 PerfProfile::GetInstance().SetBmsLoadEndTime(INVALID_TIME);
153 bmsLoadEndTime = PerfProfile::GetInstance().GetBmsLoadEndTime();
154 EXPECT_EQ(bmsLoadEndTime, BMS_LOAD_SET_START_TIME) << "bms load end time " << bmsLoadEndTime;
155
156 // set the invalid end time more than zero and less then start time
157 PerfProfile::GetInstance().SetBmsLoadEndTime(BMS_LOAD_SET_START_TIME - 1);
158 bmsLoadEndTime = PerfProfile::GetInstance().GetBmsLoadEndTime();
159 EXPECT_EQ(bmsLoadEndTime, BMS_LOAD_SET_START_TIME) << "bms load end time " << bmsLoadEndTime;
160 }
161
162 /*
163 * Feature: CommonPerfProfileTest
164 * Function: SetBundleScanTime
165 * SubFunction: NA
166 * FunctionPoints: SetBundleScanTime
167 * EnvConditions: NA
168 * CaseDescription: verify bundle scan time can set correct when set the valid start and end time
169 */
170 HWTEST_F(CommonPerfProfileTest, SetBundleScanTime_001, TestSize.Level0)
171 {
172 PerfProfile::GetInstance().SetBundleScanStartTime(BUNDLE_SCAN_SET_START_TIME);
173 int64_t scanStartTime = PerfProfile::GetInstance().GetBundleScanStartTime();
174 EXPECT_EQ(scanStartTime, BUNDLE_SCAN_SET_START_TIME) << "bundle scan start time " << scanStartTime;
175
176 PerfProfile::GetInstance().SetBundleScanEndTime(BUNDLE_SCAN_SET_END_TIME);
177 PerfProfile::GetInstance().Dump();
178 int64_t scanEndTime = PerfProfile::GetInstance().GetBundleScanEndTime();
179 EXPECT_EQ(scanEndTime, BUNDLE_SCAN_SET_END_TIME) << "bundle scan end time " << scanEndTime;
180
181 // after reset the perf profile, the scan start and end time should be zero
182 PerfProfile::GetInstance().Reset();
183 int64_t initScanStartTime = PerfProfile::GetInstance().GetBundleScanStartTime();
184 int64_t initScanEndTime = PerfProfile::GetInstance().GetBundleScanEndTime();
185 EXPECT_EQ(initScanStartTime, BUNDLE_SCAN_INIT_START_TIME) << "bundle init scan start time " << initScanStartTime;
186 EXPECT_EQ(initScanEndTime, BUNDLE_SCAN_INIT_END_TIME) << "bundle init scan end time " << initScanEndTime;
187 }
188
189 /*
190 * Feature: CommonPerfProfileTest
191 * Function: SetBundleScanTime
192 * SubFunction: NA
193 * FunctionPoints: SetBundleScanTime
194 * EnvConditions: NA
195 * CaseDescription: verify bundle scan time can set correct when set invalid start or end time
196 */
197 HWTEST_F(CommonPerfProfileTest, SetBundleScanTime_002, TestSize.Level0)
198 {
199 int64_t scanStartTime = 0;
200 int64_t scanEndTime = 0;
201
202 PerfProfile::GetInstance().SetBundleScanStartTime(INVALID_TIME);
203 scanStartTime = PerfProfile::GetInstance().GetBundleScanStartTime();
204 EXPECT_EQ(scanStartTime, BUNDLE_SCAN_INIT_START_TIME) << "bundle scan start time " << scanStartTime;
205
206 PerfProfile::GetInstance().SetBundleScanStartTime(BUNDLE_SCAN_SET_START_TIME);
207
208 // set the invalid end time less than zero
209 PerfProfile::GetInstance().SetBundleScanEndTime(INVALID_TIME);
210 scanEndTime = PerfProfile::GetInstance().GetBundleScanEndTime();
211 EXPECT_EQ(scanEndTime, BUNDLE_SCAN_SET_START_TIME) << "bundle scan end time " << scanEndTime;
212
213 // set the invalid end time more than zero and less then start time
214 PerfProfile::GetInstance().SetBundleScanEndTime(BUNDLE_SCAN_SET_START_TIME - 1);
215 scanEndTime = PerfProfile::GetInstance().GetBundleScanEndTime();
216 EXPECT_EQ(scanEndTime, BUNDLE_SCAN_SET_START_TIME) << "bundle scan end time " << scanEndTime;
217 }
218
219 /*
220 * Feature: CommonPerfProfileTest
221 * Function: SetBundleDownloadTime
222 * SubFunction: NA
223 * FunctionPoints: SetBundleDownloadTime
224 * EnvConditions: NA
225 * CaseDescription: verify bundle download time can set correct when set the valid start and end time
226 */
227 HWTEST_F(CommonPerfProfileTest, SetBundleDownloadTime_001, TestSize.Level0)
228 {
229 PerfProfile::GetInstance().SetBundleDownloadStartTime(BUNDLE_DOWNLOAD_SET_START_TIME);
230 int64_t downloadStartTime = PerfProfile::GetInstance().GetBundleDownloadStartTime();
231 EXPECT_EQ(downloadStartTime, BUNDLE_DOWNLOAD_SET_START_TIME) << "bundle download start time " << downloadStartTime;
232
233 PerfProfile::GetInstance().SetBundleDownloadEndTime(BUNDLE_DOWNLOAD_SET_END_TIME);
234 PerfProfile::GetInstance().Dump();
235 int64_t downloadEndTime = PerfProfile::GetInstance().GetBundleDownloadEndTime();
236 EXPECT_EQ(downloadEndTime, BUNDLE_DOWNLOAD_SET_END_TIME) << "bundle download end time " << downloadEndTime;
237
238 // after reset the perf profile, the download start and end time should be zero
239 PerfProfile::GetInstance().Reset();
240 int64_t initDownloadStartTime = PerfProfile::GetInstance().GetBundleDownloadStartTime();
241 int64_t initDownloadEndTime = PerfProfile::GetInstance().GetBundleDownloadEndTime();
242 EXPECT_EQ(initDownloadStartTime, BUNDLE_DOWNLOAD_INIT_START_TIME)
243 << "bundle init download start time " << initDownloadStartTime;
244 EXPECT_EQ(initDownloadEndTime, BUNDLE_DOWNLOAD_INIT_END_TIME)
245 << "bundle init download end time " << initDownloadEndTime;
246 }
247
248 /*
249 * Feature: CommonPerfProfileTest
250 * Function: SetBundleDownloadTime
251 * SubFunction: NA
252 * FunctionPoints: SetBundleDownloadTime
253 * EnvConditions: NA
254 * CaseDescription: verify bundle download time can set correct when set invalid start or end time
255 */
256 HWTEST_F(CommonPerfProfileTest, SetBundleDownloadTime_002, TestSize.Level0)
257 {
258 int64_t downloadStartTime = 0;
259 int64_t downloadEndTime = 0;
260
261 PerfProfile::GetInstance().SetBundleDownloadStartTime(INVALID_TIME);
262 downloadStartTime = PerfProfile::GetInstance().GetBundleDownloadStartTime();
263 EXPECT_EQ(downloadStartTime, BUNDLE_DOWNLOAD_INIT_START_TIME) << "bundle download start time " << downloadStartTime;
264
265 PerfProfile::GetInstance().SetBundleDownloadStartTime(BUNDLE_DOWNLOAD_SET_START_TIME);
266
267 // set the invalid end time less than zero
268 PerfProfile::GetInstance().SetBundleDownloadEndTime(INVALID_TIME);
269 downloadEndTime = PerfProfile::GetInstance().GetBundleDownloadEndTime();
270 EXPECT_EQ(downloadEndTime, BUNDLE_DOWNLOAD_SET_START_TIME) << "bundle download end time " << downloadEndTime;
271
272 // set the invalid end time more than zero and less then start time
273 PerfProfile::GetInstance().SetBundleDownloadEndTime(BUNDLE_DOWNLOAD_SET_START_TIME - 1);
274 downloadEndTime = PerfProfile::GetInstance().GetBundleDownloadEndTime();
275 EXPECT_EQ(downloadEndTime, BUNDLE_DOWNLOAD_SET_START_TIME) << "bundle download end time " << downloadEndTime;
276 }
277
278 /*
279 * Feature: CommonPerfProfileTest
280 * Function: SetBundleInstallTime
281 * SubFunction: NA
282 * FunctionPoints: SetBundleInstallTime
283 * EnvConditions: NA
284 * CaseDescription: verify bundle install time can set correct when set the valid start and end time
285 */
286 HWTEST_F(CommonPerfProfileTest, SetBundleInstallTime_001, TestSize.Level0)
287 {
288 int64_t expectTotalInstallTime = 0;
289 int64_t realTotalInstallTime = 0;
290
291 PerfProfile::GetInstance().SetBundleInstallStartTime(BUNDLE_INSTALL_SET_START_TIME);
292 int64_t installStartTime = PerfProfile::GetInstance().GetBundleInstallStartTime();
293 EXPECT_EQ(installStartTime, BUNDLE_INSTALL_SET_START_TIME) << "bundle install start time " << installStartTime;
294
295 PerfProfile::GetInstance().SetBundleInstallEndTime(BUNDLE_INSTALL_SET_END_TIME);
296 PerfProfile::GetInstance().Dump();
297 int64_t installEndTime = PerfProfile::GetInstance().GetBundleInstallEndTime();
298 EXPECT_EQ(installEndTime, BUNDLE_INSTALL_SET_END_TIME) << "bundle install end time " << installEndTime;
299
300 expectTotalInstallTime = (BUNDLE_INSTALL_SET_END_TIME - BUNDLE_INSTALL_SET_START_TIME);
301 realTotalInstallTime = PerfProfile::GetInstance().GetBundleTotalInstallTime();
302 EXPECT_EQ(realTotalInstallTime, expectTotalInstallTime) << "bundle total install time " << realTotalInstallTime;
303
304 PerfProfile::GetInstance().SetBundleInstallStartTime(BUNDLE_INSTALL_SET_START_TIME_SECOND);
305 PerfProfile::GetInstance().SetBundleInstallEndTime(BUNDLE_INSTALL_SET_END_TIME_SECOND);
306 expectTotalInstallTime = (BUNDLE_INSTALL_SET_END_TIME - BUNDLE_INSTALL_SET_START_TIME) +
307 (BUNDLE_INSTALL_SET_END_TIME_SECOND - BUNDLE_INSTALL_SET_START_TIME_SECOND);
308 realTotalInstallTime = PerfProfile::GetInstance().GetBundleTotalInstallTime();
309 EXPECT_EQ(realTotalInstallTime, expectTotalInstallTime) << "bundle total install time " << realTotalInstallTime;
310
311 // after reset the perf profile, the install start and end time should be zero
312 PerfProfile::GetInstance().Reset();
313 int64_t initInstallStartTime = PerfProfile::GetInstance().GetBundleInstallStartTime();
314 int64_t initInstallEndTime = PerfProfile::GetInstance().GetBundleInstallEndTime();
315 int64_t initInstallTotalTime = PerfProfile::GetInstance().GetBundleInstallEndTime();
316 EXPECT_EQ(initInstallStartTime, BUNDLE_INSTALL_INIT_START_TIME)
317 << "bundle init install start time " << initInstallStartTime;
318 EXPECT_EQ(initInstallEndTime, BUNDLE_INSTALL_INIT_END_TIME)
319 << "bundle init install end time " << initInstallEndTime;
320 EXPECT_EQ(initInstallTotalTime, BUNDLE_INSTALL_INIT_TOTAL_TIME)
321 << "bundle init total time " << initInstallTotalTime;
322 }
323
324 /*
325 * Feature: CommonPerfProfileTest
326 * Function: SetBundleInstallTime
327 * SubFunction: NA
328 * FunctionPoints: SetBundleInstallTime
329 * EnvConditions: NA
330 * CaseDescription: verify bundle install time can set correct when set first invalid start or end time
331 */
332 HWTEST_F(CommonPerfProfileTest, SetBundleInstallTime_002, TestSize.Level0)
333 {
334 int64_t installStartTime = 0;
335 int64_t installEndTime = 0;
336 int64_t realTotalInstallTime = 0;
337
338 PerfProfile::GetInstance().SetBundleInstallStartTime(INVALID_TIME);
339 installStartTime = PerfProfile::GetInstance().GetBundleInstallStartTime();
340 EXPECT_EQ(installStartTime, BUNDLE_INSTALL_INIT_START_TIME) << "bundle install start time " << installStartTime;
341
342 // set first install right start time and wrong end time
343 PerfProfile::GetInstance().SetBundleInstallStartTime(BUNDLE_INSTALL_SET_START_TIME);
344 PerfProfile::GetInstance().SetBundleInstallEndTime(INVALID_TIME);
345 installEndTime = PerfProfile::GetInstance().GetBundleInstallEndTime();
346 EXPECT_EQ(installEndTime, BUNDLE_INSTALL_SET_START_TIME) << "bundle install end time " << installEndTime;
347 EXPECT_EQ(realTotalInstallTime, BUNDLE_INSTALL_INIT_TOTAL_TIME)
348 << "bundle total install time " << realTotalInstallTime;
349
350 PerfProfile::GetInstance().SetBundleInstallEndTime(BUNDLE_INSTALL_SET_START_TIME - 1);
351 installEndTime = PerfProfile::GetInstance().GetBundleInstallEndTime();
352 realTotalInstallTime = PerfProfile::GetInstance().GetBundleTotalInstallTime();
353 EXPECT_EQ(installEndTime, BUNDLE_INSTALL_SET_START_TIME) << "bundle install end time " << installEndTime;
354 EXPECT_EQ(realTotalInstallTime, BUNDLE_INSTALL_INIT_TOTAL_TIME)
355 << "bundle total install time " << realTotalInstallTime;
356 }
357
358 /*
359 * Feature: CommonPerfProfileTest
360 * Function: SetBundleInstallTime
361 * SubFunction: NA
362 * FunctionPoints: SetBundleInstallTime
363 * EnvConditions: NA
364 * CaseDescription: verify bundle install time can set correct when set second invalid end time
365 */
366 HWTEST_F(CommonPerfProfileTest, SetBundleInstallTime_003, TestSize.Level0)
367 {
368 // set first install right start and end time
369 PerfProfile::GetInstance().SetBundleInstallStartTime(BUNDLE_INSTALL_SET_START_TIME);
370 PerfProfile::GetInstance().SetBundleInstallEndTime(BUNDLE_INSTALL_SET_END_TIME);
371
372 // set second install right start time and wrong end time
373 int64_t expectTotalInstallTime = 0;
374 int64_t realTotalInstallTime = 0;
375 PerfProfile::GetInstance().SetBundleInstallStartTime(BUNDLE_INSTALL_SET_START_TIME_SECOND);
376
377 PerfProfile::GetInstance().SetBundleInstallEndTime(INVALID_TIME);
378 expectTotalInstallTime = BUNDLE_INSTALL_SET_END_TIME - BUNDLE_INSTALL_SET_START_TIME;
379 realTotalInstallTime = PerfProfile::GetInstance().GetBundleTotalInstallTime();
380 EXPECT_EQ(realTotalInstallTime, expectTotalInstallTime) << "bundle total install time " << realTotalInstallTime;
381
382 PerfProfile::GetInstance().SetBundleInstallEndTime(BUNDLE_INSTALL_SET_START_TIME_SECOND - 1);
383 expectTotalInstallTime = BUNDLE_INSTALL_SET_END_TIME - BUNDLE_INSTALL_SET_START_TIME;
384 realTotalInstallTime = PerfProfile::GetInstance().GetBundleTotalInstallTime();
385 EXPECT_EQ(realTotalInstallTime, expectTotalInstallTime) << "bundle total install time " << realTotalInstallTime;
386 }
387
388 /*
389 * Feature: CommonPerfProfileTest
390 * Function: SetBundleInstallTime
391 * SubFunction: NA
392 * FunctionPoints: SetBundleInstallTime
393 * EnvConditions: NA
394 * CaseDescription: verify bundle install time can set correct when set second invalid start time
395 */
396 HWTEST_F(CommonPerfProfileTest, SetBundleInstallTime_004, TestSize.Level0)
397 {
398 // set first install right start and end time
399 PerfProfile::GetInstance().SetBundleInstallStartTime(BUNDLE_INSTALL_SET_START_TIME);
400 PerfProfile::GetInstance().SetBundleInstallEndTime(BUNDLE_INSTALL_SET_END_TIME);
401
402 // set second install wrong start time and right end time
403 PerfProfile::GetInstance().SetBundleInstallStartTime(INVALID_TIME);
404 PerfProfile::GetInstance().SetBundleInstallEndTime(BUNDLE_INSTALL_SET_END_TIME_SECOND);
405 int64_t expectTotalInstallTime =
406 BUNDLE_INSTALL_SET_END_TIME - BUNDLE_INSTALL_SET_START_TIME + BUNDLE_INSTALL_SET_END_TIME_SECOND;
407 int64_t realTotalInstallTime = PerfProfile::GetInstance().GetBundleTotalInstallTime();
408 EXPECT_EQ(realTotalInstallTime, expectTotalInstallTime) << "bundle total install time " << realTotalInstallTime;
409 }
410
411 /*
412 * Feature: CommonPerfProfileTest
413 * Function: SetBundleInstallTime
414 * SubFunction: NA
415 * FunctionPoints: SetBundleInstallTime
416 * EnvConditions: NA
417 * CaseDescription: verify bundle install time can set correct when set second invalid start and end time
418 */
419 HWTEST_F(CommonPerfProfileTest, SetBundleInstallTime_005, TestSize.Level0)
420 {
421 // set first install right start and end time
422 PerfProfile::GetInstance().SetBundleInstallStartTime(BUNDLE_INSTALL_SET_START_TIME);
423 PerfProfile::GetInstance().SetBundleInstallEndTime(BUNDLE_INSTALL_SET_END_TIME);
424
425 // set second install wrong start time and end time
426 PerfProfile::GetInstance().SetBundleInstallStartTime(INVALID_TIME);
427 PerfProfile::GetInstance().SetBundleInstallEndTime(INVALID_TIME);
428 int64_t expectTotalInstallTime = BUNDLE_INSTALL_SET_END_TIME - BUNDLE_INSTALL_SET_START_TIME;
429 int64_t realTotalInstallTime = PerfProfile::GetInstance().GetBundleTotalInstallTime();
430 EXPECT_EQ(realTotalInstallTime, expectTotalInstallTime) << "bundle total install time " << realTotalInstallTime;
431 }
432
433 /*
434 * Feature: CommonPerfProfileTest
435 * Function: SetBundleUninstallTime
436 * SubFunction: NA
437 * FunctionPoints: SetBundleUninstallTime
438 * EnvConditions: NA
439 * CaseDescription: verify bundle uninstall time can set correct when set the valid start and end time
440 */
441 HWTEST_F(CommonPerfProfileTest, SetBundleUninstallTime_001, TestSize.Level0)
442 {
443 PerfProfile::GetInstance().SetBundleUninstallStartTime(BUNDLE_UNINSTALL_SET_START_TIME);
444 int64_t uninstallStartTime = PerfProfile::GetInstance().GetBundleUninstallStartTime();
445 EXPECT_EQ(uninstallStartTime, BUNDLE_UNINSTALL_SET_START_TIME)
446 << "bundle uninstall start time " << uninstallStartTime;
447
448 PerfProfile::GetInstance().SetBundleUninstallEndTime(BUNDLE_UNINSTALL_SET_END_TIME);
449 PerfProfile::GetInstance().Dump();
450 int64_t uninstallEndTime = PerfProfile::GetInstance().GetBundleUninstallEndTime();
451 EXPECT_EQ(uninstallEndTime, BUNDLE_UNINSTALL_SET_END_TIME) << "bundle uninstall end time " << uninstallEndTime;
452
453 // after reset the perf profile, the parse start and end time should be zero
454 PerfProfile::GetInstance().Reset();
455 int64_t initUninstallStartTime = PerfProfile::GetInstance().GetBundleUninstallStartTime();
456 int64_t initUninstallEndTime = PerfProfile::GetInstance().GetBundleUninstallEndTime();
457 EXPECT_EQ(initUninstallStartTime, BUNDLE_UNINSTALL_INIT_START_TIME)
458 << "bundle init uninstall start time " << initUninstallStartTime;
459 EXPECT_EQ(initUninstallEndTime, BUNDLE_UNINSTALL_INIT_END_TIME)
460 << "bundle init uninstall end time " << initUninstallEndTime;
461 }
462
463 /*
464 * Feature: CommonPerfProfileTest
465 * Function: SetBundleUninstallTime
466 * SubFunction: NA
467 * FunctionPoints: SetBundleUninstallTime
468 * EnvConditions: NA
469 * CaseDescription: verify bundle uninstall time can set correct when set the invalid start and end time
470 */
471 HWTEST_F(CommonPerfProfileTest, SetBundleUninstallTime_002, TestSize.Level0)
472 {
473 int64_t uninstallStartTime = 0;
474 int64_t uninstallEndTime = 0;
475
476 PerfProfile::GetInstance().SetBundleUninstallStartTime(INVALID_TIME);
477 uninstallStartTime = PerfProfile::GetInstance().GetBundleParseStartTime();
478 EXPECT_EQ(uninstallStartTime, BUNDLE_UNINSTALL_INIT_START_TIME)
479 << "bundle uninstall start time " << uninstallStartTime;
480
481 PerfProfile::GetInstance().SetBundleUninstallStartTime(BUNDLE_UNINSTALL_SET_START_TIME);
482
483 // set the invalid end time less than zero
484 PerfProfile::GetInstance().SetBundleUninstallEndTime(INVALID_TIME);
485 uninstallEndTime = PerfProfile::GetInstance().GetBundleUninstallEndTime();
486 EXPECT_EQ(uninstallEndTime, BUNDLE_UNINSTALL_SET_START_TIME) << "bundle uninstall end time " << uninstallEndTime;
487
488 // set the invalid end time more than zero and less then start time
489 PerfProfile::GetInstance().SetBundleParseEndTime(BUNDLE_UNINSTALL_SET_START_TIME - 1);
490 uninstallEndTime = PerfProfile::GetInstance().GetBundleUninstallEndTime();
491 EXPECT_EQ(uninstallEndTime, BUNDLE_UNINSTALL_SET_START_TIME) << "bundle uninstall end time " << uninstallEndTime;
492 }
493
494 /*
495 * Feature: CommonPerfProfileTest
496 * Function: SetBundleParseTime
497 * SubFunction: NA
498 * FunctionPoints: SetBundleParseTime
499 * EnvConditions: NA
500 * CaseDescription: verify bundle parse time can set correct when set the valid start and end time
501 */
502 HWTEST_F(CommonPerfProfileTest, SetBundleParseTime_001, TestSize.Level0)
503 {
504 PerfProfile::GetInstance().SetBundleParseStartTime(BUNDLE_PARSE_SET_START_TIME);
505 int64_t parseStartTime = PerfProfile::GetInstance().GetBundleParseStartTime();
506 EXPECT_EQ(parseStartTime, BUNDLE_PARSE_SET_START_TIME) << "bundle parse start time " << parseStartTime;
507
508 PerfProfile::GetInstance().SetBundleParseEndTime(BUNDLE_PARSE_SET_END_TIME);
509 PerfProfile::GetInstance().Dump();
510 int64_t parseEndTime = PerfProfile::GetInstance().GetBundleParseEndTime();
511 EXPECT_EQ(parseEndTime, BUNDLE_PARSE_SET_END_TIME) << "bundle parse end time " << parseEndTime;
512
513 // after reset the perf profile, the parse start and end time should be zero
514 PerfProfile::GetInstance().Reset();
515 int64_t initParseStartTime = PerfProfile::GetInstance().GetBundleParseStartTime();
516 int64_t initParseEndTime = PerfProfile::GetInstance().GetBundleParseEndTime();
517 EXPECT_EQ(initParseStartTime, BUNDLE_PARSE_INIT_START_TIME)
518 << "bundle init parse start time " << initParseStartTime;
519 EXPECT_EQ(initParseEndTime, BUNDLE_PARSE_INIT_END_TIME) << "bundle init parse end time " << initParseEndTime;
520 }
521
522 /*
523 * Feature: CommonPerfProfileTest
524 * Function: SetBundleParseTime
525 * SubFunction: NA
526 * FunctionPoints: SetBundleParseTime
527 * EnvConditions: NA
528 * CaseDescription: verify bundle parse time can set correct when set invalid start or end time
529 */
530 HWTEST_F(CommonPerfProfileTest, SetBundleParseTime_002, TestSize.Level0)
531 {
532 int64_t parseStartTime = 0;
533 int64_t parseEndTime = 0;
534
535 PerfProfile::GetInstance().SetBundleParseStartTime(INVALID_TIME);
536 parseStartTime = PerfProfile::GetInstance().GetBundleParseStartTime();
537 EXPECT_EQ(parseStartTime, BUNDLE_PARSE_INIT_START_TIME) << "bundle parse start time " << parseStartTime;
538
539 PerfProfile::GetInstance().SetBundleParseStartTime(BUNDLE_PARSE_SET_START_TIME);
540
541 // set the invalid end time less than zero
542 PerfProfile::GetInstance().SetBundleParseEndTime(INVALID_TIME);
543 parseEndTime = PerfProfile::GetInstance().GetBundleParseEndTime();
544 EXPECT_EQ(parseEndTime, BUNDLE_PARSE_SET_START_TIME) << "bundle parse end time " << parseEndTime;
545
546 // set the invalid end time more than zero and less then start time
547 PerfProfile::GetInstance().SetBundleParseEndTime(BUNDLE_PARSE_SET_START_TIME - 1);
548 parseEndTime = PerfProfile::GetInstance().GetBundleParseEndTime();
549 EXPECT_EQ(parseEndTime, BUNDLE_PARSE_SET_START_TIME) << "bundle parse end time " << parseEndTime;
550 }
551
552 /*
553 * Feature: CommonPerfProfileTest
554 * Function: SetAmsLoadTime
555 * SubFunction: NA
556 * FunctionPoints: SetAmsLoadTime
557 * EnvConditions: NA
558 * CaseDescription: verify ams load time can set correct when set the valid start and end time
559 */
560 HWTEST_F(CommonPerfProfileTest, SetAmsLoadTime_001, TestSize.Level0)
561 {
562 PerfProfile::GetInstance().SetAmsLoadStartTime(AMS_LOAD_SET_START_TIME);
563 int64_t amsLoadStartTime = PerfProfile::GetInstance().GetAmsLoadStartTime();
564 EXPECT_EQ(amsLoadStartTime, AMS_LOAD_SET_START_TIME) << "ams load start time " << amsLoadStartTime;
565
566 PerfProfile::GetInstance().SetAmsLoadEndTime(AMS_LOAD_SET_END_TIME);
567 PerfProfile::GetInstance().Dump();
568 int64_t amsLoadEndTime = PerfProfile::GetInstance().GetAmsLoadEndTime();
569 EXPECT_EQ(amsLoadEndTime, AMS_LOAD_SET_END_TIME) << "ams load end time " << amsLoadEndTime;
570
571 // after reset the perf profile, the ams load start and end time should be zero
572 PerfProfile::GetInstance().Reset();
573 int64_t initAmsLoadStartTime = PerfProfile::GetInstance().GetAmsLoadStartTime();
574 int64_t initAmsLoadEndTime = PerfProfile::GetInstance().GetAmsLoadEndTime();
575 EXPECT_EQ(initAmsLoadStartTime, AMS_LOAD_INIT_START_TIME) << "ams init load start time " << initAmsLoadStartTime;
576 EXPECT_EQ(initAmsLoadEndTime, AMS_LOAD_INIT_END_TIME) << "ams init load end time " << initAmsLoadEndTime;
577 }
578
579 /*
580 * Feature: CommonPerfProfileTest
581 * Function: SetAmsLoadTime
582 * SubFunction: NA
583 * FunctionPoints: SetAmsLoadTime
584 * EnvConditions: NA
585 * CaseDescription: verify ams load time can set correct when set invalid start or end time
586 */
587 HWTEST_F(CommonPerfProfileTest, SetAmsLoadTime_002, TestSize.Level0)
588 {
589 int64_t amsLoadStartTime = 0;
590 int64_t amsLoadEndTime = 0;
591
592 PerfProfile::GetInstance().SetAmsLoadStartTime(INVALID_TIME);
593 amsLoadStartTime = PerfProfile::GetInstance().GetAmsLoadStartTime();
594 EXPECT_EQ(amsLoadStartTime, AMS_LOAD_INIT_START_TIME) << "ams load start time " << amsLoadStartTime;
595
596 PerfProfile::GetInstance().SetAmsLoadStartTime(AMS_LOAD_SET_START_TIME);
597
598 // set the invalid end time less than zero
599 PerfProfile::GetInstance().SetAmsLoadEndTime(INVALID_TIME);
600 amsLoadEndTime = PerfProfile::GetInstance().GetAmsLoadEndTime();
601 EXPECT_EQ(amsLoadEndTime, AMS_LOAD_SET_START_TIME) << "ams load end time " << amsLoadEndTime;
602
603 // set the invalid end time more than zero and less then start time
604 PerfProfile::GetInstance().SetAmsLoadEndTime(AMS_LOAD_SET_START_TIME - 1);
605 amsLoadEndTime = PerfProfile::GetInstance().GetAmsLoadEndTime();
606 EXPECT_EQ(amsLoadEndTime, AMS_LOAD_SET_START_TIME) << "ams load end time " << amsLoadEndTime;
607 }
608
609 /*
610 * Feature: CommonPerfProfileTest
611 * Function: SetAbilityLoadTime
612 * SubFunction: NA
613 * FunctionPoints: SetAbilityLoadTime
614 * EnvConditions: NA
615 * CaseDescription: verify ability load time can set correct when set the valid start and end time
616 */
617 HWTEST_F(CommonPerfProfileTest, SetAbilityLoadTime_001, TestSize.Level0)
618 {
619 PerfProfile::GetInstance().SetAbilityLoadStartTime(ABILITY_LOAD_SET_START_TIME);
620 int64_t loadStartTime = PerfProfile::GetInstance().GetAbilityLoadStartTime();
621 EXPECT_EQ(loadStartTime, ABILITY_LOAD_SET_START_TIME) << "ability load start time " << loadStartTime;
622
623 PerfProfile::GetInstance().SetAbilityLoadEndTime(ABILITY_LOAD_SET_END_TIME);
624 PerfProfile::GetInstance().Dump();
625 int64_t loadEndTime = PerfProfile::GetInstance().GetAbilityLoadEndTime();
626 EXPECT_EQ(loadEndTime, ABILITY_LOAD_SET_END_TIME) << "ability load end time " << loadEndTime;
627
628 // after reset the perf profile, the ability load start and end time should be zero
629 PerfProfile::GetInstance().Reset();
630 int64_t initLoadStartTime = PerfProfile::GetInstance().GetAbilityLoadStartTime();
631 int64_t initLoadEndTime = PerfProfile::GetInstance().GetAbilityLoadEndTime();
632 EXPECT_EQ(initLoadStartTime, ABILITY_LOAD_INIT_START_TIME) << "ability init load start time " << initLoadStartTime;
633 EXPECT_EQ(initLoadEndTime, ABILITY_LOAD_INIT_END_TIME) << "ability init load end time " << initLoadEndTime;
634 }
635
636 /*
637 * Feature: CommonPerfProfileTest
638 * Function: SetAbilityLoadTime
639 * SubFunction: NA
640 * FunctionPoints: SetAbilityLoadTime
641 * EnvConditions: NA
642 * CaseDescription: verify ability load time can set correct when set invalid start or end time
643 */
644 HWTEST_F(CommonPerfProfileTest, SetAbilityLoadTime_002, TestSize.Level0)
645 {
646 int64_t loadStartTime = 0;
647 int64_t loadEndTime = 0;
648
649 PerfProfile::GetInstance().SetAbilityLoadStartTime(INVALID_TIME);
650 loadStartTime = PerfProfile::GetInstance().GetAbilityLoadStartTime();
651 EXPECT_EQ(loadStartTime, ABILITY_LOAD_INIT_START_TIME) << "ability load start time " << loadStartTime;
652
653 PerfProfile::GetInstance().SetAbilityLoadStartTime(ABILITY_LOAD_SET_START_TIME);
654
655 // set the invalid end time less than zero
656 PerfProfile::GetInstance().SetAbilityLoadEndTime(INVALID_TIME);
657 loadEndTime = PerfProfile::GetInstance().GetAbilityLoadEndTime();
658 EXPECT_EQ(loadEndTime, ABILITY_LOAD_SET_START_TIME) << "ability load end time " << loadEndTime;
659
660 // set the invalid end time more than zero and less then start time
661 PerfProfile::GetInstance().SetAmsLoadEndTime(ABILITY_LOAD_SET_START_TIME - 1);
662 loadEndTime = PerfProfile::GetInstance().GetAbilityLoadEndTime();
663 EXPECT_EQ(loadEndTime, ABILITY_LOAD_SET_START_TIME) << "ability load end time " << loadEndTime;
664 }
665
666 /*
667 * Feature: CommonPerfProfileTest
668 * Function: SetAppForkTime
669 * SubFunction: NA
670 * FunctionPoints: SetAppForkTime
671 * EnvConditions: NA
672 * CaseDescription: verify app fork time can set correct when set the valid start and end time
673 */
674 HWTEST_F(CommonPerfProfileTest, SetAppForkTime_001, TestSize.Level0)
675 {
676 PerfProfile::GetInstance().SetAppForkStartTime(APP_FORK_SET_START_TIME);
677 int64_t forkStartTime = PerfProfile::GetInstance().GetAppForkStartTime();
678 EXPECT_EQ(forkStartTime, APP_FORK_SET_START_TIME) << "app fork start time " << forkStartTime;
679
680 PerfProfile::GetInstance().SetAppForkEndTime(APP_FORK_SET_END_TIME);
681 PerfProfile::GetInstance().Dump();
682 int64_t forkEndTime = PerfProfile::GetInstance().GetAppForkEndTime();
683 EXPECT_EQ(forkEndTime, APP_FORK_SET_END_TIME) << "app fork end time " << forkEndTime;
684
685 // after reset the perf profile, the ability load start and end time should be zero
686 PerfProfile::GetInstance().Reset();
687 int64_t initForkStartTime = PerfProfile::GetInstance().GetAppForkStartTime();
688 int64_t initForkEndTime = PerfProfile::GetInstance().GetAppForkEndTime();
689 EXPECT_EQ(initForkStartTime, APP_FORK_INIT_START_TIME) << "app init fork start time " << initForkStartTime;
690 EXPECT_EQ(initForkEndTime, APP_FORK_INIT_END_TIME) << "app init fork end time " << initForkEndTime;
691 }
692
693 /*
694 * Feature: CommonPerfProfileTest
695 * Function: SetAppForkTime
696 * SubFunction: NA
697 * FunctionPoints: SetAppForkTime
698 * EnvConditions: NA
699 * CaseDescription: verify app fork time can set correct when set invalid start or end time
700 */
701 HWTEST_F(CommonPerfProfileTest, SetAppForkTime_002, TestSize.Level0)
702 {
703 int64_t forkStartTime = 0;
704 int64_t forkEndTime = 0;
705
706 PerfProfile::GetInstance().SetAppForkStartTime(INVALID_TIME);
707 forkStartTime = PerfProfile::GetInstance().GetAppForkStartTime();
708 EXPECT_EQ(forkStartTime, APP_FORK_INIT_START_TIME) << "app fork start time " << forkStartTime;
709
710 PerfProfile::GetInstance().SetAppForkStartTime(APP_FORK_SET_START_TIME);
711
712 // set the invalid end time less than zero
713 PerfProfile::GetInstance().SetAppForkEndTime(INVALID_TIME);
714 forkEndTime = PerfProfile::GetInstance().GetAppForkEndTime();
715 EXPECT_EQ(forkEndTime, APP_FORK_SET_START_TIME) << "app fork end time " << forkEndTime;
716
717 // set the invalid end time more than zero and less then start time
718 PerfProfile::GetInstance().SetAppForkEndTime(APP_FORK_SET_START_TIME - 1);
719 forkEndTime = PerfProfile::GetInstance().GetAppForkEndTime();
720 EXPECT_EQ(forkEndTime, ABILITY_LOAD_SET_START_TIME) << "app fork end time " << forkEndTime;
721 }
722
723 /*
724 * Feature: CommonPerfProfileTest
725 * Function: PerfProfileEnable
726 * SubFunction: NA
727 * FunctionPoints: PerfProfileEnable
728 * EnvConditions: NA
729 * CaseDescription: verify perf profile dump can set enable or disable
730 */
731 HWTEST_F(CommonPerfProfileTest, PerfProfileEnable_001, TestSize.Level0)
732 {
733 bool profileFlag = false;
734 PerfProfile::GetInstance().SetPerfProfileEnabled(false);
735 profileFlag = PerfProfile::GetInstance().GetPerfProfileEnabled();
736 PerfProfile::GetInstance().Dump();
737 ASSERT_FALSE(profileFlag);
738
739 PerfProfile::GetInstance().SetPerfProfileEnabled(true);
740 profileFlag = PerfProfile::GetInstance().GetPerfProfileEnabled();
741 PerfProfile::GetInstance().Dump();
742 ASSERT_TRUE(profileFlag);
743
744 // after reset the perf profile, the perf profile flag should be true
745 PerfProfile::GetInstance().SetPerfProfileEnabled(false);
746 PerfProfile::GetInstance().Reset();
747 profileFlag = PerfProfile::GetInstance().GetPerfProfileEnabled();
748 ASSERT_TRUE(profileFlag);
749 }