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
25namespace {
26    class CommandParserTest : public ::testing::Test {
27    public:
28        CommandParserTest() {}
29        ~CommandParserTest() {}
30    protected:
31        // 在整个测试夹具类执行前执行一次初始化操作
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        // 在整个测试夹具类执行后执行一次清理操作
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
931    TEST_F(CommandParserTest, GetOrignalResolutionWidthTest)
932    {
933        int32_t val1 = 1080;
934        EXPECT_EQ(CommandParser::GetInstance().GetOrignalResolutionWidth(), val1);
935    }
936
937    TEST_F(CommandParserTest, GetOrignalResolutionHeightTest)
938    {
939        int32_t val1 = 2340;
940        EXPECT_EQ(CommandParser::GetInstance().GetOrignalResolutionHeight(), val1);
941    }
942
943    TEST_F(CommandParserTest, GetCompressionResolutionWidthTest)
944    {
945        int32_t val1 = 1080;
946        EXPECT_EQ(CommandParser::GetInstance().GetCompressionResolutionWidth(), val1);
947    }
948
949    TEST_F(CommandParserTest, GetCompressionResolutionHeightTest)
950    {
951        int32_t val1 = 2340;
952        EXPECT_EQ(CommandParser::GetInstance().GetCompressionResolutionHeight(), val1);
953    }
954
955    TEST_F(CommandParserTest, GetJsHeapSizeTest)
956    {
957        int32_t val1 = 100000;
958        EXPECT_EQ(CommandParser::GetInstance().GetJsHeapSize(), val1);
959    }
960
961    TEST_F(CommandParserTest, GetAppNameTest)
962    {
963        std::string val1 = "entry";
964        EXPECT_EQ(CommandParser::GetInstance().GetAppName(), val1);
965    }
966
967    TEST_F(CommandParserTest, IsSendJSHeapTest)
968    {
969        EXPECT_TRUE(CommandParser::GetInstance().IsSendJSHeap());
970    }
971
972    TEST_F(CommandParserTest, GetDeviceTypeTest)
973    {
974        EXPECT_EQ(CommandParser::GetInstance().GetDeviceType(), "phone");
975    }
976
977    TEST_F(CommandParserTest, IsRegionRefreshTest)
978    {
979        EXPECT_TRUE(CommandParser::GetInstance().IsRegionRefresh());
980    }
981
982    TEST_F(CommandParserTest, IsCardDisplayTest)
983    {
984        EXPECT_TRUE(CommandParser::GetInstance().IsCardDisplay());
985    }
986
987    TEST_F(CommandParserTest, GetConfigPathTest)
988    {
989        EXPECT_EQ(CommandParser::GetInstance().GetConfigPath(), currFile);
990    }
991
992    TEST_F(CommandParserTest, GetProjectIDTest)
993    {
994        std::string str = "138968279";
995        EXPECT_EQ(CommandParser::GetInstance().GetProjectID(), str);
996    }
997
998    TEST_F(CommandParserTest, GetScreenModeTest)
999    {
1000        std::string str = "static";
1001        EXPECT_EQ(CommandParser::GetInstance().GetScreenMode(), CommandParser::ScreenMode::STATIC);
1002    }
1003
1004    TEST_F(CommandParserTest, GetConfigChangesTest)
1005    {
1006        EXPECT_EQ(CommandParser::GetInstance().GetConfigChanges(), "");
1007    }
1008
1009    TEST_F(CommandParserTest, GetAppResourcePathTest)
1010    {
1011        EXPECT_EQ(CommandParser::GetInstance().GetAppResourcePath(), currDir);
1012    }
1013
1014    TEST_F(CommandParserTest, GetScreenShapeTest)
1015    {
1016        std::string str = "rect";
1017        EXPECT_EQ(CommandParser::GetInstance().GetScreenShape(), str);
1018    }
1019
1020    TEST_F(CommandParserTest, GetProjectModelTest)
1021    {
1022        std::string str = "Stage";
1023        EXPECT_EQ(CommandParser::GetInstance().GetProjectModel(), str);
1024    }
1025
1026    TEST_F(CommandParserTest, GetProjectModelEnumValueTest)
1027    {
1028        int value = 1;
1029        EXPECT_EQ(CommandParser::GetInstance().GetProjectModelEnumValue(), value);
1030    }
1031
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
1044    TEST_F(CommandParserTest, GetPagesTest)
1045    {
1046        std::string str = "main_pages";
1047        EXPECT_EQ(CommandParser::GetInstance().GetPages(), str);
1048    }
1049
1050    TEST_F(CommandParserTest, GetContainerSdkPathTest)
1051    {
1052        EXPECT_EQ(CommandParser::GetInstance().GetContainerSdkPath(), currDir);
1053    }
1054
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
1077    TEST_F(CommandParserTest, IsComponentModeTest)
1078    {
1079        EXPECT_TRUE(CommandParser::GetInstance().IsComponentMode());
1080    }
1081
1082    TEST_F(CommandParserTest, GetAbilityPathTest)
1083    {
1084        std::string str = "ets/entryability/EntryAbility.abc";
1085        EXPECT_EQ(CommandParser::GetInstance().GetAbilityPath(), str);
1086    }
1087
1088    TEST_F(CommandParserTest, GetAbilityNameTest)
1089    {
1090        std::string str = "EntryAbility";
1091        EXPECT_EQ(CommandParser::GetInstance().GetAbilityName(), str);
1092    }
1093
1094    TEST_F(CommandParserTest, IsStaticCardTest)
1095    {
1096        EXPECT_TRUE(CommandParser::GetInstance().IsStaticCard());
1097    }
1098
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
1109    TEST_F(CommandParserTest, IsFoldableTest)
1110    {
1111        EXPECT_TRUE(CommandParser::GetInstance().IsFoldable());
1112    }
1113
1114    TEST_F(CommandParserTest, GetFoldStatusTest)
1115    {
1116        std::string str = "half_fold";
1117        EXPECT_EQ(CommandParser::GetInstance().GetFoldStatus(), str);
1118    }
1119
1120    TEST_F(CommandParserTest, GetFoldResolutionWidthTest)
1121    {
1122        int32_t value = 1080;
1123        EXPECT_EQ(CommandParser::GetInstance().GetFoldResolutionWidth(), value);
1124    }
1125
1126    TEST_F(CommandParserTest, GetFoldResolutionHeightTest)
1127    {
1128        int32_t value = 2504;
1129        EXPECT_EQ(CommandParser::GetInstance().GetFoldResolutionHeight(), value);
1130    }
1131
1132    TEST_F(CommandParserTest, GetLoaderJsonPathTest)
1133    {
1134        EXPECT_EQ(CommandParser::GetInstance().GetLoaderJsonPath(), currFile);
1135    }
1136
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
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
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}