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 <gtest/gtest.h>
18 #include <string>
19 #include <vector>
20 #include "os_account_manager.h"
21 #undef private
22 #include "os_account_constants.h"
23
24 using namespace std;
25 using namespace testing::ext;
26 using namespace OHOS;
27 using namespace OHOS::AccountSA;
28
29 namespace {
30 const std::vector<std::string> CONSTANTS_VECTOR {
31 "constraint.sms.use"
32 };
33 const std::string PHOTO_IMG =
34 "data:image/"
35 "png;base64,"
36 "iVBORw0KGgoAAAANSUhEUgAAABUAAAAXCAIAAABrvZPKAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAEXRFWHRTb2Z0d2FyZQBTbmlwYXN0ZV0Xzt0AAA"
37 "FBSURBVDiN7ZQ/S8NQFMVPxU/QCx06GBzrkqUZ42rBbHWUBDqYxSnUoTxXydCSycVsgltfBiFDR8HNdHGxY4nQQAPvMzwHsWn+KMWsPdN7h/"
38 "vj3He5vIaUEjV0UAfe85X83KMBT7N75JEXVdSlfEAVfPRyZ5yfIrBoUkVlMU82Hkp8wu9ddt1vFew4sIiIiKwgzcXIvN7GTZOvpZRrbja3tDG/"
39 "D3I1NZvmdCXz+XOv5wJANKHOVYjRTAghxIyh0FHKb+0QQH5+kXf2zkYGAG0oFr5RfnK8DAGkwY19wliRT2L448vjv0YGQFVa8VKdDXUU+"
40 "faFUxpblhxYRNRzmd6FNnS0H3/X/VH6j0IIIRxMLJ5k/j/2L/"
41 "zchW8pKj7iFAA0R2wajl5d46idlR3+GtPV2XOvQ3bBNvyFs8U39v9PLX0Bp0CN+yY0OAEAAAAASUVORK5CYII=";
42 const std::int32_t LOCAL_ID = 100;
43
44 class OsAccountManagerBenchmarkTest : public benchmark::Fixture {
45 public:
SetUp(const::benchmark::State & state)46 void SetUp(const ::benchmark::State &state)
47 {}
TearDown(const::benchmark::State & state)48 void TearDown(const ::benchmark::State &state)
49 {}
50 };
51
52 /**
53 * @tc.name: OsAccountManagerTestCase001
54 * @tc.desc: SetOsAccountName
55 * @tc.type: FUNC
56 * @tc.require:
57 */
58
BENCHMARK_F(OsAccountManagerBenchmarkTest,OsAccountManagerTestCase001)59 BENCHMARK_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase001)(
60 benchmark::State &st)
61 {
62 GTEST_LOG_(INFO) << "OsAccountManagerBenchmarkTest OsAccountManagerTestCase001 start!";
63 int32_t i = 0;
64 for (auto _ : st) {
65 i++;
66 std::string STRING_NAME = "name_";
67 STRING_NAME += to_string(i);
68 EXPECT_EQ(OsAccountManager::SetOsAccountName(LOCAL_ID, STRING_NAME), ERR_OK);
69 }
70 }
71
72 BENCHMARK_REGISTER_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase001)->Iterations(100)->
73 Repetitions(3)->ReportAggregatesOnly();
74
75 /**
76 * @tc.name: OsAccountManagerTestCase002
77 * @tc.desc: IsMultiOsAccountEnable
78 * @tc.type: FUNC
79 * @tc.require:
80 */
81
BENCHMARK_F(OsAccountManagerBenchmarkTest,OsAccountManagerTestCase002)82 BENCHMARK_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase002)(
83 benchmark::State &st)
84 {
85 GTEST_LOG_(INFO) << "OsAccountManagerBenchmarkTest OsAccountManagerTestCase002 start!";
86 bool isMultiOsAccountEnable = false;
87 for (auto _ : st) {
88 EXPECT_EQ(OsAccountManager::IsMultiOsAccountEnable(isMultiOsAccountEnable), ERR_OK);
89 }
90 }
91
92 BENCHMARK_REGISTER_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase002)->Iterations(100)->
93 Repetitions(3)->ReportAggregatesOnly();
94
95 /**
96 * @tc.name: OsAccountManagerTestCase003
97 * @tc.desc: IsOsAccountActived
98 * @tc.type: FUNC
99 * @tc.require:
100 */
101
BENCHMARK_F(OsAccountManagerBenchmarkTest,OsAccountManagerTestCase003)102 BENCHMARK_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase003)(
103 benchmark::State &st)
104 {
105 GTEST_LOG_(INFO) << "OsAccountManagerBenchmarkTest OsAccountManagerTestCase003 start!";
106 bool isOsAccountActived = false;
107 for (auto _ : st) {
108 EXPECT_EQ(OsAccountManager::IsOsAccountActived(LOCAL_ID, isOsAccountActived), ERR_OK);
109 EXPECT_EQ(isOsAccountActived, true);
110 }
111 }
112
113 BENCHMARK_REGISTER_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase003)->Iterations(100)->
114 Repetitions(3)->ReportAggregatesOnly();
115
116 /**
117 * @tc.name: OsAccountManagerTestCase004
118 * @tc.desc: isOsAccountConstraintEnable
119 * @tc.type: FUNC
120 * @tc.require:
121 */
122
BENCHMARK_F(OsAccountManagerBenchmarkTest,OsAccountManagerTestCase004)123 BENCHMARK_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase004)(
124 benchmark::State &st)
125 {
126 GTEST_LOG_(INFO) << "OsAccountManagerBenchmarkTest OsAccountManagerTestCase004 start!";
127 bool isConstraintEnable = false;
128 for (auto _ : st) {
129 EXPECT_EQ(OsAccountManager::IsOsAccountConstraintEnable(LOCAL_ID, "constraint.wifi.set",
130 isConstraintEnable), ERR_OK);
131 EXPECT_EQ(isConstraintEnable, true);
132 }
133 }
134
135 BENCHMARK_REGISTER_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase004)->Iterations(100)->
136 Repetitions(3)->ReportAggregatesOnly();
137
138 /**
139 * @tc.name: OsAccountManagerTestCase005
140 * @tc.desc: IsOsAccountVerified
141 * @tc.type: FUNC
142 * @tc.require:
143 */
144
BENCHMARK_F(OsAccountManagerBenchmarkTest,OsAccountManagerTestCase005)145 BENCHMARK_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase005)(
146 benchmark::State &st)
147 {
148 GTEST_LOG_(INFO) << "OsAccountManagerBenchmarkTest OsAccountManagerTestCase005 start!";
149 bool isVerified = true;
150 for (auto _ : st) {
151 EXPECT_EQ(OsAccountManager::IsOsAccountVerified(LOCAL_ID, isVerified), ERR_OK);
152 }
153 }
154
155 BENCHMARK_REGISTER_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase005)->Iterations(100)->
156 Repetitions(3)->ReportAggregatesOnly();
157
158 /**
159 * @tc.name: OsAccountManagerTestCase006
160 * @tc.desc: GetCreatedOsAccountsCount
161 * @tc.type: FUNC
162 * @tc.require:
163 */
164
BENCHMARK_F(OsAccountManagerBenchmarkTest,OsAccountManagerTestCase006)165 BENCHMARK_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase006)(
166 benchmark::State &st)
167 {
168 GTEST_LOG_(INFO) << "OsAccountManagerBenchmarkTest OsAccountManagerTestCase006 start!";
169 unsigned int osAccountsCount = 0;
170 for (auto _ : st) {
171 EXPECT_EQ(OsAccountManager::GetCreatedOsAccountsCount(osAccountsCount), ERR_OK);
172 }
173 }
174
175 BENCHMARK_REGISTER_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase006)->Iterations(100)->
176 Repetitions(3)->ReportAggregatesOnly();
177
178 /**
179 * @tc.name: OsAccountManagerTestCase007
180 * @tc.desc: SetOsAccountConstraints
181 * @tc.type: FUNC
182 * @tc.require:
183 */
184
BENCHMARK_F(OsAccountManagerBenchmarkTest,OsAccountManagerTestCase007)185 BENCHMARK_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase007)(
186 benchmark::State &st)
187 {
188 GTEST_LOG_(INFO) << "OsAccountManagerBenchmarkTest OsAccountManagerTestCase007 start!";
189 for (auto _ : st) {
190 EXPECT_EQ(OsAccountManager::SetOsAccountConstraints(LOCAL_ID, CONSTANTS_VECTOR, true), ERR_OK);
191 }
192 }
193
194 BENCHMARK_REGISTER_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase007)->Iterations(100)->
195 Repetitions(3)->ReportAggregatesOnly();
196
197 /**
198 * @tc.name: OsAccountManagerTestCase008
199 * @tc.desc: GetOsAccountLocalIdFromUid
200 * @tc.type: FUNC
201 * @tc.require:
202 */
203
BENCHMARK_F(OsAccountManagerBenchmarkTest,OsAccountManagerTestCase008)204 BENCHMARK_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase008)(
205 benchmark::State &st)
206 {
207 int testUid = 1000000; // uid for test
208 int expectedUserID = 5; // the expected result user ID
209 GTEST_LOG_(INFO) << "OsAccountManagerBenchmarkTest OsAccountManagerTestCase008 start!";
210 for (auto _ : st) {
211 int id = -1;
212 EXPECT_EQ(OsAccountManager::GetOsAccountLocalIdFromUid(testUid, id), ERR_OK);
213 EXPECT_EQ(expectedUserID, id);
214 }
215 }
216
217 BENCHMARK_REGISTER_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase008)->Iterations(100)->
218 Repetitions(3)->ReportAggregatesOnly();
219
220 /**
221 * @tc.name: OsAccountManagerTestCase009
222 * @tc.desc: GetOsAccountLocalIdFromProcess
223 * @tc.type: FUNC
224 * @tc.require:
225 */
226
BENCHMARK_F(OsAccountManagerBenchmarkTest,OsAccountManagerTestCase009)227 BENCHMARK_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase009)(
228 benchmark::State &st)
229 {
230 GTEST_LOG_(INFO) << "OsAccountManagerBenchmarkTest OsAccountManagerTestCase009 start!";
231 for (auto _ : st) {
232 int id = -1;
233 EXPECT_EQ(OsAccountManager::GetOsAccountLocalIdFromProcess(id), ERR_OK);
234 }
235 }
236
237 BENCHMARK_REGISTER_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase009)->Iterations(100)->
238 Repetitions(3)->ReportAggregatesOnly();
239
240 /**
241 * @tc.name: OsAccountManagerTestCase0010
242 * @tc.desc: QueryMaxOsAccountNumber
243 * @tc.type: FUNC
244 * @tc.require:
245 */
246
BENCHMARK_F(OsAccountManagerBenchmarkTest,OsAccountManagerTestCase0010)247 BENCHMARK_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase0010)(
248 benchmark::State &st)
249 {
250 GTEST_LOG_(INFO) << "OsAccountManagerBenchmarkTest OsAccountManagerTestCase0010 start!";
251 for (auto _ : st) {
252 uint32_t maxOsAccountNumber = 0;
253 EXPECT_EQ(OsAccountManager::QueryMaxOsAccountNumber(maxOsAccountNumber), ERR_OK);
254 }
255 }
256
257 BENCHMARK_REGISTER_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase0010)->Iterations(100)->
258 Repetitions(3)->ReportAggregatesOnly();
259
260 /**
261 * @tc.name: OsAccountManagerTestCase0011
262 * @tc.desc: GetOsAccountAllConstraints
263 * @tc.type: FUNC
264 * @tc.require:
265 */
266
BENCHMARK_F(OsAccountManagerBenchmarkTest,OsAccountManagerTestCase0011)267 BENCHMARK_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase0011)(
268 benchmark::State &st)
269 {
270 GTEST_LOG_(INFO) << "OsAccountManagerBenchmarkTest OsAccountManagerTestCase0011 start!";
271 for (auto _ : st) {
272 std::vector<std::string> constraints;
273 const unsigned int size = 0;
274 EXPECT_EQ(OsAccountManager::GetOsAccountAllConstraints(LOCAL_ID, constraints), ERR_OK);
275 EXPECT_NE(size, constraints.size());
276 }
277 }
278
279 BENCHMARK_REGISTER_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase0011)->Iterations(100)->
280 Repetitions(3)->ReportAggregatesOnly();
281
282 /**
283 * @tc.name: OsAccountManagerTestCase0012
284 * @tc.desc: QueryActiveOsAccountIds
285 * @tc.type: FUNC
286 * @tc.require:
287 */
288
BENCHMARK_F(OsAccountManagerBenchmarkTest,OsAccountManagerTestCase0012)289 BENCHMARK_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase0012)(
290 benchmark::State &st)
291 {
292 GTEST_LOG_(INFO) << "OsAccountManagerBenchmarkTest OsAccountManagerTestCase0012 start!";
293 for (auto _ : st) {
294 std::vector<int32_t> ids;
295 const unsigned int size = 0;
296 EXPECT_EQ(OsAccountManager::QueryActiveOsAccountIds(ids), ERR_OK);
297 EXPECT_NE(size, ids.size());
298 }
299 }
300
301 BENCHMARK_REGISTER_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase0012)->Iterations(100)->
302 Repetitions(3)->ReportAggregatesOnly();
303
304 /**
305 * @tc.name: OsAccountManagerTestCase0013
306 * @tc.desc: QueryOsAccountById
307 * @tc.type: FUNC
308 * @tc.require:
309 */
310
BENCHMARK_F(OsAccountManagerBenchmarkTest,OsAccountManagerTestCase0013)311 BENCHMARK_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase0013)(
312 benchmark::State &st)
313 {
314 GTEST_LOG_(INFO) << "OsAccountManagerBenchmarkTest OsAccountManagerTestCase0013 start!";
315 for (auto _ : st) {
316 OsAccountInfo osAccountInfo;
317 EXPECT_EQ(OsAccountManager::QueryOsAccountById(LOCAL_ID, osAccountInfo), ERR_OK);
318 }
319 }
320
321 BENCHMARK_REGISTER_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase0013)->Iterations(100)->
322 Repetitions(3)->ReportAggregatesOnly();
323
324 /**
325 * @tc.name: OsAccountManagerTestCase0014
326 * @tc.desc: QueryCurrentOsAccount
327 * @tc.type: FUNC
328 * @tc.require:
329 */
330
BENCHMARK_F(OsAccountManagerBenchmarkTest,OsAccountManagerTestCase0014)331 BENCHMARK_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase0014)(
332 benchmark::State &st)
333 {
334 GTEST_LOG_(INFO) << "OsAccountManagerBenchmarkTest OsAccountManagerTestCase0014 start!";
335 for (auto _ : st) {
336 OsAccountInfo osAccountInfo;
337 EXPECT_EQ(OsAccountManager::QueryCurrentOsAccount(osAccountInfo), ERR_OK);
338 }
339 }
340
341 BENCHMARK_REGISTER_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase0014)->Iterations(100)->
342 Repetitions(3)->ReportAggregatesOnly();
343
344 /**
345 * @tc.name: OsAccountManagerTestCase0015
346 * @tc.desc: GetOsAccountTypeFromProcess
347 * @tc.type: FUNC
348 * @tc.require:
349 */
350
BENCHMARK_F(OsAccountManagerBenchmarkTest,OsAccountManagerTestCase0015)351 BENCHMARK_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase0015)(
352 benchmark::State &st)
353 {
354 GTEST_LOG_(INFO) << "OsAccountManagerBenchmarkTest OsAccountManagerTestCase0015 start!";
355 for (auto _ : st) {
356 OsAccountType type = OsAccountType::ADMIN;
357 EXPECT_EQ(OsAccountManager::GetOsAccountTypeFromProcess(type), ERR_OK);
358 }
359 }
360
361 BENCHMARK_REGISTER_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase0015)->Iterations(100)->
362 Repetitions(3)->ReportAggregatesOnly();
363
364 /**
365 * @tc.name: OsAccountManagerTestCase0016
366 * @tc.desc: GetDistributedVirtualDeviceId
367 * @tc.type: FUNC
368 * @tc.require:
369 */
370
BENCHMARK_F(OsAccountManagerBenchmarkTest,OsAccountManagerTestCase0016)371 BENCHMARK_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase0016)(
372 benchmark::State &st)
373 {
374 GTEST_LOG_(INFO) << "OsAccountManagerBenchmarkTest OsAccountManagerTestCase0016 start!";
375 for (auto _ : st) {
376 std::string deviceId;
377 EXPECT_EQ(OsAccountManager::GetDistributedVirtualDeviceId(deviceId), ERR_OK);
378 }
379 }
380
381 BENCHMARK_REGISTER_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase0016)->Iterations(100)->
382 Repetitions(3)->ReportAggregatesOnly();
383
384 /**
385 * @tc.name: OsAccountManagerTestCase0017
386 * @tc.desc: SetOsAccountProfilePhoto
387 * @tc.type: FUNC
388 * @tc.require:
389 */
390
BENCHMARK_F(OsAccountManagerBenchmarkTest,OsAccountManagerTestCase0017)391 BENCHMARK_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase0017)(
392 benchmark::State &st)
393 {
394 GTEST_LOG_(INFO) << "OsAccountManagerBenchmarkTest OsAccountManagerTestCase0017 start!";
395 for (auto _ : st) {
396 EXPECT_EQ(OsAccountManager::SetOsAccountProfilePhoto(LOCAL_ID, PHOTO_IMG), ERR_OK);
397 }
398 }
399
400 BENCHMARK_REGISTER_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase0017)->Iterations(100)->
401 Repetitions(3)->ReportAggregatesOnly();
402
403 /**
404 * @tc.name: OsAccountManagerTestCase0018
405 * @tc.desc: GetOsAccountProfilePhoto
406 * @tc.type: FUNC
407 * @tc.require:
408 */
409
BENCHMARK_F(OsAccountManagerBenchmarkTest,OsAccountManagerTestCase0018)410 BENCHMARK_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase0018)(
411 benchmark::State &st)
412 {
413 GTEST_LOG_(INFO) << "OsAccountManagerBenchmarkTest OsAccountManagerTestCase0018 start!";
414 for (auto _ : st) {
415 std::string photo;
416 EXPECT_EQ(OsAccountManager::GetOsAccountProfilePhoto(LOCAL_ID, photo), ERR_OK);
417 EXPECT_EQ(photo, PHOTO_IMG);
418 }
419 }
420
421 BENCHMARK_REGISTER_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase0018)->Iterations(100)->
422 Repetitions(3)->ReportAggregatesOnly();
423
424 /**
425 * @tc.name: OsAccountManagerTestCase0019
426 * @tc.desc: GetSerialNumberByOsAccountLocalId
427 * @tc.type: FUNC
428 * @tc.require:
429 */
430
BENCHMARK_F(OsAccountManagerBenchmarkTest,OsAccountManagerTestCase0019)431 BENCHMARK_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase0019)(
432 benchmark::State &st)
433 {
434 GTEST_LOG_(INFO) << "OsAccountManagerBenchmarkTest OsAccountManagerTestCase0019 start!";
435 for (auto _ : st) {
436 int64_t serialNumber;
437 EXPECT_EQ(OsAccountManager::GetSerialNumberByOsAccountLocalId(LOCAL_ID, serialNumber), ERR_OK);
438 EXPECT_NE(serialNumber, 0);
439 }
440 }
441
442 BENCHMARK_REGISTER_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase0019)->Iterations(100)->
443 Repetitions(3)->ReportAggregatesOnly();
444
445 /**
446 * @tc.name: OsAccountManagerTestCase0020
447 * @tc.desc: GetBundleIdFromUid
448 * @tc.type: FUNC
449 * @tc.require:
450 */
451
BENCHMARK_F(OsAccountManagerBenchmarkTest,OsAccountManagerTestCase0020)452 BENCHMARK_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase0020)(
453 benchmark::State &st)
454 {
455 int expectedBundleID = 5; // the expected result user ID
456 int testUid = 1000000 + expectedBundleID; // uid for test
457
458 GTEST_LOG_(INFO) << "OsAccountManagerBenchmarkTest OsAccountManagerTestCase0020 start!";
459 for (auto _ : st) {
460 int id = -1;
461 EXPECT_EQ(OsAccountManager::GetBundleIdFromUid(testUid, id), ERR_OK);
462 EXPECT_EQ(expectedBundleID, id);
463 }
464 }
465
466 BENCHMARK_REGISTER_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase0020)->Iterations(100)->
467 Repetitions(3)->ReportAggregatesOnly();
468
469 /**
470 * @tc.name: OsAccountManagerTestCase0021
471 * @tc.desc: IsMainOsAccount
472 * @tc.type: FUNC
473 * @tc.require:
474 */
475
BENCHMARK_F(OsAccountManagerBenchmarkTest,OsAccountManagerTestCase0021)476 BENCHMARK_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase0021)(
477 benchmark::State &st)
478 {
479 GTEST_LOG_(INFO) << "OsAccountManagerBenchmarkTest OsAccountManagerTestCase0021 start!";
480 for (auto _ : st) {
481 bool isMainOsAccount = false;
482 EXPECT_EQ(OsAccountManager::IsMainOsAccount(isMainOsAccount), ERR_OK);
483 }
484 }
485
486 BENCHMARK_REGISTER_F(OsAccountManagerBenchmarkTest, OsAccountManagerTestCase0021)->Iterations(100)->
487 Repetitions(3)->ReportAggregatesOnly();
488 } // namespace
489
490 BENCHMARK_MAIN();