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 "focus_test_flow.h"
17
18 #include <string>
19
20 #include "report.h"
21 #include "wukong_define.h"
22 #include "ability_manager_client.h"
23 #include "component_manager.h"
24 #include "accessibility_ui_test_ability.h"
25 #include "component_input.h"
26 #include "tree_manager.h"
27
28 namespace OHOS {
29 namespace WuKong {
30 namespace {
31 const std::string FOCUS_TEST_HELP_MSG =
32 "usage: wukong focus [<arguments>]\n"
33 "These are wukong focus arguments list:\n"
34 " -h, --help random test help\n"
35 " -a, --appswitch appswitch event percent\n"
36 " -b, --bundle the bundle name of allowlist\n"
37 " -p, --prohibit the bundle name of blocklist\n"
38 " -d, --page block page list\n"
39 " -t, --touch touch event percent\n"
40 " -c, --count test count\n"
41 " -i, --interval interval\n"
42 " -s, --seed random seed\n"
43 " -m, --mouse mouse event percent\n"
44 " -k, --keyboard keyboard event percent\n"
45 " -H, --hardkey hardkey event percent\n"
46 " -S, --swap swap event percent\n"
47 " -T, --time test time\n"
48 " -C, --component component event percent\n"
49 " -r, --rotate rotate event percent\n"
50 " -n, --numberfocus the number of inputs to focus on some component one time\n"
51 " -f, --focustypes the component type to focus on\n"
52 " -e, --allow ability the ability name of allowlist\n"
53 " -E, --block ability the ability name of blocklist\n"
54 " -Y, --blockCompId the id list of block component\n"
55 " -y, --blockCompType the type list of block component\n"
56 " -I, --screenshot get screenshot\n";
57
58 const std::string SHORT_OPTIONS = "a:b:c:d:e:E:hIi:k:p:s:t:T:H:m:S:C:r:n:f:Y:y:";
59 const struct option LONG_OPTIONS[] = {
60 {"help", no_argument, nullptr, 'h'}, // help
61 {"seed", required_argument, nullptr, 's'}, // test seed
62 {"time", required_argument, nullptr, 'T'}, // test time
63 {"count", required_argument, nullptr, 'c'}, // test count
64 {"interval", required_argument, nullptr, 'i'}, // test interval
65 {"bundle", required_argument, nullptr, 'b'}, // test haps
66 {"appswitch", required_argument, nullptr, 'a'}, // switch app percent
67 {"keyboard", required_argument, nullptr, 'k'}, // keyboard percent
68 {"mouse", required_argument, nullptr, 'm'}, // mouse percent
69 {"touch", required_argument, nullptr, 't'}, // touch percent
70 {"swap", required_argument, nullptr, 'S'}, // swap percent
71 {"hardkey", required_argument, nullptr, 'H'}, // hardkey percent
72 {"prohibit", required_argument, nullptr, 'p'}, // prohibit
73 {"component", required_argument, nullptr, 'C'}, // prohibit
74 {"rotate", required_argument, nullptr, 'r'}, // rotate percent
75 {"numberfocus", required_argument, nullptr, 'n'}, // number focus
76 {"focustypes", required_argument, nullptr, 'f'}, // focus types
77 {"page", required_argument, nullptr, 'd'}, // block page
78 {"allow ability", required_argument, nullptr, 'e'},
79 {"block ability", required_argument, nullptr, 'E'},
80 {"blockCompId", required_argument, nullptr, 'Y'},
81 {"blockCompType", required_argument, nullptr, 'y'},
82 {"screenshot", no_argument, nullptr, 'I'}, // get screenshot
83 };
84
85 /**
86 * WuKong default input action percent.
87 */
88 const vector<int> DEFAULT_INPUT_PERCENT = {
89 10, // INPUTTYPE_TOUCHINPUT, input touch event
90 3, // INPUTTYPE_SWAPINPUT, input swap event
91 1, // INPUTTYPE_MOUSEINPUT, input mouse event
92 2, // INPUTTYPE_KEYBOARDINPUT, input keyboard event
93 70, // INPUTTYPE_ELEMENTINPUT, input element event
94 10, // INPUTTYPE_APPSWITCHINPUT, input appswitch event
95 2, // INPUTTYPE_HARDKEYINPUT, input hardkey event
96 2 // INPUTTYPE_ROTATE, input rotate event
97 };
98
99 const map<int, InputType> OPTION_INPUT_PERCENT = {
100 {'a', INPUTTYPE_APPSWITCHINPUT}, // input appswitch event
101 {'C', INPUTTYPE_ELEMENTINPUT}, // input element event
102 {'k', INPUTTYPE_KEYBOARDINPUT}, // input keyboard event
103 {'S', INPUTTYPE_SWAPINPUT}, // input swap event
104 {'m', INPUTTYPE_MOUSEINPUT}, // input mouse event
105 {'t', INPUTTYPE_TOUCHINPUT}, // input touch event
106 {'H', INPUTTYPE_HARDKEYINPUT}, // input hardkey event
107 {'r', INPUTTYPE_ROTATEINPUT} // input rotate event
108 };
109
110 const int ONE_HUNDRED_PERCENT = 100;
111 // one minute (ms)
112 const int ONE_MINUTE = 60000;
113 // rotate
114 const int ROTATE = 114;
115 bool g_commandSEEDENABLE = false;
116 bool g_commandHELPENABLE = false;
117 bool g_commandTIMEENABLE = false;
118 bool g_commandCOUNTENABLE = false;
119 bool g_isAppStarted = false;
120 bool g_commandSCREENSHOTENABLE = false;
121 bool g_commandALLOWABILITYENABLE = false;
122 bool g_commandBLOCKABILITYENABLE = false;
123 bool g_commandALLOWBUNDLEENABLE = false;
124 } // namespace
125 using namespace std;
126
FocusTestFlow(WuKongShellCommand &shellcommand)127 FocusTestFlow::FocusTestFlow(WuKongShellCommand &shellcommand)
128 : TestFlow(shellcommand),
129 inputPercent_(INPUTTYPE_INVALIDINPUT, 0)
130 {
131 }
132
~FocusTestFlow()133 FocusTestFlow::~FocusTestFlow()
134 {
135 if (timer_ != nullptr) {
136 timer_->Shutdown();
137 timer_->Unregister(timerId_);
138 timer_ = nullptr;
139 }
140 }
141
InitEventPercent()142 ErrCode FocusTestFlow::InitEventPercent()
143 {
144 int sumPercent = 0;
145 int sumLastDefaultPercent = ONE_HUNDRED_PERCENT;
146 vector<int> lastDefaultPercent = DEFAULT_INPUT_PERCENT;
147 for (auto input : inputPercent_) {
148 TRACK_LOG_STR("input: (%02d)", input);
149 }
150 for (int type = 0; type < INPUTTYPE_INVALIDINPUT; type++) {
151 // add type to count input list for random algorithm.
152 for (int index = 0; index < inputPercent_[type]; index++) {
153 eventList_.push_back(type);
154 }
155 // check argument percent, and set last default percent.
156 if (inputPercent_[type] > 0) {
157 sumLastDefaultPercent -= lastDefaultPercent[type];
158 lastDefaultPercent[type] = 0;
159 }
160 sumPercent += inputPercent_[type];
161 }
162 TRACK_LOG_STR("sumPercent: %d", sumPercent);
163 // check the sum percent more than 100%, and exit wukong.
164 if (sumPercent > ONE_HUNDRED_PERCENT) {
165 shellcommand_.ResultReceiverAppend("all event percentage more than 1, please reset params.\n");
166 shellcommand_.ResultReceiverAppend(FOCUS_TEST_HELP_MSG);
167 return OHOS::ERR_INVALID_VALUE;
168 }
169
170 // sum the last default percent for calculate last percent.
171 int lastPercent = ONE_HUNDRED_PERCENT - sumPercent;
172 int lastInputPercent = 0;
173 for (int type = 0; type < INPUTTYPE_INVALIDINPUT; type++) {
174 if (lastDefaultPercent[type] <= 0 || lastDefaultPercent[type] > ONE_HUNDRED_PERCENT ||
175 sumLastDefaultPercent <= 0) {
176 continue;
177 }
178 lastInputPercent = (int)(lastPercent * ((float)(lastDefaultPercent[type]) / sumLastDefaultPercent));
179 // add type to count input list for random algorithm.
180 for (int index = 0; index < lastInputPercent; index++) {
181 eventList_.push_back(type);
182 }
183 sumPercent += lastInputPercent;
184 }
185
186 // if the sumPercent less than 100%, add INPUTTYPE_TOUCHINPUT to random algorithm.
187 for (int index = 0; index < ONE_HUNDRED_PERCENT - sumPercent; index++) {
188 eventList_.push_back(INPUTTYPE_TOUCHINPUT);
189 }
190
191 return OHOS::ERR_OK;
192 }
193
EnvInit()194 ErrCode FocusTestFlow::EnvInit()
195 {
196 // init event list percent.
197 ErrCode result = InitEventPercent();
198 if (result != OHOS::ERR_OK) {
199 return result;
200 }
201
202 // init srand and print seed information.
203 if (g_commandSEEDENABLE) {
204 srand(seedArgs_);
205 } else {
206 time_t tempSeed = time(nullptr);
207 srand((unsigned int)tempSeed);
208 seedArgs_ = (int)time(nullptr);
209 }
210 Report::GetInstance()->SetSeed(std::to_string(seedArgs_));
211 Report::GetInstance()->SetIsFocusTest(true);
212 TEST_RUN_LOG(("Seed: " + std::to_string(seedArgs_)).c_str());
213
214 // shuffle the event list.
215 RandomShuffle();
216
217 // if time test flow, register timer.
218 if (g_commandTIMEENABLE) {
219 RegisterTimer();
220 }
221 return result;
222 }
223
SetInputPercent(const int option)224 ErrCode FocusTestFlow::SetInputPercent(const int option)
225 {
226 InputType inputType = INPUTTYPE_INVALIDINPUT;
227 auto it = OPTION_INPUT_PERCENT.find(option);
228 if (it == OPTION_INPUT_PERCENT.end()) {
229 return OHOS::ERR_INVALID_VALUE;
230 }
231
232 inputType = it->second;
233 float percent = 0.0;
234 try {
235 percent = std::stof(optarg);
236 if ((it->first) == ROTATE && percent == 1) {
237 g_isAppStarted = true;
238 }
239 } catch (const std::exception &e) {
240 // try the option argument string convert float.
241 shellcommand_.ResultReceiverAppend("error: option '");
242 shellcommand_.ResultReceiverAppend(string((char *)(&option)));
243 shellcommand_.ResultReceiverAppend("' requires a value.\n");
244 shellcommand_.ResultReceiverAppend(FOCUS_TEST_HELP_MSG);
245 return OHOS::ERR_INVALID_VALUE;
246 }
247 // check valid of the option argument
248 if (percent > 1 || percent < 0) {
249 shellcommand_.ResultReceiverAppend("the input percent more than 1 (100%).\n");
250 shellcommand_.ResultReceiverAppend(FOCUS_TEST_HELP_MSG);
251 return OHOS::ERR_INVALID_VALUE;
252 }
253
254 // convert float to int (0 ~ 100)
255 inputPercent_[inputType] = (int)(percent * ONE_HUNDRED_PERCENT);
256 return OHOS::ERR_OK;
257 }
258
SetBlackWhiteSheet(const int option)259 ErrCode FocusTestFlow::SetBlackWhiteSheet(const int option)
260 {
261 ErrCode result = OHOS::ERR_OK;
262 if (option == 'b') {
263 result = WuKongUtil::GetInstance()->SetAllowList(optarg);
264 g_commandALLOWBUNDLEENABLE = true;
265 } else if (option == 'p') {
266 result = WuKongUtil::GetInstance()->SetBlockList(optarg);
267 } else if (option == 'e') {
268 result = WuKongUtil::GetInstance()->SetAllowAbilityList(optarg);
269 if (result != OHOS::ERR_INVALID_VALUE) {
270 result = CheckArgument(option);
271 }
272 } else if (option == 'E') {
273 result = WuKongUtil::GetInstance()->SetBlockAbilityList(optarg);
274 if (result != OHOS::ERR_INVALID_VALUE) {
275 result = CheckArgument(option);
276 }
277 } else if (option == 'd') {
278 result = WuKongUtil::GetInstance()->SetBlockPageList(optarg);
279 } else if (option == 'Y') {
280 WuKongUtil::GetInstance()->SetCompIdBlockList(optarg);
281 } else if (option == 'y') {
282 WuKongUtil::GetInstance()->SetCompTypeBlockList(optarg);
283 }
284 return OHOS::ERR_OK;
285 }
286
SetRunningParam(const int option)287 ErrCode FocusTestFlow::SetRunningParam(const int option)
288 {
289 ErrCode result = OHOS::ERR_OK;
290 if (option == 'c' || option == 'T') {
291 result = CheckArgument(option);
292 } else if (option == 'i') {
293 intervalArgs_ = std::stoi(optarg);
294 TEST_RUN_LOG(("Interval: " + std::to_string(intervalArgs_)).c_str());
295 } else if (option == 's') {
296 seedArgs_ = std::stoi(optarg);
297 g_commandSEEDENABLE = true;
298 } else if (option == 'n') {
299 TreeManager::GetInstance()->SetFocusNum(optarg);
300 } else if (option == 'f') {
301 TreeManager::GetInstance()->SetFocusTypeList(optarg);
302 }
303 return result;
304 }
305
SetRunningIndicator(const int option)306 ErrCode FocusTestFlow::SetRunningIndicator(const int option)
307 {
308 ErrCode result = OHOS::ERR_OK;
309 if (option == 'h') {
310 shellcommand_.ResultReceiverAppend(FOCUS_TEST_HELP_MSG);
311 result = OHOS::ERR_NO_INIT;
312 g_commandHELPENABLE = true;
313 } else if (option == 'I') {
314 g_commandSCREENSHOTENABLE = true;
315 }
316 return OHOS::ERR_OK;
317 }
318
InputScene(std::shared_ptr<InputAction> inputaction, bool inputFlag)319 ErrCode FocusTestFlow::InputScene(std::shared_ptr<InputAction> inputaction, bool inputFlag)
320 {
321 ErrCode result = OHOS::ERR_OK;
322 if (inputFlag) {
323 TRACK_LOG("inputScene branck 1");
324 result = inputaction->FocusInput(g_commandSCREENSHOTENABLE);
325 } else {
326 TRACK_LOG("inputScene branck 2");
327 ComponentManager::GetInstance()->BackToPrePage();
328 }
329 return result;
330 }
331
SetBlockPage()332 bool FocusTestFlow::SetBlockPage()
333 {
334 auto root = std::make_shared<OHOS::Accessibility::AccessibilityElementInfo>();
335 auto accPtr = OHOS::Accessibility::AccessibilityUITestAbility::GetInstance();
336 // Get root AccessibilityElementInfo from Accessibility
337 accPtr->GetRoot(*(root.get()));
338 std::string path = root->GetPagePath();
339 bool inputFlag = true;
340 char const *systemPath = "pages/system";
341 char const *passwordPath = "pages/biometricsandpassword";
342 if (strstr(path.c_str(), systemPath) != NULL ||
343 strstr(path.c_str(), passwordPath) != NULL) {
344 inputFlag = false;
345 }
346 TRACK_LOG_STR("Componentpage path: (%s)", path.c_str());
347 return inputFlag;
348 }
349
RunStep()350 ErrCode FocusTestFlow::RunStep()
351 {
352 TRACK_LOG("RunStep Start");
353 ErrCode result;
354 // control the count test flow
355 if (g_commandCOUNTENABLE == true) {
356 totalCount_--;
357 if (totalCount_ < 0) {
358 isFinished_ = true;
359 return OHOS::ERR_OK;
360 }
361 }
362 bool inputFlag = SetBlockPage();
363 std::shared_ptr<InputAction> inputaction = nullptr;
364 if (!g_isAppStarted) {
365 TRACK_LOG("RunStep g_isAppStarted not start");
366 inputaction = InputFactory::GetInputAction(INPUTTYPE_APPSWITCHINPUT);
367 if (inputaction == nullptr) {
368 ERROR_LOG("inputaction is nullptr");
369 return OHOS::ERR_INVALID_VALUE;
370 }
371 result = InputScene(inputaction, inputFlag);
372 if (result != OHOS::ERR_OK) {
373 ERROR_LOG("launch app failed and exit");
374 return result;
375 }
376 inputaction = nullptr;
377 g_isAppStarted = true;
378 usleep(intervalArgs_ * oneSecond_);
379 }
380 TRACK_LOG("RunStep after g_isAppStarted ");
381 // input event, get event index form event list by random algorithm.
382 int eventindex = rand() % ONE_HUNDRED_PERCENT;
383 InputType eventTypeId = (InputType)(eventList_.at(eventindex));
384 inputaction = InputFactory::GetInputAction(eventTypeId);
385 if (inputaction == nullptr) {
386 ERROR_LOG("inputaction is nullptr");
387 return OHOS::ERR_INVALID_VALUE;
388 }
389 TRACK_LOG("RunStep before ProtectRightAbility");
390 if (ProtectRightAbility(inputaction, eventTypeId) == OHOS::ERR_INVALID_VALUE) {
391 return OHOS::ERR_INVALID_VALUE;
392 }
393
394 result = InputScene(inputaction, inputFlag);
395 usleep(intervalArgs_ * oneSecond_);
396 return result;
397 }
398
ProtectRightAbility(std::shared_ptr<InputAction> &inputaction, InputType &eventTypeId)399 ErrCode FocusTestFlow::ProtectRightAbility(std::shared_ptr<InputAction> &inputaction, InputType &eventTypeId)
400 {
401 std::vector<std::string> allowList;
402 WuKongUtil::GetInstance()->GetAllowList(allowList);
403 if (allowList.size() > 0) {
404 auto elementName = AAFwk::AbilityManagerClient::GetInstance()->GetTopAbility();
405
406 // allowList 数量大于0 并且 elementName.GetBundleName() 不在allowList里面，重新拉起一个应用
407 auto curBundleName = elementName.GetBundleName();
408 auto it = find(allowList.begin(), allowList.end(), curBundleName);
409 if (it == allowList.end()) {
410 inputaction = InputFactory::GetInputAction(INPUTTYPE_APPSWITCHINPUT);
411 if (inputaction == nullptr) {
412 ERROR_LOG("inputaction is nullptr");
413 return OHOS::ERR_INVALID_VALUE;
414 }
415 }
416 }
417 return OHOS::ERR_OK;
418 }
419
HandleNormalOption(const int option)420 ErrCode FocusTestFlow::HandleNormalOption(const int option)
421 {
422 ErrCode result;
423 if (option == 't' || option == 'm' || option == 'S' || option == 'k' || option == 'H' ||
424 option == 'a' || option == 'r' || option == 'C') {
425 result = SetInputPercent(option);
426 } else {
427 result = SetBlackWhiteSheet(option);
428 if (result != OHOS::ERR_OK) {
429 return result;
430 }
431 result = SetRunningParam(option);
432 if (result != OHOS::ERR_OK) {
433 return result;
434 }
435 result = SetRunningIndicator(option);
436 }
437 WuKongUtil::GetInstance()->SetOrderFlag(false);
438 return result;
439 }
440
CheckArgument(const int option)441 ErrCode FocusTestFlow::CheckArgument(const int option)
442 {
443 ErrCode result = OHOS::ERR_OK;
444 switch (option) {
445 case 'c': {
446 result = CheckArgumentOptionOfc();
447 break;
448 }
449 case 'T': {
450 result = CheckArgumentOptionOfT();
451 break;
452 }
453 case 'e': {
454 result = CheckArgumentOptionOfe();
455 break;
456 }
457 case 'E': {
458 result = CheckArgumentOptionOfE();
459 break;
460 }
461 default: {
462 result = OHOS::ERR_INVALID_VALUE;
463 break;
464 }
465 }
466 return result;
467 }
468
GetOptionArguments(std::string &shortOpts)469 const struct option *FocusTestFlow::GetOptionArguments(std::string &shortOpts)
470 {
471 shortOpts = SHORT_OPTIONS;
472 return LONG_OPTIONS;
473 }
474
HandleUnknownOption(const char optopt)475 ErrCode FocusTestFlow::HandleUnknownOption(const char optopt)
476 {
477 ErrCode result = OHOS::ERR_OK;
478 switch (optopt) {
479 case 'a':
480 case 'b':
481 case 'c':
482 case 'i':
483 case 's':
484 case 't':
485 case 'r':
486 case 'S':
487 case 'p':
488 case 'k':
489 case 'H':
490 case 'T':
491 case 'm':
492 case 'C':
493 case 'n':
494 case 'f':
495 case 'Y':
496 case 'y':
497 // error: option 'x' requires a value.
498 shellcommand_.ResultReceiverAppend("error: option '-");
499 shellcommand_.ResultReceiverAppend(string(1, optopt));
500 shellcommand_.ResultReceiverAppend("' requires a value.\n");
501 result = OHOS::ERR_INVALID_VALUE;
502 break;
503 case 'h': {
504 result = OHOS::ERR_INVALID_VALUE;
505 break;
506 }
507 default: {
508 // 'wukong focus' with an unknown option: wukong focus -x
509 shellcommand_.ResultReceiverAppend(
510 "'wukong focus' with an unknown option, please reference help information:\n");
511 result = OHOS::ERR_INVALID_VALUE;
512 break;
513 }
514 }
515 shellcommand_.ResultReceiverAppend(FOCUS_TEST_HELP_MSG);
516 return result;
517 }
518
RandomShuffle()519 void FocusTestFlow::RandomShuffle()
520 {
521 for (uint32_t i = eventList_.size() - 1; i > 0; --i) {
522 std::swap(eventList_[i], eventList_[std::rand() % (i + 1)]);
523 }
524 }
525
RegisterTimer()526 void FocusTestFlow::RegisterTimer()
527 {
528 if (timer_ == nullptr) {
529 timer_ = std::make_shared<Utils::Timer>("wukong");
530 timerId_ = timer_->Register([this] () { FocusTestFlow::TestTimeout(); }, totalTime_ * ONE_MINUTE, true);
531 timer_->Setup();
532 }
533 }
534
TestTimeout()535 void FocusTestFlow::TestTimeout()
536 {
537 g_commandTIMEENABLE = false;
538 isFinished_ = true;
539 }
540
CheckArgumentOptionOfe()541 ErrCode FocusTestFlow::CheckArgumentOptionOfe()
542 {
543 if (g_commandALLOWABILITYENABLE == false) {
544 g_commandALLOWABILITYENABLE = true;
545 if (g_commandALLOWBUNDLEENABLE == true) {
546 return OHOS::ERR_OK;
547 } else {
548 ERROR_LOG("invalid param : When -e is configured, -b must be configured.");
549 ERROR_LOG("invalid param : please ensure that the -b is before the -e");
550 return OHOS::ERR_INVALID_VALUE;
551 }
552 } else {
553 ERROR_LOG("invalid param : please check params of '-e'.");
554 return OHOS::ERR_INVALID_VALUE;
555 }
556 }
557
CheckArgumentOptionOfE()558 ErrCode FocusTestFlow::CheckArgumentOptionOfE()
559 {
560 if (g_commandBLOCKABILITYENABLE == false) {
561 g_commandBLOCKABILITYENABLE = true;
562 if (g_commandALLOWBUNDLEENABLE == true) {
563 return OHOS::ERR_OK;
564 } else {
565 ERROR_LOG("invalid param : When -E is configure, -b must be configured.");
566 ERROR_LOG("invalid param : Plese ensure that the -b is before the -E.");
567 return OHOS::ERR_INVALID_VALUE;
568 }
569 } else {
570 ERROR_LOG("invalid param : please check params of '-E'.");
571 return OHOS::ERR_INVALID_VALUE;
572 }
573 }
574
CheckArgumentOptionOfc()575 ErrCode FocusTestFlow::CheckArgumentOptionOfc()
576 {
577 // check if the '-c' and 'T' is exist at the same time
578 if (g_commandTIMEENABLE == false) {
579 std::stringstream ss(optarg);
580 if (ss >> countArgs_) {
581 g_commandCOUNTENABLE = true;
582 TEST_RUN_LOG(("Count: " + std::to_string(countArgs_)).c_str());
583 totalCount_ = countArgs_;
584 return OHOS::ERR_OK;
585 } else {
586 ERROR_LOG("Setting -c must follow an interger");
587 return OHOS::ERR_INVALID_VALUE;
588 }
589 } else {
590 DEBUG_LOG(PARAM_COUNT_TIME_ERROR);
591 shellcommand_.ResultReceiverAppend(std::string(PARAM_COUNT_TIME_ERROR) + "\n");
592 return OHOS::ERR_INVALID_VALUE;
593 }
594 }
595
CheckArgumentOptionOfT()596 ErrCode FocusTestFlow::CheckArgumentOptionOfT()
597 {
598 // check if the '-c' and 'T' is exist at the same time
599 if (g_commandCOUNTENABLE == false) {
600 std::stringstream ss(optarg);
601 if (ss >> totalTime_) {
602 TEST_RUN_LOG(("Time: " + std::to_string(totalTime_)).c_str());
603 g_commandTIMEENABLE = true;
604 return OHOS::ERR_OK;
605 } else {
606 ERROR_LOG("Setting -T must follow a float");
607 return OHOS::ERR_INVALID_VALUE;
608 }
609 } else {
610 DEBUG_LOG(PARAM_TIME_COUNT_ERROR);
611 shellcommand_.ResultReceiverAppend(std::string(PARAM_TIME_COUNT_ERROR) + "\n");
612 return OHOS::ERR_INVALID_VALUE;
613 }
614 }
615
616 } // namespace WuKong
617 } // namespace OHOS
618