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 #include "locale_info_test.h"
16
17 #include <chrono>
18 #include <climits>
19 #include <cstring>
20 #include <gtest/gtest.h>
21
22 #include "hilog_wrapper.h"
23 #include "locale_info.h"
24 #include "test_common.h"
25
26 using namespace OHOS::Global::Resource;
27 using namespace testing::ext;
28
29 class LocaleInfoTest : public testing::Test {
30 public:
31 static void SetUpTestCase(void);
32
33 static void TearDownTestCase(void);
34
35 void SetUp();
36
37 void TearDown();
38 };
39
SetUpTestCase(void)40 void LocaleInfoTest::SetUpTestCase(void)
41 {
42 // step 1: input testsuit setup step
43 }
44
TearDownTestCase(void)45 void LocaleInfoTest::TearDownTestCase(void)
46 {
47 // step 2: input testsuit teardown step
48 }
49
SetUp()50 void LocaleInfoTest::SetUp()
51 {
52 }
53
TearDown()54 void LocaleInfoTest::TearDown()
55 {
56 }
57
58 /*
59 * @tc.name: LocaleInfoFindAndSortTest001
60 * @tc.desc: Test FindAndSort
61 * @tc.type: FUNC
62 */
63 HWTEST_F(LocaleInfoTest, LocaleInfoFindAndSortTest001, TestSize.Level1)
64 {
65 std::vector<std::string> request;
66 std::vector<std::string> outValue;
67 request.push_back("en");
68 request.push_back("en-CN");
69 request.push_back("en-US");
70 request.push_back("en-GB");
71 request.push_back("");
72 std::string current = "en-US";
73 FindAndSort(current, request, outValue);
74 EXPECT_TRUE(outValue.at(0) == "en-US");
75 EXPECT_TRUE(outValue.at(1) == "en");
76 EXPECT_TRUE(outValue.at(2) == "");
77 EXPECT_TRUE(outValue.at(3) == "en-CN");
78 EXPECT_TRUE(outValue.at(4) == "en-GB");
79 }
80
81 /*
82 * @tc.name: LocaleInfoFindAndSortTest002
83 * @tc.desc: Test FindAndSort
84 * @tc.type: FUNC
85 */
86 HWTEST_F(LocaleInfoTest, LocaleInfoFindAndSortTest002, TestSize.Level1)
87 {
88 std::vector<std::string> request;
89 std::vector<std::string> outValue;
90 request.push_back("zh-CN");
91 request.push_back("zh-TW");
92 request.push_back("zh");
93 request.push_back("zh-HK");
94 request.push_back("");
95 std::string current = "zh-CN";
96 FindAndSort(current, request, outValue);
97 EXPECT_TRUE(outValue.at(0) == "zh-CN");
98 EXPECT_TRUE(outValue.at(1) == "zh");
99 EXPECT_TRUE(outValue.at(2) == "");
100 }
101
102 /*
103 * @tc.name: LocaleInfoFindAndSortTest003
104 * @tc.desc: Test FindAndSort
105 * @tc.type: FUNC
106 */
107 HWTEST_F(LocaleInfoTest, LocaleInfoFindAndSortTest003, TestSize.Level1)
108 {
109 std::vector<std::string> request;
110 std::vector<std::string> outValue;
111 request.push_back("en");
112 request.push_back("en-CA");
113 request.push_back("en-GB");
114 request.push_back("");
115 std::string current = "en-CN";
116 FindAndSort(current, request, outValue);
117 EXPECT_TRUE(outValue.at(0) == "en");
118 EXPECT_TRUE(outValue.at(1) == "en-CA");
119 EXPECT_TRUE(outValue.at(2) == "");
120 EXPECT_TRUE(outValue.at(3) == "en-GB");
121 }
122
123 /*
124 * @tc.name: LocaleInfoFindAndSortTest004
125 * @tc.desc: Test FindAndSort
126 * @tc.type: FUNC
127 */
128 HWTEST_F(LocaleInfoTest, LocaleInfoFindAndSortTest004, TestSize.Level1)
129 {
130 std::vector<std::string> request;
131 std::vector<std::string> outValue;
132 request.push_back("en");
133 request.push_back("en-CA");
134 request.push_back("en-GB");
135 request.push_back("");
136 std::string current = "en-Qaag";
137 FindAndSort(current, request, outValue);
138 EXPECT_TRUE(outValue.at(0) == "en");
139 EXPECT_TRUE(outValue.at(1) == "en-GB");
140 EXPECT_TRUE(outValue.at(2) == "en-CA");
141 EXPECT_TRUE(outValue.at(3) == "");
142 }
143
144 /*
145 * @tc.name: LocaleInfoFindAndSortTest005
146 * @tc.desc: Test FindAndSort
147 * @tc.type: FUNC
148 */
149 HWTEST_F(LocaleInfoTest, LocaleInfoFindAndSortTest005, TestSize.Level1)
150 {
151 std::vector<std::string> request;
152 std::vector<std::string> outValue;
153 request.push_back("en");
154 request.push_back("en-001");
155 request.push_back("en-CA");
156 request.push_back("en-GB");
157 request.push_back("");
158 std::string current = "en-AI";
159 FindAndSort(current, request, outValue);
160 EXPECT_TRUE(outValue.at(0) == "en-001");
161 EXPECT_TRUE(outValue.at(1) == "en");
162 EXPECT_TRUE(outValue.at(2) == "en-GB");
163 EXPECT_TRUE(outValue.at(3) == "en-CA");
164 EXPECT_TRUE(outValue.at(4) == "");
165 }
166
167 /*
168 * @tc.name: LocaleInfoGetSysDefaultTest001
169 * @tc.desc: Test GetSysDefault
170 * @tc.type: FUNC
171 */
172 HWTEST_F(LocaleInfoTest, LocaleInfoGetSysDefaultTest001, TestSize.Level1)
173 {
174 RState state = SUCCESS;
175 LocaleInfo* localeInfo = BuildFromString("zh-CN", '-', state);
176 if (localeInfo == nullptr) {
177 EXPECT_TRUE(false);
178 return;
179 }
180 UpdateSysDefault(*localeInfo, false);
181 const LocaleInfo* currentLocaleInfo = GetSysDefault();
182 if (currentLocaleInfo == nullptr) {
183 EXPECT_TRUE(false);
184 delete localeInfo;
185 return;
186 }
187 EXPECT_TRUE(std::strcmp("zh", currentLocaleInfo->GetLanguage()) == 0);
188 EXPECT_TRUE(std::strcmp("CN", currentLocaleInfo->GetRegion()) == 0);
189 delete localeInfo;
190 localeInfo = nullptr;
191 }
192
193 /*
194 * @tc.name: LocaleInfoUpdateSysDefaultTest001
195 * @tc.desc: Test UpdateSysDefault
196 * @tc.type: FUNC
197 */
198 HWTEST_F(LocaleInfoTest, LocaleInfoUpdateSysDefaultTest001, TestSize.Level1)
199 {
200 RState state = SUCCESS;
201 LocaleInfo* localeInfo = BuildFromString("zh-CN", '-', state);
202 if (localeInfo == nullptr) {
203 EXPECT_TRUE(false);
204 return;
205 }
206 UpdateSysDefault(*localeInfo, false);
207 const LocaleInfo* currentLocaleInfo = GetSysDefault();
208 if (currentLocaleInfo == nullptr) {
209 EXPECT_TRUE(false);
210 delete localeInfo;
211 return;
212 }
213 EXPECT_TRUE(std::strcmp("zh", currentLocaleInfo->GetLanguage()) == 0);
214 EXPECT_TRUE(std::strcmp("CN", currentLocaleInfo->GetRegion()) == 0);
215 delete localeInfo;
216 localeInfo = BuildFromString("en-US", '-', state);
217 UpdateSysDefault(*localeInfo, false);
218 currentLocaleInfo = GetSysDefault();
219 if (currentLocaleInfo == nullptr) {
220 EXPECT_TRUE(false);
221 delete localeInfo;
222 return;
223 }
224 EXPECT_TRUE(std::strcmp("en", currentLocaleInfo->GetLanguage()) == 0);
225 EXPECT_TRUE(std::strcmp("US", currentLocaleInfo->GetRegion()) == 0);
226 delete localeInfo;
227 localeInfo = BuildFromString("en-Qaag-US", '-', state);
228 if (localeInfo == nullptr) {
229 EXPECT_TRUE(false);
230 return;
231 }
232 UpdateSysDefault(*localeInfo, false);
233 currentLocaleInfo = GetSysDefault();
234 if (currentLocaleInfo == nullptr) {
235 EXPECT_TRUE(false);
236 delete localeInfo;
237 return;
238 }
239 EXPECT_TRUE(std::strcmp("en", currentLocaleInfo->GetLanguage()) == 0);
240 EXPECT_TRUE(std::strcmp("US", currentLocaleInfo->GetRegion()) == 0);
241 EXPECT_TRUE(std::strcmp("Qaag", currentLocaleInfo->GetScript()) == 0);
242 delete localeInfo;
243 localeInfo = nullptr;
244 }
245
246 /*
247 * @tc.name: LocaleInfoGetLanguageTest001
248 * @tc.desc: Test LocaleInfo GetLanguage
249 * @tc.type: FUNC
250 */
251 HWTEST_F(LocaleInfoTest, LocaleInfoGetLanguageTest001, TestSize.Level1)
252 {
253 RState state = SUCCESS;
254 LocaleInfo* localeInfo = BuildFromString("zh-CN", '-', state);
255 if (localeInfo == nullptr) {
256 EXPECT_TRUE(false);
257 return;
258 }
259 EXPECT_TRUE(std::strcmp("zh", localeInfo->GetLanguage()) == 0);
260 delete localeInfo;
261 localeInfo = nullptr;
262 }
263
264 /*
265 * @tc.name: LocaleInfoGetRegionTest001
266 * @tc.desc: Test LocaleInfo GetRegion
267 * @tc.type: FUNC
268 */
269 HWTEST_F(LocaleInfoTest, LocaleInfoGetRegionTest001, TestSize.Level1)
270 {
271 RState state = SUCCESS;
272 LocaleInfo* localeInfo = BuildFromString("zh-CN", '-', state);
273 if (localeInfo == nullptr) {
274 EXPECT_TRUE(false);
275 return;
276 }
277 EXPECT_TRUE(std::strcmp("CN", localeInfo->GetRegion()) == 0);
278 delete localeInfo;
279 localeInfo = nullptr;
280 }
281
282 /*
283 * @tc.name: LocaleInfoGetScriptTest001
284 * @tc.desc: Test LocaleInfo GetScript
285 * @tc.type: FUNC
286 */
287 HWTEST_F(LocaleInfoTest, LocaleInfoGetScriptTest001, TestSize.Level1)
288 {
289 RState state = SUCCESS;
290 LocaleInfo* localeInfo = BuildFromString("zh-Hant-CN", '-', state);
291 if (localeInfo == nullptr) {
292 EXPECT_TRUE(false);
293 return;
294 }
295 EXPECT_TRUE(std::strcmp("Hant", localeInfo->GetScript()) == 0);
296 delete localeInfo;
297 localeInfo = nullptr;
298 }
299
300 /*
301 * @tc.name: LocaleInfoBuildFromPartsTest001
302 * @tc.desc: Test BuildFromParts
303 * @tc.type: FUNC
304 */
305 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromPartsTest001, TestSize.Level1)
306 {
307 RState state = SUCCESS;
308 LocaleInfo* localeInfo = BuildFromParts("zh", "Hant", "CN", state);
309 if (localeInfo == nullptr) {
310 EXPECT_TRUE(false);
311 return;
312 }
313 EXPECT_TRUE(state == SUCCESS);
314 EXPECT_TRUE(std::strcmp("zh", localeInfo->GetLanguage()) == 0);
315 EXPECT_TRUE(std::strcmp("Hant", localeInfo->GetScript()) == 0);
316 EXPECT_TRUE(std::strcmp("CN", localeInfo->GetRegion()) == 0);
317 delete localeInfo;
318 localeInfo = nullptr;
319 }
320
321 /*
322 * @tc.name: LocaleInfoBuildFromPartsTest002
323 * @tc.desc: Test BuildFromParts
324 * @tc.type: FUNC
325 */
326 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromPartsTest002, TestSize.Level1)
327 {
328 RState state = SUCCESS;
329 LocaleInfo* localeInfo = BuildFromParts("zh1", "Hant", "CN", state);
330 EXPECT_TRUE(state == INVALID_BCP47_LANGUAGE_SUBTAG);
331 EXPECT_TRUE(localeInfo == nullptr);
332 delete localeInfo;
333 localeInfo = nullptr;
334 }
335
336 /*
337 * @tc.name: LocaleInfoBuildFromPartsTest003
338 * @tc.desc: Test BuildFromParts
339 * @tc.type: FUNC
340 */
341 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromPartsTest003, TestSize.Level1)
342 {
343 RState state = SUCCESS;
344 LocaleInfo* localeInfo = BuildFromParts("zh", "Hants", "CN", state);
345 EXPECT_TRUE(state == INVALID_BCP47_SCRIPT_SUBTAG);
346 EXPECT_TRUE(localeInfo == nullptr);
347 delete localeInfo;
348 localeInfo = nullptr;
349 }
350
351 /*
352 * @tc.name: LocaleInfoBuildFromPartsTest004
353 * @tc.desc: Test BuildFromParts
354 * @tc.type: FUNC
355 */
356 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromPartsTest004, TestSize.Level1)
357 {
358 RState state = SUCCESS;
359 LocaleInfo* localeInfo = BuildFromParts("zh", "Hant", "C", state);
360 EXPECT_TRUE(state == INVALID_BCP47_REGION_SUBTAG);
361 EXPECT_TRUE(localeInfo == nullptr);
362 delete localeInfo;
363 localeInfo = nullptr;
364 }
365
366 /*
367 * @tc.name: LocaleInfoBuildFromPartsTest005
368 * @tc.desc: Test BuildFromParts
369 * @tc.type: FUNC
370 */
371 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromPartsTest005, TestSize.Level1)
372 {
373 RState state = SUCCESS;
374 LocaleInfo* localeInfo = BuildFromParts(nullptr, "Hants", "CN", state);
375 EXPECT_TRUE(state == INVALID_BCP47_LANGUAGE_SUBTAG);
376 EXPECT_TRUE(localeInfo == nullptr);
377 delete localeInfo;
378 localeInfo = nullptr;
379 }
380
381 /*
382 * @tc.name: LocaleInfoBuildFromPartsTest006
383 * @tc.desc: Test BuildFromParts
384 * @tc.type: FUNC
385 */
386 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromPartsTest006, TestSize.Level1)
387 {
388 RState state = SUCCESS;
389 LocaleInfo* localeInfo = BuildFromParts("zh", nullptr, nullptr, state);
390 if (localeInfo == nullptr) {
391 EXPECT_TRUE(false);
392 return;
393 }
394 EXPECT_TRUE(state == SUCCESS);
395 EXPECT_TRUE(std::strcmp("zh", localeInfo->GetLanguage()) == 0);
396 EXPECT_TRUE(localeInfo->GetScript() == nullptr);
397 EXPECT_TRUE(localeInfo->GetRegion() == nullptr);
398 delete localeInfo;
399 localeInfo = nullptr;
400 }
401
402 /*
403 * @tc.name: LocaleInfoBuildFromStringTest001
404 * @tc.desc: Test BuildFromString
405 * @tc.type: FUNC
406 */
407 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromStringTest001, TestSize.Level1)
408 {
409 RState state = SUCCESS;
410 LocaleInfo* localeInfo = BuildFromString("zh-Hant-CN", '-', state);
411 if (localeInfo == nullptr) {
412 EXPECT_TRUE(false);
413 return;
414 }
415 EXPECT_TRUE(state == SUCCESS);
416 EXPECT_TRUE(std::strcmp("zh", localeInfo->GetLanguage()) == 0);
417 EXPECT_TRUE(std::strcmp("Hant", localeInfo->GetScript()) == 0);
418 EXPECT_TRUE(std::strcmp("CN", localeInfo->GetRegion()) == 0);
419 delete localeInfo;
420 localeInfo = nullptr;
421 }
422
423 /*
424 * @tc.name: LocaleInfoBuildFromStringTest002
425 * @tc.desc: Test BuildFromString
426 * @tc.type: FUNC
427 */
428 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromStringTest002, TestSize.Level1)
429 {
430 RState state = SUCCESS;
431 LocaleInfo* localeInfo = BuildFromString("zh1-Hant-CN", '-', state);
432 EXPECT_TRUE(state == INVALID_BCP47_LANGUAGE_SUBTAG);
433 EXPECT_TRUE(localeInfo == nullptr);
434 delete localeInfo;
435 localeInfo = nullptr;
436 }
437
438 /*
439 * @tc.name: LocaleInfoBuildFromStringTest003
440 * @tc.desc: Test BuildFromString
441 * @tc.type: FUNC
442 */
443 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromStringTest003, TestSize.Level1)
444 {
445 RState state = SUCCESS;
446 LocaleInfo* localeInfo = BuildFromString("-Hant-CN", '-', state);
447 EXPECT_TRUE(state == INVALID_BCP47_LANGUAGE_SUBTAG);
448 EXPECT_TRUE(localeInfo == nullptr);
449 delete localeInfo;
450 localeInfo = nullptr;
451 }
452
453 /*
454 * @tc.name: LocaleInfoBuildFromStringTest004
455 * @tc.desc: Test BuildFromString
456 * @tc.type: FUNC
457 */
458 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromStringTest004, TestSize.Level1)
459 {
460 RState state = SUCCESS;
461 LocaleInfo* localeInfo = BuildFromString("zh", '-', state);
462 if (localeInfo == nullptr) {
463 EXPECT_TRUE(false);
464 return;
465 }
466 EXPECT_TRUE(state == SUCCESS);
467 EXPECT_TRUE(std::strcmp("zh", localeInfo->GetLanguage()) == 0);
468 EXPECT_TRUE(localeInfo->GetScript() == nullptr);
469 EXPECT_TRUE(localeInfo->GetRegion() == nullptr);
470 delete localeInfo;
471 localeInfo = nullptr;
472 }
473
474 /*
475 * @tc.name: LocaleInfoBuildFromStringTest005
476 * @tc.desc: Test BuildFromString
477 * @tc.type: FUNC
478 */
479 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromStringTest005, TestSize.Level1)
480 {
481 RState state = SUCCESS;
482 LocaleInfo* localeInfo = BuildFromString("en_US", '_', state);
483 if (localeInfo == nullptr) {
484 EXPECT_TRUE(false);
485 return;
486 }
487 EXPECT_TRUE(state == SUCCESS);
488 EXPECT_TRUE(std::strcmp("en", localeInfo->GetLanguage()) == 0);
489 EXPECT_TRUE(localeInfo->GetScript() == nullptr);
490 EXPECT_TRUE(std::strcmp("US", localeInfo->GetRegion()) == 0);
491 delete localeInfo;
492 localeInfo = nullptr;
493 }
494
495 /*
496 * @tc.name: LocaleInfoBuildFromStringTest006
497 * @tc.desc: Test BuildFromString
498 * @tc.type: FUNC
499 */
500 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromStringTest006, TestSize.Level1)
501 {
502 RState state = SUCCESS;
503 LocaleInfo* localeInfo = BuildFromString("en_Latn_US", '&', state);
504 EXPECT_TRUE(state == NOT_SUPPORT_SEP);
505 EXPECT_TRUE(localeInfo == nullptr);
506 delete localeInfo;
507 localeInfo = nullptr;
508 }
509
510 /*
511 * @tc.name: LocaleInfoBuildFromStringTest007
512 * @tc.desc: Test BuildFromString
513 * @tc.type: FUNC
514 */
515 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromStringTest007, TestSize.Level1)
516 {
517 RState state = SUCCESS;
518 LocaleInfo* localeInfo = BuildFromString("en_Latn_US", '_', state);
519 if (localeInfo == nullptr) {
520 EXPECT_TRUE(false);
521 return;
522 }
523 EXPECT_TRUE(state == SUCCESS);
524 EXPECT_TRUE(std::strcmp("en", localeInfo->GetLanguage()) == 0);
525 EXPECT_TRUE(std::strcmp("Latn", localeInfo->GetScript()) == 0);
526 EXPECT_TRUE(std::strcmp("US", localeInfo->GetRegion()) == 0);
527 delete localeInfo;
528 localeInfo = nullptr;
529 }
530
531 /*
532 * @tc.name: LocaleInfoBuildFromStringTest008
533 * @tc.desc: Test BuildFromString
534 * @tc.type: FUNC
535 */
536 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromStringTest008, TestSize.Level1)
537 {
538 RState state = SUCCESS;
539 LocaleInfo* localeInfo = BuildFromString("zh-Hants-CN", '-', state);
540 EXPECT_TRUE(state == INVALID_BCP47_SCRIPT_SUBTAG);
541 EXPECT_TRUE(localeInfo == nullptr);
542 delete localeInfo;
543 localeInfo = nullptr;
544 }
545
546 /*
547 * @tc.name: LocaleInfoBuildFromStringTest009
548 * @tc.desc: Test BuildFromString
549 * @tc.type: FUNC
550 */
551 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromStringTest009, TestSize.Level1)
552 {
553 RState state = SUCCESS;
554 LocaleInfo* localeInfo = BuildFromString("zh-Hant-C", '-', state);
555 EXPECT_TRUE(state == INVALID_BCP47_REGION_SUBTAG);
556 EXPECT_TRUE(localeInfo == nullptr);
557 delete localeInfo;
558 localeInfo = nullptr;
559 }
560
561 /*
562 * @tc.name: LocaleInfoBuildFromStringTest0010
563 * @tc.desc: Test BuildFromString
564 * @tc.type: FUNC
565 */
566 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromStringTest0010, TestSize.Level1)
567 {
568 RState state = SUCCESS;
569 LocaleInfo* localeInfo = BuildFromString("zh-CN-xxxx", '-', state);
570 if (localeInfo == nullptr) {
571 EXPECT_TRUE(false);
572 return;
573 }
574 EXPECT_TRUE(state == SUCCESS);
575 EXPECT_TRUE(std::strcmp("zh", localeInfo->GetLanguage()) == 0);
576 EXPECT_TRUE(localeInfo->GetScript() == nullptr);
577 EXPECT_TRUE(std::strcmp("CN", localeInfo->GetRegion()) == 0);
578 delete localeInfo;
579 localeInfo = nullptr;
580 }
581
582 /*
583 * @tc.name: LocaleInfoPerformanceFuncTest001
584 * @tc.desc: Test FindAndSort Performance
585 * @tc.type: FUNC
586 */
587 HWTEST_F(LocaleInfoTest, LocaleInfoPerformanceFuncTest001, TestSize.Level1)
588 {
589 unsigned long long total = 0;
590 double average = 0;
591 std::vector<std::string> outValue;
592 for (int k = 0; k < 1000; ++k) {
593 auto t1 = std::chrono::high_resolution_clock::now();
594 std::vector<std::string> request;
595 std::vector<std::string> outValue;
596 request.push_back("en");
597 request.push_back("en-CN");
598 request.push_back("en-US");
599 request.push_back("en-GB");
600 request.push_back("");
601 std::string current = "en-US";
602 FindAndSort(current, request, outValue);
603 auto t2 = std::chrono::high_resolution_clock::now();
604 total += std::chrono::duration_cast<std::chrono::microseconds>(t2 - t1).count();
605 }
606 average = total / 1000.0;
607 HILOG_DEBUG("avg cost FindAndSort: %f us", average);
608 EXPECT_LT(average, 500);
609 };