1 /*
2 * Copyright (c) 2021-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 #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 namespace {
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 ASSERT_TRUE(false);
178 }
179 UpdateSysDefault(*localeInfo, false);
180 const LocaleInfo* currentLocaleInfo = GetSysDefault();
181 if (currentLocaleInfo == nullptr) {
182 delete localeInfo;
183 ASSERT_TRUE(false);
184 }
185 EXPECT_TRUE(std::strcmp("zh", currentLocaleInfo->GetLanguage()) == 0);
186 EXPECT_TRUE(std::strcmp("CN", currentLocaleInfo->GetRegion()) == 0);
187 delete localeInfo;
188 localeInfo = nullptr;
189 }
190
191 /*
192 * @tc.name: LocaleInfoUpdateSysDefaultTest001
193 * @tc.desc: Test UpdateSysDefault
194 * @tc.type: FUNC
195 */
196 HWTEST_F(LocaleInfoTest, LocaleInfoUpdateSysDefaultTest001, TestSize.Level1)
197 {
198 RState state = SUCCESS;
199 LocaleInfo* localeInfo = BuildFromString("zh-CN", '-', state);
200 if (localeInfo == nullptr) {
201 ASSERT_TRUE(false);
202 }
203 UpdateSysDefault(*localeInfo, false);
204 const LocaleInfo* currentLocaleInfo = GetSysDefault();
205 if (currentLocaleInfo == nullptr) {
206 delete localeInfo;
207 ASSERT_TRUE(false);
208 }
209 EXPECT_TRUE(std::strcmp("zh", currentLocaleInfo->GetLanguage()) == 0);
210 EXPECT_TRUE(std::strcmp("CN", currentLocaleInfo->GetRegion()) == 0);
211 delete localeInfo;
212 localeInfo = BuildFromString("en-US", '-', state);
213 UpdateSysDefault(*localeInfo, false);
214 currentLocaleInfo = GetSysDefault();
215 if (currentLocaleInfo == nullptr) {
216 delete localeInfo;
217 ASSERT_TRUE(false);
218 }
219 EXPECT_TRUE(std::strcmp("en", currentLocaleInfo->GetLanguage()) == 0);
220 EXPECT_TRUE(std::strcmp("US", currentLocaleInfo->GetRegion()) == 0);
221 delete localeInfo;
222 localeInfo = BuildFromString("en-Qaag-US", '-', state);
223 if (localeInfo == nullptr) {
224 ASSERT_TRUE(false);
225 }
226 UpdateSysDefault(*localeInfo, false);
227 currentLocaleInfo = GetSysDefault();
228 if (currentLocaleInfo == nullptr) {
229 delete localeInfo;
230 ASSERT_TRUE(false);
231 }
232 EXPECT_TRUE(std::strcmp("en", currentLocaleInfo->GetLanguage()) == 0);
233 EXPECT_TRUE(std::strcmp("US", currentLocaleInfo->GetRegion()) == 0);
234 EXPECT_TRUE(std::strcmp("Qaag", currentLocaleInfo->GetScript()) == 0);
235 delete localeInfo;
236 localeInfo = nullptr;
237 }
238
239 /*
240 * @tc.name: LocaleInfoGetLanguageTest001
241 * @tc.desc: Test LocaleInfo GetLanguage
242 * @tc.type: FUNC
243 */
244 HWTEST_F(LocaleInfoTest, LocaleInfoGetLanguageTest001, TestSize.Level1)
245 {
246 RState state = SUCCESS;
247 LocaleInfo* localeInfo = BuildFromString("zh-CN", '-', state);
248 if (localeInfo == nullptr) {
249 ASSERT_TRUE(false);
250 }
251 EXPECT_TRUE(std::strcmp("zh", localeInfo->GetLanguage()) == 0);
252 delete localeInfo;
253 localeInfo = nullptr;
254 }
255
256 /*
257 * @tc.name: LocaleInfoGetRegionTest001
258 * @tc.desc: Test LocaleInfo GetRegion
259 * @tc.type: FUNC
260 */
261 HWTEST_F(LocaleInfoTest, LocaleInfoGetRegionTest001, TestSize.Level1)
262 {
263 RState state = SUCCESS;
264 LocaleInfo* localeInfo = BuildFromString("zh-CN", '-', state);
265 if (localeInfo == nullptr) {
266 ASSERT_TRUE(false);
267 }
268 EXPECT_TRUE(std::strcmp("CN", localeInfo->GetRegion()) == 0);
269 delete localeInfo;
270 localeInfo = nullptr;
271 }
272
273 /*
274 * @tc.name: LocaleInfoGetScriptTest001
275 * @tc.desc: Test LocaleInfo GetScript
276 * @tc.type: FUNC
277 */
278 HWTEST_F(LocaleInfoTest, LocaleInfoGetScriptTest001, TestSize.Level1)
279 {
280 RState state = SUCCESS;
281 LocaleInfo* localeInfo = BuildFromString("zh-Hant-CN", '-', state);
282 if (localeInfo == nullptr) {
283 ASSERT_TRUE(false);
284 }
285 EXPECT_TRUE(std::strcmp("Hant", localeInfo->GetScript()) == 0);
286 delete localeInfo;
287 localeInfo = nullptr;
288 }
289
290 /*
291 * @tc.name: LocaleInfoBuildFromPartsTest001
292 * @tc.desc: Test BuildFromParts
293 * @tc.type: FUNC
294 */
295 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromPartsTest001, TestSize.Level1)
296 {
297 RState state = SUCCESS;
298 LocaleInfo* localeInfo = BuildFromParts("zh", "Hant", "CN", state);
299 if (localeInfo == nullptr) {
300 ASSERT_TRUE(false);
301 }
302 EXPECT_TRUE(state == SUCCESS);
303 EXPECT_TRUE(std::strcmp("zh", localeInfo->GetLanguage()) == 0);
304 EXPECT_TRUE(std::strcmp("Hant", localeInfo->GetScript()) == 0);
305 EXPECT_TRUE(std::strcmp("CN", localeInfo->GetRegion()) == 0);
306 delete localeInfo;
307 localeInfo = nullptr;
308 }
309
310 /*
311 * @tc.name: LocaleInfoBuildFromPartsTest002
312 * @tc.desc: Test BuildFromParts
313 * @tc.type: FUNC
314 */
315 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromPartsTest002, TestSize.Level1)
316 {
317 RState state = SUCCESS;
318 LocaleInfo* localeInfo = BuildFromParts("zh1", "Hant", "CN", state);
319 EXPECT_TRUE(state == INVALID_BCP47_LANGUAGE_SUBTAG);
320 EXPECT_TRUE(localeInfo == nullptr);
321 delete localeInfo;
322 localeInfo = nullptr;
323 }
324
325 /*
326 * @tc.name: LocaleInfoBuildFromPartsTest003
327 * @tc.desc: Test BuildFromParts
328 * @tc.type: FUNC
329 */
330 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromPartsTest003, TestSize.Level1)
331 {
332 RState state = SUCCESS;
333 LocaleInfo* localeInfo = BuildFromParts("zh", "Hants", "CN", state);
334 EXPECT_TRUE(state == INVALID_BCP47_SCRIPT_SUBTAG);
335 EXPECT_TRUE(localeInfo == nullptr);
336 delete localeInfo;
337 localeInfo = nullptr;
338 }
339
340 /*
341 * @tc.name: LocaleInfoBuildFromPartsTest004
342 * @tc.desc: Test BuildFromParts
343 * @tc.type: FUNC
344 */
345 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromPartsTest004, TestSize.Level1)
346 {
347 RState state = SUCCESS;
348 LocaleInfo* localeInfo = BuildFromParts("zh", "Hant", "C", state);
349 EXPECT_TRUE(state == INVALID_BCP47_REGION_SUBTAG);
350 EXPECT_TRUE(localeInfo == nullptr);
351 delete localeInfo;
352 localeInfo = nullptr;
353 }
354
355 /*
356 * @tc.name: LocaleInfoBuildFromPartsTest005
357 * @tc.desc: Test BuildFromParts
358 * @tc.type: FUNC
359 */
360 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromPartsTest005, TestSize.Level1)
361 {
362 RState state = SUCCESS;
363 LocaleInfo* localeInfo = BuildFromParts(nullptr, "Hants", "CN", state);
364 EXPECT_TRUE(state == INVALID_BCP47_LANGUAGE_SUBTAG);
365 EXPECT_TRUE(localeInfo == nullptr);
366 delete localeInfo;
367 localeInfo = nullptr;
368 }
369
370 /*
371 * @tc.name: LocaleInfoBuildFromPartsTest006
372 * @tc.desc: Test BuildFromParts
373 * @tc.type: FUNC
374 */
375 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromPartsTest006, TestSize.Level1)
376 {
377 RState state = SUCCESS;
378 LocaleInfo* localeInfo = BuildFromParts("zh", nullptr, nullptr, state);
379 if (localeInfo == nullptr) {
380 ASSERT_TRUE(false);
381 }
382 EXPECT_TRUE(state == SUCCESS);
383 EXPECT_TRUE(std::strcmp("zh", localeInfo->GetLanguage()) == 0);
384 EXPECT_TRUE(localeInfo->GetScript() == nullptr);
385 EXPECT_TRUE(localeInfo->GetRegion() == nullptr);
386 delete localeInfo;
387 localeInfo = nullptr;
388 }
389
390 /*
391 * @tc.name: LocaleInfoBuildFromStringTest001
392 * @tc.desc: Test BuildFromString
393 * @tc.type: FUNC
394 */
395 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromStringTest001, TestSize.Level1)
396 {
397 RState state = SUCCESS;
398 LocaleInfo* localeInfo = BuildFromString("zh-Hant-CN", '-', state);
399 if (localeInfo == nullptr) {
400 ASSERT_TRUE(false);
401 }
402 EXPECT_TRUE(state == SUCCESS);
403 EXPECT_TRUE(std::strcmp("zh", localeInfo->GetLanguage()) == 0);
404 EXPECT_TRUE(std::strcmp("Hant", localeInfo->GetScript()) == 0);
405 EXPECT_TRUE(std::strcmp("CN", localeInfo->GetRegion()) == 0);
406 delete localeInfo;
407 localeInfo = nullptr;
408 }
409
410 /*
411 * @tc.name: LocaleInfoBuildFromStringTest002
412 * @tc.desc: Test BuildFromString
413 * @tc.type: FUNC
414 */
415 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromStringTest002, TestSize.Level1)
416 {
417 RState state = SUCCESS;
418 LocaleInfo* localeInfo = BuildFromString("zh1-Hant-CN", '-', state);
419 EXPECT_TRUE(state == INVALID_BCP47_LANGUAGE_SUBTAG);
420 EXPECT_TRUE(localeInfo == nullptr);
421 delete localeInfo;
422 localeInfo = nullptr;
423 }
424
425 /*
426 * @tc.name: LocaleInfoBuildFromStringTest003
427 * @tc.desc: Test BuildFromString
428 * @tc.type: FUNC
429 */
430 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromStringTest003, TestSize.Level1)
431 {
432 RState state = SUCCESS;
433 LocaleInfo* localeInfo = BuildFromString("-Hant-CN", '-', state);
434 EXPECT_TRUE(state == INVALID_BCP47_LANGUAGE_SUBTAG);
435 EXPECT_TRUE(localeInfo == nullptr);
436 delete localeInfo;
437 localeInfo = nullptr;
438 }
439
440 /*
441 * @tc.name: LocaleInfoBuildFromStringTest004
442 * @tc.desc: Test BuildFromString
443 * @tc.type: FUNC
444 */
445 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromStringTest004, TestSize.Level1)
446 {
447 RState state = SUCCESS;
448 LocaleInfo* localeInfo = BuildFromString("zh", '-', state);
449 if (localeInfo == nullptr) {
450 ASSERT_TRUE(false);
451 }
452 EXPECT_TRUE(state == SUCCESS);
453 EXPECT_TRUE(std::strcmp("zh", localeInfo->GetLanguage()) == 0);
454 EXPECT_TRUE(localeInfo->GetScript() == nullptr);
455 EXPECT_TRUE(localeInfo->GetRegion() == nullptr);
456 delete localeInfo;
457 localeInfo = nullptr;
458 }
459
460 /*
461 * @tc.name: LocaleInfoBuildFromStringTest005
462 * @tc.desc: Test BuildFromString
463 * @tc.type: FUNC
464 */
465 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromStringTest005, TestSize.Level1)
466 {
467 RState state = SUCCESS;
468 LocaleInfo* localeInfo = BuildFromString("en_US", '_', state);
469 if (localeInfo == nullptr) {
470 ASSERT_TRUE(false);
471 }
472 EXPECT_TRUE(state == SUCCESS);
473 EXPECT_TRUE(std::strcmp("en", localeInfo->GetLanguage()) == 0);
474 EXPECT_TRUE(localeInfo->GetScript() == nullptr);
475 EXPECT_TRUE(std::strcmp("US", localeInfo->GetRegion()) == 0);
476 delete localeInfo;
477 localeInfo = nullptr;
478 }
479
480 /*
481 * @tc.name: LocaleInfoBuildFromStringTest006
482 * @tc.desc: Test BuildFromString
483 * @tc.type: FUNC
484 */
485 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromStringTest006, TestSize.Level1)
486 {
487 RState state = SUCCESS;
488 LocaleInfo* localeInfo = BuildFromString("en_Latn_US", '&', state);
489 EXPECT_TRUE(state == NOT_SUPPORT_SEP);
490 EXPECT_TRUE(localeInfo == nullptr);
491 delete localeInfo;
492 localeInfo = nullptr;
493 }
494
495 /*
496 * @tc.name: LocaleInfoBuildFromStringTest007
497 * @tc.desc: Test BuildFromString
498 * @tc.type: FUNC
499 */
500 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromStringTest007, TestSize.Level1)
501 {
502 RState state = SUCCESS;
503 LocaleInfo* localeInfo = BuildFromString("en_Latn_US", '_', state);
504 if (localeInfo == nullptr) {
505 ASSERT_TRUE(false);
506 }
507 EXPECT_TRUE(state == SUCCESS);
508 EXPECT_TRUE(std::strcmp("en", localeInfo->GetLanguage()) == 0);
509 EXPECT_TRUE(std::strcmp("Latn", localeInfo->GetScript()) == 0);
510 EXPECT_TRUE(std::strcmp("US", localeInfo->GetRegion()) == 0);
511 delete localeInfo;
512 localeInfo = nullptr;
513 }
514
515 /*
516 * @tc.name: LocaleInfoBuildFromStringTest008
517 * @tc.desc: Test BuildFromString
518 * @tc.type: FUNC
519 */
520 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromStringTest008, TestSize.Level1)
521 {
522 RState state = SUCCESS;
523 LocaleInfo* localeInfo = BuildFromString("zh-Hants-CN", '-', state);
524 EXPECT_TRUE(state == INVALID_BCP47_SCRIPT_SUBTAG);
525 EXPECT_TRUE(localeInfo == nullptr);
526 delete localeInfo;
527 localeInfo = nullptr;
528 }
529
530 /*
531 * @tc.name: LocaleInfoBuildFromStringTest009
532 * @tc.desc: Test BuildFromString
533 * @tc.type: FUNC
534 */
535 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromStringTest009, TestSize.Level1)
536 {
537 RState state = SUCCESS;
538 LocaleInfo* localeInfo = BuildFromString("zh-Hant-C", '-', state);
539 EXPECT_TRUE(state == INVALID_BCP47_REGION_SUBTAG);
540 EXPECT_TRUE(localeInfo == nullptr);
541 delete localeInfo;
542 localeInfo = nullptr;
543 }
544
545 /*
546 * @tc.name: LocaleInfoBuildFromStringTest0010
547 * @tc.desc: Test BuildFromString
548 * @tc.type: FUNC
549 */
550 HWTEST_F(LocaleInfoTest, LocaleInfoBuildFromStringTest0010, TestSize.Level1)
551 {
552 RState state = SUCCESS;
553 LocaleInfo* localeInfo = BuildFromString("zh-CN-xxxx", '-', state);
554 if (localeInfo == nullptr) {
555 ASSERT_TRUE(false);
556 }
557 EXPECT_TRUE(state == SUCCESS);
558 EXPECT_TRUE(std::strcmp("zh", localeInfo->GetLanguage()) == 0);
559 EXPECT_TRUE(localeInfo->GetScript() == nullptr);
560 EXPECT_TRUE(std::strcmp("CN", localeInfo->GetRegion()) == 0);
561 delete localeInfo;
562 localeInfo = nullptr;
563 }
564
565 /*
566 * @tc.name: LocaleInfoPerformanceFuncTest001
567 * @tc.desc: Test FindAndSort Performance
568 * @tc.type: FUNC
569 */
570 HWTEST_F(LocaleInfoTest, LocaleInfoPerformanceFuncTest001, TestSize.Level1)
571 {
572 unsigned long long total = 0;
573 double average = 0;
574 std::vector<std::string> outValue;
575 for (int k = 0; k < 1000; ++k) {
576 auto t1 = std::chrono::high_resolution_clock::now();
577 std::vector<std::string> request;
578 std::vector<std::string> outValue;
579 request.push_back("en");
580 request.push_back("en-CN");
581 request.push_back("en-US");
582 request.push_back("en-GB");
583 request.push_back("");
584 std::string current = "en-US";
585 FindAndSort(current, request, outValue);
586 auto t2 = std::chrono::high_resolution_clock::now();
587 total += std::chrono::duration_cast<std::chrono::microseconds>(t2 - t1).count();
588 }
589 average = total / 1000.0;
590 HILOG_DEBUG("avg cost FindAndSort: %f us", average);
591 EXPECT_LT(average, 500);
592 };
593 }