1 /*
2  * Copyright (c) 2024 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 <string>
16 #include <sstream>
17 #include <vector>
18 #include <fstream>
19 #include <cstdio>
20 #include <unistd.h>
21 #include "gtest/gtest.h"
22 #define private public
23 #include "CommandParser.h"
24 
25 namespace {
26     class CommandParserTest : public ::testing::Test {
27     public:
CommandParserTest()28         CommandParserTest() {}
~CommandParserTest()29         ~CommandParserTest() {}
30     protected:
31         // 在整个测试夹具类执行前执行一次初始化操作
SetUpTestCase()32         static void SetUpTestCase()
33         {
34             std::stringstream ss1(invalidParams);
35             std::string invalidParam;
36             // 使用空格分割字符串，并存入vector
37             char buffer[FILENAME_MAX];
38             if (getcwd(buffer, FILENAME_MAX) != nullptr) {
39                 currDir = std::string(buffer);
40                 currFile = currDir + "/mytestfilename";
41                 // 创建文件流对象并打开文件
42                 std::ofstream file(currFile);
43                 // 检查文件是否成功打开
44                 if (file.is_open()) {
45                     file.close();
46                 } else {
47                     printf("Error creating file!\n");
48                 }
49             } else {
50                 printf("error: getcwd failed\n");
51             }
52             while (std::getline(ss1, invalidParam, ' ')) {
53                 invalidParamVec.push_back(invalidParam);
54                 if (invalidParam == "=dir=") {
55                     invalidParam = currDir;
56                 } else if (invalidParam == "=file=") {
57                     invalidParam = currFile;
58                 } else if (invalidParam == "-h") {
59                     continue; // 不存在的参数存储
60                 }
61                 validParamVec.push_back(invalidParam);
62             }
63         }
64         // 在整个测试夹具类执行后执行一次清理操作
TearDownTestCase()65         static void TearDownTestCase()
66         {
67             if (std::remove(currFile.c_str()) != 0) {
68                 printf("Error deleting file!\n");
69             }
70         }
71 
72         static std::vector<std::string> invalidParamVec;
73         static std::vector<std::string> validParamVec;
74         static std::string invalidParams;
75         static std::string currDir;
76         static std::string currFile;
77     };
78     std::string CommandParserTest::currDir = "";
79     std::string CommandParserTest::currFile = "";
80     std::vector<std::string> CommandParserTest::invalidParamVec = {};
81     std::vector<std::string> CommandParserTest::validParamVec = {};
82     std::string CommandParserTest::invalidParams = "-refresh region "
83         "-projectID 138968279 "
84         "-ts trace_70259_commandPipe "
85         "-j =dir= "
86         "-s componentpreviewinstance_1712054594321_1 "
87         "-cpm true "
88         "-device phone "
89         "-shape rect "
90         "-sd 480 "
91         "-ljPath =file= "
92         "-or 1080 2340 "
93         "-cr 1080 2340 "
94         "-fr 1080 2504 "
95         "-f =file= "
96         "-n entry "
97         "-av ACE_2_0 "
98         "-url pages/BigImg_1M "
99         "-pages main_pages "
100         "-arp =dir= "
101         "-pm Stage "
102         "-hsp =dir= "
103         "-l zh_CN "
104         "-cm light "
105         "-o portrait "
106         "-lws 40003 "
107         "-card true "
108         "-p 8888 "
109         "-abn EntryAbility "
110         "-abp ets/entryability/EntryAbility.abc "
111         "-d "
112         "-sm static "
113         "-staticCard true "
114         "-foldable true "
115         "-foldStatus half_fold "
116         "-hs 100000 "
117         "-hf true "
118         "-h";
119 
TEST_F(CommandParserTest, IsSetTest)120     TEST_F(CommandParserTest, IsSetTest)
121     {
122         CommandParser::GetInstance().argsMap.clear();
123         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
124         EXPECT_TRUE(CommandParser::GetInstance().IsSet("arp"));
125         EXPECT_FALSE(CommandParser::GetInstance().IsSet("abc"));
126     }
127 
TEST_F(CommandParserTest, IsCommandValidTest2)128     TEST_F(CommandParserTest, IsCommandValidTest2)
129     {
130         CommandParser::GetInstance().argsMap.clear();
131         EXPECT_FALSE(CommandParser::GetInstance().ProcessCommand(invalidParamVec));
132         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
133     }
134 
TEST_F(CommandParserTest, IsCommandValidTest_VErr)135     TEST_F(CommandParserTest, IsCommandValidTest_VErr)
136     {
137         CommandParser::GetInstance().argsMap.clear();
138         invalidParamVec.push_back("-v");
139         EXPECT_FALSE(CommandParser::GetInstance().ProcessCommand(invalidParamVec));
140         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
141     }
142 
TEST_F(CommandParserTest, IsCommandValidTest_PErr)143     TEST_F(CommandParserTest, IsCommandValidTest_PErr)
144     {
145         CommandParser::GetInstance().argsMap.clear();
146         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-p");
147         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
148             *std::next(it) = "new_value";
149         }
150         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
151         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
152         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
153             *std::next(it) = "655350";
154         }
155         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
156         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
157         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
158             *std::next(it) = "8888";
159         }
160     }
161 
TEST_F(CommandParserTest, IsCommandValidTest_JErr)162     TEST_F(CommandParserTest, IsCommandValidTest_JErr)
163     {
164         CommandParser::GetInstance().argsMap.clear();
165         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-j");
166         if (it != validParamVec.end()) {
167             *it = "-jjjjj";
168         }
169         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
170         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
171         if (it != validParamVec.end()) {
172             *it = "-j";
173         }
174     }
175 
TEST_F(CommandParserTest, IsCommandValidTest_NErr)176     TEST_F(CommandParserTest, IsCommandValidTest_NErr)
177     {
178         CommandParser::GetInstance().argsMap.clear();
179         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-n");
180         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
181             *std::next(it) = "~!@#$%^&";
182         }
183         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
184         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
185         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
186             std::string str(257, 'a');
187             *std::next(it) = str;
188         }
189         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
190         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
191         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
192             *std::next(it) = "entry";
193         }
194     }
195 
TEST_F(CommandParserTest, IsCommandValidTest_CrOrErr)196     TEST_F(CommandParserTest, IsCommandValidTest_CrOrErr)
197     {
198         CommandParser::GetInstance().argsMap.clear();
199         // no -cr param
200         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-cr");
201         if (it != validParamVec.end()) {
202             *it = "~!@#$%^&";
203         }
204         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
205         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
206         if (it != validParamVec.end()) {
207             *it = "-cr";
208         }
209         // -cr value invalid
210         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
211             *std::next(it) = "aaaa";
212         }
213         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
214         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
215         // params value invalid
216         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
217             *std::next(it) = "4000";
218         }
219         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
220         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
221         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
222             *std::next(it) = "1080";
223         }
224     }
225 
TEST_F(CommandParserTest, IsCommandValidTest_HsErr)226     TEST_F(CommandParserTest, IsCommandValidTest_HsErr)
227     {
228         CommandParser::GetInstance().argsMap.clear();
229         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-hs");
230         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
231             *std::next(it) = "~!@#$%^&";
232         }
233         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
234         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
235         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
236             *std::next(it) = "524289";
237         }
238         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
239         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
240         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
241             *std::next(it) = "100000";
242         }
243     }
244 
TEST_F(CommandParserTest, IsCommandValidTest_HfErr)245     TEST_F(CommandParserTest, IsCommandValidTest_HfErr)
246     {
247         CommandParser::GetInstance().argsMap.clear();
248         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-hf");
249         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
250             *std::next(it) = "~!@#$%^&";
251         }
252         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
253         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
254         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
255             *std::next(it) = "true";
256         }
257     }
258 
TEST_F(CommandParserTest, IsCommandValidTest_ShapeErr)259     TEST_F(CommandParserTest, IsCommandValidTest_ShapeErr)
260     {
261         CommandParser::GetInstance().argsMap.clear();
262         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-shape");
263         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
264             *std::next(it) = "~!@#$%^&";
265         }
266         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
267         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
268         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
269             *std::next(it) = "rect";
270         }
271     }
272 
TEST_F(CommandParserTest, IsCommandValidTest_DeviceErr)273     TEST_F(CommandParserTest, IsCommandValidTest_DeviceErr)
274     {
275         CommandParser::GetInstance().argsMap.clear();
276         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-device");
277         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
278             *std::next(it) = "~!@#$%^&";
279         }
280         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
281         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
282         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
283             *std::next(it) = "phone";
284         }
285     }
286 
TEST_F(CommandParserTest, IsCommandValidTest_UrlErr)287     TEST_F(CommandParserTest, IsCommandValidTest_UrlErr)
288     {
289         CommandParser::GetInstance().argsMap.clear();
290         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-url");
291         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
292             *std::next(it) = "";
293         }
294         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
295         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
296         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
297             *std::next(it) = "pages/BigImg_1M";
298         }
299     }
300 
TEST_F(CommandParserTest, IsCommandValidTest_FErr)301     TEST_F(CommandParserTest, IsCommandValidTest_FErr)
302     {
303         CommandParser::GetInstance().argsMap.clear();
304         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-f");
305         if (it != validParamVec.end()) {
306             *it = "ffff";
307         }
308         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
309         EXPECT_TRUE(CommandParser::GetInstance().IsCommandValid());
310         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
311             *it = "-f";
312             *std::next(it) = "pages/BigImg_1M";
313         }
314         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
315         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
316         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
317             *std::next(it) = currFile;
318         }
319     }
320 
TEST_F(CommandParserTest, IsCommandValidTest_ArpErr)321     TEST_F(CommandParserTest, IsCommandValidTest_ArpErr)
322     {
323         CommandParser::GetInstance().argsMap.clear();
324         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-arp");
325         if (it != validParamVec.end()) {
326             *it = "aaarp";
327         }
328         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
329         EXPECT_TRUE(CommandParser::GetInstance().IsCommandValid());
330         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
331             *it = "-arp";
332             *std::next(it) = "pages/BigImg_1M";
333         }
334         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
335         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
336         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
337             *std::next(it) = currDir;
338         }
339     }
340 
TEST_F(CommandParserTest, IsCommandValidTest_PmErr)341     TEST_F(CommandParserTest, IsCommandValidTest_PmErr)
342     {
343         CommandParser::GetInstance().argsMap.clear();
344         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-pm");
345         if (it != validParamVec.end()) {
346             *it = "aaapm";
347         }
348         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
349         EXPECT_TRUE(CommandParser::GetInstance().IsCommandValid());
350         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
351             *it = "-pm";
352             *std::next(it) = "aaa";
353         }
354         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
355         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
356         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
357             *std::next(it) = "Stage";
358         }
359     }
360 
TEST_F(CommandParserTest, IsCommandValidTest_PagesErr)361     TEST_F(CommandParserTest, IsCommandValidTest_PagesErr)
362     {
363         CommandParser::GetInstance().argsMap.clear();
364         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-pages");
365         if (it != validParamVec.end()) {
366             *it = "aaapages";
367         }
368         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
369         EXPECT_TRUE(CommandParser::GetInstance().IsCommandValid());
370         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
371             *it = "-pages";
372             *std::next(it) = "~!@#$%^";
373         }
374         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
375         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
376         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
377             *std::next(it) = "main_pages";
378         }
379     }
380 
TEST_F(CommandParserTest, IsCommandValidTest_RefreshErr)381     TEST_F(CommandParserTest, IsCommandValidTest_RefreshErr)
382     {
383         CommandParser::GetInstance().argsMap.clear();
384         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-refresh");
385         if (it != validParamVec.end()) {
386             *it = "aaarefresh";
387         }
388         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
389         EXPECT_TRUE(CommandParser::GetInstance().IsCommandValid());
390         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
391             *it = "-refresh";
392             *std::next(it) = "~!@#$%^";
393         }
394         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
395         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
396         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
397             *std::next(it) = "region";
398         }
399     }
400 
TEST_F(CommandParserTest, IsCommandValidTest_CardErr)401     TEST_F(CommandParserTest, IsCommandValidTest_CardErr)
402     {
403         CommandParser::GetInstance().argsMap.clear();
404         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-card");
405         if (it != validParamVec.end()) {
406             *it = "aaacard";
407         }
408         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
409         EXPECT_TRUE(CommandParser::GetInstance().IsCommandValid());
410         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
411             *it = "-card";
412             *std::next(it) = "~!@#$%^";
413         }
414         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
415         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
416         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
417             *std::next(it) = "true";
418         }
419     }
420 
TEST_F(CommandParserTest, IsCommandValidTest_ProjectIdErr)421     TEST_F(CommandParserTest, IsCommandValidTest_ProjectIdErr)
422     {
423         CommandParser::GetInstance().argsMap.clear();
424         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-projectID");
425         if (it != validParamVec.end()) {
426             *it = "aaaprojectID";
427         }
428         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
429         EXPECT_TRUE(CommandParser::GetInstance().IsCommandValid());
430         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
431             *it = "-projectID";
432             *std::next(it) = "~!@#$%^";
433         }
434         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
435         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
436         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
437             *std::next(it) = "138968279";
438         }
439     }
440 
TEST_F(CommandParserTest, IsCommandValidTest_CmErr)441     TEST_F(CommandParserTest, IsCommandValidTest_CmErr)
442     {
443         CommandParser::GetInstance().argsMap.clear();
444         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-cm");
445         if (it != validParamVec.end()) {
446             *it = "aaacm";
447         }
448         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
449         EXPECT_TRUE(CommandParser::GetInstance().IsCommandValid());
450         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
451             *it = "-cm";
452             *std::next(it) = "~!@#$%^";
453         }
454         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
455         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
456         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
457             *std::next(it) = "light";
458         }
459     }
460 
TEST_F(CommandParserTest, IsCommandValidTest_AvErr)461     TEST_F(CommandParserTest, IsCommandValidTest_AvErr)
462     {
463         CommandParser::GetInstance().argsMap.clear();
464         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-av");
465         if (it != validParamVec.end()) {
466             *it = "aaaav";
467         }
468         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
469         EXPECT_TRUE(CommandParser::GetInstance().IsCommandValid());
470         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
471             *it = "-av";
472             *std::next(it) = "~!@#$%^";
473         }
474         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
475         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
476         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
477             *std::next(it) = "ACE_2_0";
478         }
479     }
480 
TEST_F(CommandParserTest, IsCommandValidTest_OErr)481     TEST_F(CommandParserTest, IsCommandValidTest_OErr)
482     {
483         CommandParser::GetInstance().argsMap.clear();
484         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-o");
485         if (it != validParamVec.end()) {
486             *it = "aaao";
487         }
488         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
489         EXPECT_TRUE(CommandParser::GetInstance().IsCommandValid());
490         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
491             *it = "-o";
492             *std::next(it) = "~!@#$%^";
493         }
494         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
495         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
496         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
497             *std::next(it) = "portrait";
498         }
499     }
500 
TEST_F(CommandParserTest, IsCommandValidTest_LwsErr)501     TEST_F(CommandParserTest, IsCommandValidTest_LwsErr)
502     {
503         CommandParser::GetInstance().argsMap.clear();
504         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-lws");
505         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
506             *std::next(it) = "~!@#$%^";
507         }
508         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
509         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
510         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
511             *std::next(it) = "65536";
512         }
513         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
514         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
515         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
516             *std::next(it) = "40003";
517         }
518     }
519 
TEST_F(CommandParserTest, IsCommandValidTest_SmErr)520     TEST_F(CommandParserTest, IsCommandValidTest_SmErr)
521     {
522         CommandParser::GetInstance().argsMap.clear();
523         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-sm");
524         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
525             *std::next(it) = "~!@#$%^";
526         }
527         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
528         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
529         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
530             *std::next(it) = "static";
531         }
532     }
533 
TEST_F(CommandParserTest, IsCommandValidTest_HspErr)534     TEST_F(CommandParserTest, IsCommandValidTest_HspErr)
535     {
536         CommandParser::GetInstance().argsMap.clear();
537         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-hsp");
538         if (it != validParamVec.end()) {
539             *it = "aaahsp";
540         }
541         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
542         EXPECT_TRUE(CommandParser::GetInstance().IsCommandValid());
543         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
544             *it = "-hsp";
545             *std::next(it) = "~!@#$%^";
546         }
547         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
548         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
549         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
550             *std::next(it) = currDir;
551         }
552     }
553 
TEST_F(CommandParserTest, IsCommandValidTest_CpmErr)554     TEST_F(CommandParserTest, IsCommandValidTest_CpmErr)
555     {
556         CommandParser::GetInstance().argsMap.clear();
557         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-cpm");
558         if (it != validParamVec.end()) {
559             *it = "aaacpm";
560         }
561         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
562         EXPECT_TRUE(CommandParser::GetInstance().IsCommandValid());
563         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
564             *it = "-cpm";
565             *std::next(it) = "~!@#$%^";
566         }
567         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
568         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
569         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
570             *std::next(it) = "true";
571         }
572     }
573 
TEST_F(CommandParserTest, IsCommandValidTest_AbpErr)574     TEST_F(CommandParserTest, IsCommandValidTest_AbpErr)
575     {
576         CommandParser::GetInstance().argsMap.clear();
577         // lite device
578         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-device");
579         if (it != validParamVec.end()) {
580             *std::next(it) = "liteWearable";
581         }
582         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
583         EXPECT_TRUE(CommandParser::GetInstance().IsCommandValid());
584         if (it != validParamVec.end()) {
585             *std::next(it) = "phone";
586         }
587         // no -d
588         it = std::find(validParamVec.begin(), validParamVec.end(), "-d");
589         if (it != validParamVec.end()) {
590             *it = "aaad";
591         }
592         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
593         EXPECT_TRUE(CommandParser::GetInstance().IsCommandValid());
594         if (it != validParamVec.end()) {
595             *it = "-d";
596         }
597         // no -abp
598         CommandParser::GetInstance().argsMap.clear();
599         it = std::find(validParamVec.begin(), validParamVec.end(), "-abp");
600         if (it != validParamVec.end()) {
601             *it = "aaaabp";
602         }
603         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
604         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
605         // -abp value empty
606         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
607             *it = "-abp";
608             *std::next(it) = "";
609         }
610         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
611         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
612         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
613             *std::next(it) = "ets/entryability/EntryAbility.abc";
614         }
615     }
616 
TEST_F(CommandParserTest, IsCommandValidTest_AbnErr)617     TEST_F(CommandParserTest, IsCommandValidTest_AbnErr)
618     {
619         CommandParser::GetInstance().argsMap.clear();
620         // no -d
621         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-d");
622         if (it != validParamVec.end()) {
623             *it = "aaad";
624         }
625         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
626         EXPECT_TRUE(CommandParser::GetInstance().IsCommandValid());
627         if (it != validParamVec.end()) {
628             *it = "-d";
629         }
630         // lite device
631         it = std::find(validParamVec.begin(), validParamVec.end(), "-device");
632         if (it != validParamVec.end()) {
633             *std::next(it) = "liteWearable";
634         }
635         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
636         EXPECT_TRUE(CommandParser::GetInstance().IsCommandValid());
637         if (it != validParamVec.end()) {
638             *std::next(it) = "phone";
639         }
640         // no -abn
641         CommandParser::GetInstance().argsMap.clear();
642         it = std::find(validParamVec.begin(), validParamVec.end(), "-abn");
643         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
644             *it = "aaaabn";
645         }
646         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
647         EXPECT_TRUE(CommandParser::GetInstance().IsCommandValid());
648         // -abn value empty
649         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
650             *it = "-abn";
651             *std::next(it) = "";
652         }
653         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
654         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
655         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
656             *std::next(it) = "EntryAbility";
657         }
658     }
659 
TEST_F(CommandParserTest, IsCommandValidTest_StaticCardErr)660     TEST_F(CommandParserTest, IsCommandValidTest_StaticCardErr)
661     {
662         CommandParser::GetInstance().argsMap.clear();
663         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-staticCard");
664         if (it != validParamVec.end()) {
665             *it = "aaastaticCard";
666         }
667         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
668         EXPECT_TRUE(CommandParser::GetInstance().IsCommandValid());
669         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
670             *it = "-staticCard";
671             *std::next(it) = "~!@#$%^";
672         }
673         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
674         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
675         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
676             *std::next(it) = "true";
677         }
678     }
679 
TEST_F(CommandParserTest, IsCommandValidTest_FoldableErr)680     TEST_F(CommandParserTest, IsCommandValidTest_FoldableErr)
681     {
682         CommandParser::GetInstance().argsMap.clear();
683         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-foldable");
684         if (it != validParamVec.end()) {
685             *it = "aaafoldable";
686         }
687         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
688         EXPECT_TRUE(CommandParser::GetInstance().IsCommandValid());
689         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
690             *it = "-foldable";
691             *std::next(it) = "~!@#$%^";
692         }
693         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
694         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
695         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
696             *std::next(it) = "true";
697         }
698     }
699 
TEST_F(CommandParserTest, IsCommandValidTest_FoldStatusErr)700     TEST_F(CommandParserTest, IsCommandValidTest_FoldStatusErr)
701     {
702         CommandParser::GetInstance().argsMap.clear();
703         // no -foldable
704         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-foldable");
705         if (it != validParamVec.end()) {
706             *it = "aaafoldable";
707         }
708         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
709         EXPECT_TRUE(CommandParser::GetInstance().IsCommandValid());
710         // param -foldable value is false
711         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
712             *it = "-foldable";
713             *std::next(it) = "false";
714         }
715         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
716         EXPECT_TRUE(CommandParser::GetInstance().IsCommandValid());
717         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
718             *std::next(it) = "true";
719         }
720         // param foldStatus value invalid
721         CommandParser::GetInstance().argsMap.clear();
722         it = std::find(validParamVec.begin(), validParamVec.end(), "-foldStatus");
723         if (it != validParamVec.end()) {
724             *it = "aaafoldStatus";
725         }
726         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
727         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
728         if (it != validParamVec.end()) {
729             *it = "-foldStatus";
730         }
731     }
732 
TEST_F(CommandParserTest, IsCommandValidTest_FrErr)733     TEST_F(CommandParserTest, IsCommandValidTest_FrErr)
734     {
735         CommandParser::GetInstance().argsMap.clear();
736         // no -foldable
737         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-foldable");
738         if (it != validParamVec.end()) {
739             *it = "aaafoldable";
740         }
741         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
742         EXPECT_TRUE(CommandParser::GetInstance().IsCommandValid());
743         // param -foldable value is false
744         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
745             *it = "-foldable";
746             *std::next(it) = "false";
747         }
748         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
749         EXPECT_TRUE(CommandParser::GetInstance().IsCommandValid());
750         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
751             *std::next(it) = "true";
752         }
753         // no param -fr
754         CommandParser::GetInstance().argsMap.clear();
755         it = std::find(validParamVec.begin(), validParamVec.end(), "-fr");
756         if (it != validParamVec.end()) {
757             *it = "aaafr";
758         }
759         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
760         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
761         if (it != validParamVec.end()) {
762             *it = "-fr";
763         }
764         // param -fr value is invalid
765         it = std::find(validParamVec.begin(), validParamVec.end(), "-fr");
766         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
767             *std::next(it) = "aaaa";
768         }
769         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
770         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
771         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
772             *std::next(it) = "1080";
773         }
774     }
775 
TEST_F(CommandParserTest, IsCommandValidTest_LjPathErr)776     TEST_F(CommandParserTest, IsCommandValidTest_LjPathErr)
777     {
778         CommandParser::GetInstance().argsMap.clear();
779         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-ljPath");
780         if (it != validParamVec.end()) {
781             *it = "aaaljPath";
782         }
783         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
784         EXPECT_TRUE(CommandParser::GetInstance().IsCommandValid());
785         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
786             *it = "-ljPath";
787             *std::next(it) = "~!@#$%^";
788         }
789         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
790         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
791         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
792             *std::next(it) = currFile;
793         }
794     }
795 
TEST_F(CommandParserTest, IsCommandValidTest_LErr)796     TEST_F(CommandParserTest, IsCommandValidTest_LErr)
797     {
798         CommandParser::GetInstance().argsMap.clear();
799         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-l");
800         if (it != validParamVec.end()) {
801             *it = "aaal";
802         }
803         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
804         EXPECT_TRUE(CommandParser::GetInstance().IsCommandValid());
805         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
806             *it = "-l";
807             *std::next(it) = "~!@#$%^";
808         }
809         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
810         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
811         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
812             *std::next(it) = "zh_CN";
813         }
814     }
815 
TEST_F(CommandParserTest, IsCommandValidTest_TsErr)816     TEST_F(CommandParserTest, IsCommandValidTest_TsErr)
817     {
818         CommandParser::GetInstance().argsMap.clear();
819         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-ts");
820         if (it != validParamVec.end()) {
821             *it = "aaats";
822         }
823         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
824         EXPECT_TRUE(CommandParser::GetInstance().IsCommandValid());
825         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
826             *it = "-ts";
827             *std::next(it) = "~!@#$%^";
828         }
829         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
830         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
831         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
832             *std::next(it) = "trace_70259_commandPipe";
833         }
834     }
835 
TEST_F(CommandParserTest, IsCommandValidTest_SErr)836     TEST_F(CommandParserTest, IsCommandValidTest_SErr)
837     {
838         CommandParser::GetInstance().argsMap.clear();
839         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-s");
840         if (it != validParamVec.end()) {
841             *it = "aaas";
842         }
843         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
844         EXPECT_TRUE(CommandParser::GetInstance().IsCommandValid());
845         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
846             *it = "-s";
847             *std::next(it) = "~!@#$%^";
848         }
849         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
850         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
851         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
852             *std::next(it) = "componentpreviewinstance_1712054594321_1";
853         }
854     }
855 
TEST_F(CommandParserTest, IsCommandValidTest_SdErr)856     TEST_F(CommandParserTest, IsCommandValidTest_SdErr)
857     {
858         CommandParser::GetInstance().argsMap.clear();
859         auto it = std::find(validParamVec.begin(), validParamVec.end(), "-sd");
860         if (it != validParamVec.end()) {
861             *it = "aaasd";
862         }
863         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
864         EXPECT_TRUE(CommandParser::GetInstance().IsCommandValid());
865         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
866             *it = "-sd";
867             *std::next(it) = "~!@#$%^";
868         }
869         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
870         EXPECT_FALSE(CommandParser::GetInstance().IsCommandValid());
871         if (it != validParamVec.end() && std::next(it) != validParamVec.end()) {
872             *std::next(it) = "480";
873         }
874     }
875 
876 
TEST_F(CommandParserTest, IsCommandValidTest1)877     TEST_F(CommandParserTest, IsCommandValidTest1)
878     {
879         CommandParser::GetInstance().argsMap.clear();
880         EXPECT_TRUE(CommandParser::GetInstance().ProcessCommand(validParamVec));
881         EXPECT_TRUE(CommandParser::GetInstance().IsCommandValid());
882     }
883 
TEST_F(CommandParserTest, ValueTest)884     TEST_F(CommandParserTest, ValueTest)
885     {
886         std::string str1 = "abcd";
887         std::string str2 = "rect";
888         std::string str3 = CommandParser::GetInstance().Value("shape");
889         EXPECT_EQ(str2, str3);
890         EXPECT_NE(str1, str3);
891     }
892 
TEST_F(CommandParserTest, ValuesTest)893     TEST_F(CommandParserTest, ValuesTest)
894     {
895         std::vector<std::string> vec1 = {"1111", "2222"};
896         std::vector<std::string> vec2 = {"1080", "2340"};
897         std::vector<std::string> vec3 = CommandParser::GetInstance().Values("or");
898         for (int i = 0; i < vec3.size(); i++) {
899             EXPECT_NE(vec1[i], vec3[i]);
900         }
901         for (int i = 0; i < vec3.size(); i++) {
902             EXPECT_EQ(vec2[i], vec3[i]);
903         }
904     }
905 
TEST_F(CommandParserTest, RegisterTest)906     TEST_F(CommandParserTest, RegisterTest)
907     {
908         std::string key = "-abcd";
909         uint32_t count = 1;
910         CommandParser::GetInstance().Register(key, count, "abcd");
911         uint32_t num = CommandParser::GetInstance().regsArgsCountMap[key];
912         std::string helpStr = CommandParser::GetInstance().regsHelpMap[key];
913         EXPECT_EQ(num, count);
914         EXPECT_EQ(helpStr, "abcd");
915     }
916 
TEST_F(CommandParserTest, IsResolutionValidTest)917     TEST_F(CommandParserTest, IsResolutionValidTest)
918     {
919         int32_t val1 = 0;
920         int32_t val2 = 1;
921         int32_t val3 = 1024;
922         int32_t val4 = 3840;
923         int32_t val5 = 3841;
924         EXPECT_FALSE(CommandParser::GetInstance().IsResolutionValid(val1));
925         EXPECT_TRUE(CommandParser::GetInstance().IsResolutionValid(val2));
926         EXPECT_TRUE(CommandParser::GetInstance().IsResolutionValid(val3));
927         EXPECT_TRUE(CommandParser::GetInstance().IsResolutionValid(val4));
928         EXPECT_FALSE(CommandParser::GetInstance().IsResolutionValid(val5));
929     }
930 
TEST_F(CommandParserTest, GetOrignalResolutionWidthTest)931     TEST_F(CommandParserTest, GetOrignalResolutionWidthTest)
932     {
933         int32_t val1 = 1080;
934         EXPECT_EQ(CommandParser::GetInstance().GetOrignalResolutionWidth(), val1);
935     }
936 
TEST_F(CommandParserTest, GetOrignalResolutionHeightTest)937     TEST_F(CommandParserTest, GetOrignalResolutionHeightTest)
938     {
939         int32_t val1 = 2340;
940         EXPECT_EQ(CommandParser::GetInstance().GetOrignalResolutionHeight(), val1);
941     }
942 
TEST_F(CommandParserTest, GetCompressionResolutionWidthTest)943     TEST_F(CommandParserTest, GetCompressionResolutionWidthTest)
944     {
945         int32_t val1 = 1080;
946         EXPECT_EQ(CommandParser::GetInstance().GetCompressionResolutionWidth(), val1);
947     }
948 
TEST_F(CommandParserTest, GetCompressionResolutionHeightTest)949     TEST_F(CommandParserTest, GetCompressionResolutionHeightTest)
950     {
951         int32_t val1 = 2340;
952         EXPECT_EQ(CommandParser::GetInstance().GetCompressionResolutionHeight(), val1);
953     }
954 
TEST_F(CommandParserTest, GetJsHeapSizeTest)955     TEST_F(CommandParserTest, GetJsHeapSizeTest)
956     {
957         int32_t val1 = 100000;
958         EXPECT_EQ(CommandParser::GetInstance().GetJsHeapSize(), val1);
959     }
960 
TEST_F(CommandParserTest, GetAppNameTest)961     TEST_F(CommandParserTest, GetAppNameTest)
962     {
963         std::string val1 = "entry";
964         EXPECT_EQ(CommandParser::GetInstance().GetAppName(), val1);
965     }
966 
TEST_F(CommandParserTest, IsSendJSHeapTest)967     TEST_F(CommandParserTest, IsSendJSHeapTest)
968     {
969         EXPECT_TRUE(CommandParser::GetInstance().IsSendJSHeap());
970     }
971 
TEST_F(CommandParserTest, GetDeviceTypeTest)972     TEST_F(CommandParserTest, GetDeviceTypeTest)
973     {
974         EXPECT_EQ(CommandParser::GetInstance().GetDeviceType(), "phone");
975     }
976 
TEST_F(CommandParserTest, IsRegionRefreshTest)977     TEST_F(CommandParserTest, IsRegionRefreshTest)
978     {
979         EXPECT_TRUE(CommandParser::GetInstance().IsRegionRefresh());
980     }
981 
TEST_F(CommandParserTest, IsCardDisplayTest)982     TEST_F(CommandParserTest, IsCardDisplayTest)
983     {
984         EXPECT_TRUE(CommandParser::GetInstance().IsCardDisplay());
985     }
986 
TEST_F(CommandParserTest, GetConfigPathTest)987     TEST_F(CommandParserTest, GetConfigPathTest)
988     {
989         EXPECT_EQ(CommandParser::GetInstance().GetConfigPath(), currFile);
990     }
991 
TEST_F(CommandParserTest, GetProjectIDTest)992     TEST_F(CommandParserTest, GetProjectIDTest)
993     {
994         std::string str = "138968279";
995         EXPECT_EQ(CommandParser::GetInstance().GetProjectID(), str);
996     }
997 
TEST_F(CommandParserTest, GetScreenModeTest)998     TEST_F(CommandParserTest, GetScreenModeTest)
999     {
1000         std::string str = "static";
1001         EXPECT_EQ(CommandParser::GetInstance().GetScreenMode(), CommandParser::ScreenMode::STATIC);
1002     }
1003 
TEST_F(CommandParserTest, GetConfigChangesTest)1004     TEST_F(CommandParserTest, GetConfigChangesTest)
1005     {
1006         EXPECT_EQ(CommandParser::GetInstance().GetConfigChanges(), "");
1007     }
1008 
TEST_F(CommandParserTest, GetAppResourcePathTest)1009     TEST_F(CommandParserTest, GetAppResourcePathTest)
1010     {
1011         EXPECT_EQ(CommandParser::GetInstance().GetAppResourcePath(), currDir);
1012     }
1013 
TEST_F(CommandParserTest, GetScreenShapeTest)1014     TEST_F(CommandParserTest, GetScreenShapeTest)
1015     {
1016         std::string str = "rect";
1017         EXPECT_EQ(CommandParser::GetInstance().GetScreenShape(), str);
1018     }
1019 
TEST_F(CommandParserTest, GetProjectModelTest)1020     TEST_F(CommandParserTest, GetProjectModelTest)
1021     {
1022         std::string str = "Stage";
1023         EXPECT_EQ(CommandParser::GetInstance().GetProjectModel(), str);
1024     }
1025 
TEST_F(CommandParserTest, GetProjectModelEnumValueTest)1026     TEST_F(CommandParserTest, GetProjectModelEnumValueTest)
1027     {
1028         int value = 1;
1029         EXPECT_EQ(CommandParser::GetInstance().GetProjectModelEnumValue(), value);
1030     }
1031 
TEST_F(CommandParserTest, GetProjectModelEnumNameTest)1032     TEST_F(CommandParserTest, GetProjectModelEnumNameTest)
1033     {
1034         int index = 0;
1035         EXPECT_EQ(CommandParser::GetInstance().GetProjectModelEnumName(index), "FA");
1036         index = 1;
1037         EXPECT_EQ(CommandParser::GetInstance().GetProjectModelEnumName(index), "Stage");
1038         index = -1;
1039         EXPECT_EQ(CommandParser::GetInstance().GetProjectModelEnumName(index), "FA");
1040         index = 2;
1041         EXPECT_EQ(CommandParser::GetInstance().GetProjectModelEnumName(index), "FA");
1042     }
1043 
TEST_F(CommandParserTest, GetPagesTest)1044     TEST_F(CommandParserTest, GetPagesTest)
1045     {
1046         std::string str = "main_pages";
1047         EXPECT_EQ(CommandParser::GetInstance().GetPages(), str);
1048     }
1049 
TEST_F(CommandParserTest, GetContainerSdkPathTest)1050     TEST_F(CommandParserTest, GetContainerSdkPathTest)
1051     {
1052         EXPECT_EQ(CommandParser::GetInstance().GetContainerSdkPath(), currDir);
1053     }
1054 
TEST_F(CommandParserTest, CheckParamInvalidityTest)1055     TEST_F(CommandParserTest, CheckParamInvalidityTest)
1056     {
1057         std::string param = "0";
1058         EXPECT_FALSE(CommandParser::GetInstance().CheckParamInvalidity(param, true));
1059         EXPECT_FALSE(CommandParser::GetInstance().CheckParamInvalidity(param, false));
1060         param = "110";
1061         EXPECT_FALSE(CommandParser::GetInstance().CheckParamInvalidity(param, true));
1062         EXPECT_FALSE(CommandParser::GetInstance().CheckParamInvalidity(param, false));
1063         param = "01";
1064         EXPECT_TRUE(CommandParser::GetInstance().CheckParamInvalidity(param, true));
1065         EXPECT_FALSE(CommandParser::GetInstance().CheckParamInvalidity(param, false));
1066         param = "ab01";
1067         EXPECT_TRUE(CommandParser::GetInstance().CheckParamInvalidity(param, true));
1068         EXPECT_FALSE(CommandParser::GetInstance().CheckParamInvalidity(param, false));
1069         param = "0.34";
1070         EXPECT_FALSE(CommandParser::GetInstance().CheckParamInvalidity(param, true));
1071         EXPECT_FALSE(CommandParser::GetInstance().CheckParamInvalidity(param, false));
1072         param = "10.34";
1073         EXPECT_FALSE(CommandParser::GetInstance().CheckParamInvalidity(param, true));
1074         EXPECT_FALSE(CommandParser::GetInstance().CheckParamInvalidity(param, false));
1075     }
1076 
TEST_F(CommandParserTest, IsComponentModeTest)1077     TEST_F(CommandParserTest, IsComponentModeTest)
1078     {
1079         EXPECT_TRUE(CommandParser::GetInstance().IsComponentMode());
1080     }
1081 
TEST_F(CommandParserTest, GetAbilityPathTest)1082     TEST_F(CommandParserTest, GetAbilityPathTest)
1083     {
1084         std::string str = "ets/entryability/EntryAbility.abc";
1085         EXPECT_EQ(CommandParser::GetInstance().GetAbilityPath(), str);
1086     }
1087 
TEST_F(CommandParserTest, GetAbilityNameTest)1088     TEST_F(CommandParserTest, GetAbilityNameTest)
1089     {
1090         std::string str = "EntryAbility";
1091         EXPECT_EQ(CommandParser::GetInstance().GetAbilityName(), str);
1092     }
1093 
TEST_F(CommandParserTest, IsStaticCardTest)1094     TEST_F(CommandParserTest, IsStaticCardTest)
1095     {
1096         EXPECT_TRUE(CommandParser::GetInstance().IsStaticCard());
1097     }
1098 
TEST_F(CommandParserTest, IsMainArgLengthInvalidTest)1099     TEST_F(CommandParserTest, IsMainArgLengthInvalidTest)
1100     {
1101         std::string validStr = "1111111";
1102         EXPECT_FALSE(CommandParser::GetInstance().IsMainArgLengthInvalid(validStr.c_str()));
1103         int desiredLength = 1184;
1104         char initialChar = '1';
1105         std::string invalidStr(desiredLength, initialChar);
1106         EXPECT_TRUE(CommandParser::GetInstance().IsMainArgLengthInvalid(invalidStr.c_str()));
1107     }
1108 
TEST_F(CommandParserTest, IsFoldableTest)1109     TEST_F(CommandParserTest, IsFoldableTest)
1110     {
1111         EXPECT_TRUE(CommandParser::GetInstance().IsFoldable());
1112     }
1113 
TEST_F(CommandParserTest, GetFoldStatusTest)1114     TEST_F(CommandParserTest, GetFoldStatusTest)
1115     {
1116         std::string str = "half_fold";
1117         EXPECT_EQ(CommandParser::GetInstance().GetFoldStatus(), str);
1118     }
1119 
TEST_F(CommandParserTest, GetFoldResolutionWidthTest)1120     TEST_F(CommandParserTest, GetFoldResolutionWidthTest)
1121     {
1122         int32_t value = 1080;
1123         EXPECT_EQ(CommandParser::GetInstance().GetFoldResolutionWidth(), value);
1124     }
1125 
TEST_F(CommandParserTest, GetFoldResolutionHeightTest)1126     TEST_F(CommandParserTest, GetFoldResolutionHeightTest)
1127     {
1128         int32_t value = 2504;
1129         EXPECT_EQ(CommandParser::GetInstance().GetFoldResolutionHeight(), value);
1130     }
1131 
TEST_F(CommandParserTest, GetLoaderJsonPathTest)1132     TEST_F(CommandParserTest, GetLoaderJsonPathTest)
1133     {
1134         EXPECT_EQ(CommandParser::GetInstance().GetLoaderJsonPath(), currFile);
1135     }
1136 
TEST_F(CommandParserTest, GetCommandInfoTest)1137     TEST_F(CommandParserTest, GetCommandInfoTest)
1138     {
1139         CommandInfo info;
1140         CommandParser::GetInstance().GetCommandInfo(info);
1141         EXPECT_EQ(info.deviceType, "phone");
1142         EXPECT_TRUE(info.isComponentMode);
1143     }
1144 
TEST_F(CommandParserTest, GetFoldInfoTest)1145     TEST_F(CommandParserTest, GetFoldInfoTest)
1146     {
1147         FoldInfo info;
1148         CommandParser::GetInstance().GetFoldInfo(info);
1149         EXPECT_TRUE(info.foldable);
1150         EXPECT_EQ(info.foldStatus, "half_fold");
1151     }
1152 
TEST_F(CommandParserTest, ParseArgsTest)1153     TEST_F(CommandParserTest, ParseArgsTest)
1154     {
1155         int argc = 5;
1156         char* argv[5]; // 5 is array length
1157         // param value length is out of range
1158         int desiredLength = 1184;
1159         char initialChar = '1';
1160         std::string invalidStr(desiredLength, initialChar);
1161         argv[1] = "-p";
1162         argv[2] = const_cast<char*>(invalidStr.c_str());
1163         int ret = CommandParser::GetInstance().ParseArgs(argc, argv);
1164         EXPECT_EQ(ret, 11); // 11 is expect return value
1165         // param value invalid
1166         argv[2] = "999999999";
1167         ret = CommandParser::GetInstance().ParseArgs(argc, argv);
1168         EXPECT_EQ(ret, 11); // 11 is expect return value
1169         argv[2] = "9999";
1170         ret = CommandParser::GetInstance().ParseArgs(argc, argv);
1171         EXPECT_EQ(ret, -1); // -1 is expect return valu
1172         // invalid param
1173         argv[3] = "-v";
1174         ret = CommandParser::GetInstance().ParseArgs(argc, argv);
1175         EXPECT_EQ(ret, 0); // 0 is expect return value
1176     }
1177 }