1 /*
2  * Copyright (c) 2024-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 
16 #include <gtest/gtest.h>
17 #include "signature_tools_log.h"
18 #include "options.h"
19 #include "sign_tool_service_impl.h"
20 #include "localization_adapter.h"
21 #include "openssl/ssl.h"
22 #include "openssl/pem.h"
23 #include "openssl/err.h"
24 #include "p12_local.h"
25 #include "cmd_util.h"
26 #include "file_utils.h"
27 #include "params_run_tool.h"
28 #include "constant.h"
29 #include "params.h"
30 #include "params_trust_list.h"
31 #include "param_constants.h"
32 
33 namespace OHOS {
34 namespace SignatureTools {
35 
36 class ProcessCmdTest : public testing::Test {
37 public:
SetUpTestCase()38     static void SetUpTestCase()
39     {
40     };
TearDownTestCase()41     static void TearDownTestCase()
42     {
43     };
SetUp()44     void SetUp()
45     {
46     };
TearDown()47     void TearDown()
48     {
49     };
50 };
51 
52 /*
53  * @tc.name: processcmd_test_001
54  * @tc.desc: The ProcessCmd function is executed to generate the key pair.
55  * @tc.type: FUNC
56  * @tc.require:
57  */
HWTEST_F(ProcessCmdTest, processcmd_test_001, testing::ext::TestSize.Level1)58 HWTEST_F(ProcessCmdTest, processcmd_test_001, testing::ext::TestSize.Level1)
59 {
60     char arg0[] = "";
61     char arg1[] = "generate-keypair";
62     char arg2[] = "-keyAlias";
63     char arg3[] = "oh-app1-key-v1";
64     char arg4[] = "-keyPwd";
65     char arg5[] = "123456";
66     char arg6[] = "-keyAlg";
67     char arg7[] = "ECC";
68     char arg8[] = "-keySize";
69     char arg9[] = "NIST-P-384";
70     char arg10[] = "-keystoreFile";
71     char arg11[] = "./generateKeyPair/OpenHarmony.p12";
72     char arg12[] = "-keystorePwd";
73     char arg13[] = "123456";
74     char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13 };
75 
76     int argc = 14;
77     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
78 
79     EXPECT_EQ(ret, false);
80 }
81 
82 /*
83  * @tc.name: processcmd_test_002
84  * @tc.desc: Test typing empty characters and printing the help document.
85  * @tc.type: FUNC
86  * @tc.require:
87  */
HWTEST_F(ProcessCmdTest, processcmd_test_002, testing::ext::TestSize.Level1)88 HWTEST_F(ProcessCmdTest, processcmd_test_002, testing::ext::TestSize.Level1)
89 {
90     char arg0[] = "";
91     char arg1[] = "";
92     char* argv[] = { arg0, arg1 };
93 
94     int argc = 2;
95     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
96 
97     EXPECT_EQ(ret, true);
98 }
99 
100 /*
101  * @tc.name: processcmd_test_003
102  * @tc.desc: View the help documentation.
103  * @tc.type: FUNC
104  * @tc.require:
105  */
HWTEST_F(ProcessCmdTest, processcmd_test_003, testing::ext::TestSize.Level1)106 HWTEST_F(ProcessCmdTest, processcmd_test_003, testing::ext::TestSize.Level1)
107 {
108     char arg0[] = "";
109     char arg1[] = "-h";
110     char* argv[] = { arg0, arg1 };
111 
112     int argc = 2;
113     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
114 
115     EXPECT_EQ(ret, true);
116 }
117 
118 /*
119  * @tc.name: processcmd_test_004
120  * @tc.desc: Print version number.
121  * @tc.type: FUNC
122  * @tc.require:
123  */
HWTEST_F(ProcessCmdTest, processcmd_test_004, testing::ext::TestSize.Level1)124 HWTEST_F(ProcessCmdTest, processcmd_test_004, testing::ext::TestSize.Level1)
125 {
126     char arg0[] = "";
127     char arg1[] = "-v";
128     char* argv[] = { arg0, arg1 };
129 
130     int argc = 2;
131     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
132 
133     EXPECT_EQ(ret, true);
134 }
135 
136 /*
137  * @tc.name: processcmd_test_005
138  * @tc.desc: Check that the value command-line argument is empty.
139  * @tc.type: FUNC
140  * @tc.require:
141  */
HWTEST_F(ProcessCmdTest, processcmd_test_005, testing::ext::TestSize.Level1)142 HWTEST_F(ProcessCmdTest, processcmd_test_005, testing::ext::TestSize.Level1)
143 {
144     char arg0[] = "";
145     char arg1[] = "generate-keypair";
146     char arg2[] = "-keyAlias";
147     char arg3[] = "";
148     char* argv[] = { arg0, arg1, arg2, arg3 };
149 
150     int argc = 4;
151     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
152 
153     EXPECT_EQ(ret, false);
154 }
155 
156 /*
157  * @tc.name: processcmd_test_006
158  * @tc.desc: Checks whether the first argument of key has -.
159  * @tc.type: FUNC
160  * @tc.require:
161  */
HWTEST_F(ProcessCmdTest, processcmd_test_006, testing::ext::TestSize.Level1)162 HWTEST_F(ProcessCmdTest, processcmd_test_006, testing::ext::TestSize.Level1)
163 {
164     char arg0[] = "";
165     char arg1[] = "generate-keypair";
166     char arg2[] = "";
167     char arg3[] = "";
168     char* argv[] = { arg0, arg1, arg2, arg3 };
169 
170     int argc = 4;
171     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
172 
173     EXPECT_EQ(ret, false);
174 }
175 
176 /*
177  * @tc.name: processcmd_test_007
178  * @tc.desc: Check whether the key algorithm is NIST-P-384 or NIST-P-256.
179  * @tc.type: FUNC
180  * @tc.require:
181  */
HWTEST_F(ProcessCmdTest, processcmd_test_007, testing::ext::TestSize.Level1)182 HWTEST_F(ProcessCmdTest, processcmd_test_007, testing::ext::TestSize.Level1)
183 {
184     char arg0[] = "";
185     char arg1[] = "generate-keypair";
186     char arg2[] = "-keyAlias";
187     char arg3[] = "oh-app1-key-v1";
188     char arg4[] = "-keyPwd";
189     char arg5[] = "123456";
190     char arg6[] = "-keyAlg";
191     char arg7[] = "ECC";
192     char arg8[] = "-keySize";
193     char arg9[] = "NIST-P-385";
194     char arg10[] = "-keystoreFile";
195     char arg11[] = "./generateKeyPair/OpenHarmony.p12";
196     char arg12[] = "-keystorePwd";
197     char arg13[] = "123456";
198     char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6,
199                      arg7, arg8, arg9, arg10, arg11, arg12, arg13 };
200 
201     int argc = 14;
202     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
203 
204     EXPECT_EQ(ret, false);
205 }
206 
207 /*
208  * @tc.name: processcmd_test_008
209  * @tc.desc: Checks whether the argument is in the trusted list.
210  * @tc.type: FUNC
211  * @tc.require:
212  */
HWTEST_F(ProcessCmdTest, processcmd_test_008, testing::ext::TestSize.Level1)213 HWTEST_F(ProcessCmdTest, processcmd_test_008, testing::ext::TestSize.Level1)
214 {
215     char arg0[] = "";
216     char arg1[] = "generate-keypair";
217     char arg2[] = "-keyAlias";
218     char arg3[] = "oh-app1-key-v1";
219     char arg4[] = "-keyPwd";
220     char arg5[] = "123456";
221     char arg6[] = "-keyAlg";
222     char arg7[] = "ECC";
223     char arg8[] = "-keySize";
224     char arg9[] = "NIST-P-257";
225     char arg10[] = "-keystoreFile";
226     char arg11[] = "./generateKeyPair/OpenHarmony.p12";
227     char arg12[] = "-keystorePwd";
228     char arg13[] = "123456";
229     char arg14[] = "-extKeyUsageCritical";
230     char arg15[] = "false";
231     char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7,
232                      arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15 };
233 
234     int argc = 16;
235     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
236 
237     EXPECT_EQ(ret, false);
238 }
239 
240 /*
241 * @tc.name: processcmd_test_009
242 * @tc.desc: Checks whether the last value of the command argument is null.
243 * @tc.type: FUNC
244 * @tc.require:
245 */
HWTEST_F(ProcessCmdTest, processcmd_test_009, testing::ext::TestSize.Level1)246 HWTEST_F(ProcessCmdTest, processcmd_test_009, testing::ext::TestSize.Level1)
247 {
248     char arg0[] = "";
249     char arg1[] = "generate-cert";
250     char arg2[] = "-keyAlias";
251     char arg3[] = "oh-profile1-key-v1";
252     char arg4[] = "-keyPwd";
253     char arg5[] = "123456";
254     char arg6[] = "-issuer";
255     char arg7[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA";
256     char arg8[] = "-issuerKeyAlias";
257     char arg9[] = "oh-profile-sign-srv-ca-key-v1";
258     char arg10[] = "-subject";
259     char arg11[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
260     char arg12[] = "-validity";
261     char arg13[] = "365";
262     char arg14[] = "-signAlg";
263     char arg15[] = "SHA384withECDSA";
264     char arg16[] = "-keystoreFile";
265     char arg17[] = "./generateKeyPair/OpenHarmony.p12";
266     char arg18[] = "-keystorePwd";
267     char arg19[] = "123456";
268     char arg20[] = "-outFile";
269     char arg21[] = "./generateKeyPair/general.cer";
270     char arg22[] = "-keyPwd";
271     char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
272                      arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22 };
273     int argc = 23;
274     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
275 
276     EXPECT_EQ(ret, false);
277 }
278 
279 /*
280 * @tc.name: processcmd_test_010
281 * @tc.desc: Check that the required parameters of the generate-cert module are met.
282 * @tc.type: FUNC
283 * @tc.require:
284 */
HWTEST_F(ProcessCmdTest, processcmd_test_010, testing::ext::TestSize.Level1)285 HWTEST_F(ProcessCmdTest, processcmd_test_010, testing::ext::TestSize.Level1)
286 {
287     char arg0[] = "";
288     char arg1[] = "generate-cert";
289     char arg2[] = "-keyAlias";
290     char arg3[] = "oh-profile1-key-v1";
291     char arg4[] = "-keyPwd";
292     char arg5[] = "123456";
293     char arg6[] = "-issuer";
294     char arg7[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA";
295     char arg8[] = "-issuerKeyAlias";
296     char arg9[] = "oh-profile-sign-srv-ca-key-v1";
297     char arg10[] = "-subject";
298     char arg11[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
299     char arg12[] = "-validity";
300     char arg13[] = "365";
301     char arg14[] = "-signAlg";
302     char arg15[] = "SHA384withECDSA";
303     char arg16[] = "-keystoreFile";
304     char arg17[] = "/mnt/d/file/0613test/OpenHarmony.p12";
305     char arg18[] = "-keystorePwd";
306     char arg19[] = "123456";
307     char arg20[] = "-outFile";
308     char arg21[] = "/mnt/d/file/0613test/general.cer";
309     char arg22[] = "-basicConstraintsPathLen";
310     char arg23[] = "0";
311     char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
312                      arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22, arg23 };
313     int argc = 24;
314 
315     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
316 
317     EXPECT_EQ(ret, false);
318 }
319 
320 /*
321 * @tc.name: processcmd_test_011
322 * @tc.desc: Check that the required parameters of the sign-app module are met.
323 * @tc.type: FUNC
324 * @tc.require:
325 */
HWTEST_F(ProcessCmdTest, processcmd_test_011, testing::ext::TestSize.Level1)326 HWTEST_F(ProcessCmdTest, processcmd_test_011, testing::ext::TestSize.Level1)
327 {
328     char arg0[] = "";
329     char arg1[] = "sign-app";
330     char arg2[] = "-profileSigned";
331     char arg3[] = "1";
332     char* argv[] = { arg0, arg1, arg2, arg3 };
333     int argc = 4;
334 
335     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
336 
337     EXPECT_EQ(ret, false);
338 }
339 
340 /*
341 * @tc.name: processcmd_test_012
342 * @tc.desc: Check if the -profileSigned parameter in sign-app is [1,0, true, false, TRUE, FALSE].
343 * @tc.type: FUNC
344 * @tc.require:
345 */
HWTEST_F(ProcessCmdTest, processcmd_test_012, testing::ext::TestSize.Level1)346 HWTEST_F(ProcessCmdTest, processcmd_test_012, testing::ext::TestSize.Level1)
347 {
348     char arg0[] = "";
349     char arg1[] = "sign-app";
350     char arg2[] = "-profileSigned";
351     char arg3[] = "abcd";
352     char* argv[] = { arg0, arg1, arg2, arg3 };
353     int argc = 4;
354 
355     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
356 
357     EXPECT_EQ(ret, false);
358 }
359 
360 /*
361 * @tc.name: processcmd_test_013
362 * @tc.desc: Check that the output file path exists.
363 * @tc.type: FUNC
364 * @tc.require:
365 */
HWTEST_F(ProcessCmdTest, processcmd_test_013, testing::ext::TestSize.Level1)366 HWTEST_F(ProcessCmdTest, processcmd_test_013, testing::ext::TestSize.Level1)
367 {
368     char arg0[] = "";
369     char arg1[] = "generate-keypair";
370     char arg2[] = "-keyAlias";
371     char arg3[] = "oh-app1-key-v1";
372     char arg4[] = "-keyPwd";
373     char arg5[] = "123456";
374     char arg6[] = "-keyAlg";
375     char arg7[] = "ECC";
376     char arg8[] = "-keySize";
377     char arg9[] = "NIST-P-256";
378     char arg10[] = "-keystoreFile";
379     char arg11[] = "./aabc123/OpenHarmony.p12";
380     char arg12[] = "-keystorePwd";
381     char arg13[] = "123456";
382     char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13 };
383     int argc = 14;
384 
385     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
386 
387     EXPECT_EQ(ret, false);
388 }
389 
390 /*
391 * @tc.name: processcmd_test_014
392 * @tc.desc: Check if the keystore file is in 'p12' or 'JKS' file format.
393 * @tc.type: FUNC
394 * @tc.require:
395 */
HWTEST_F(ProcessCmdTest, processcmd_test_014, testing::ext::TestSize.Level1)396 HWTEST_F(ProcessCmdTest, processcmd_test_014, testing::ext::TestSize.Level1)
397 {
398     char arg0[] = "";
399     char arg1[] = "generate-keypair";
400     char arg2[] = "-keyAlias";
401     char arg3[] = "oh-app1-key-v1";
402     char arg4[] = "-keyPwd";
403     char arg5[] = "123456";
404     char arg6[] = "-keyAlg";
405     char arg7[] = "ECC";
406     char arg8[] = "-keySize";
407     char arg9[] = "NIST-P-256";
408     char arg10[] = "-keystoreFile";
409     char arg11[] = "./generateKeyPair";
410     char arg12[] = "-keystorePwd";
411     char arg13[] = "123456";
412     char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13 };
413     int argc = 14;
414 
415     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
416 
417     EXPECT_EQ(ret, false);
418 }
419 
420 /*
421 * @tc.name: processcmd_test_015
422 * @tc.desc: Check if the signature algorithm is SHA3256withECDSA or SHA384withECDSA.
423 * @tc.type: FUNC
424 * @tc.require:
425 */
HWTEST_F(ProcessCmdTest, processcmd_test_015, testing::ext::TestSize.Level1)426 HWTEST_F(ProcessCmdTest, processcmd_test_015, testing::ext::TestSize.Level1)
427 {
428     char arg0[] = "";
429     char arg1[] = "sign-app";
430     char arg2[] = "-signAlg";
431     char arg3[] = "abcd";
432     char* argv[] = { arg0, arg1, arg2, arg3 };
433     int argc = 4;
434 
435     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
436 
437     EXPECT_EQ(ret, false);
438 }
439 
440 /*
441 * @tc.name: processcmd_test_016
442 * @tc.desc: Check if the signature algorithm is SHA3256withECDSA or SHA384withECDSA.
443 * @tc.type: FUNC
444 * @tc.require:
445 */
HWTEST_F(ProcessCmdTest, processcmd_test_016, testing::ext::TestSize.Level1)446 HWTEST_F(ProcessCmdTest, processcmd_test_016, testing::ext::TestSize.Level1)
447 {
448     char arg0[] = "";
449     char arg1[] = "sign-app";
450     char arg2[] = "-signAlg";
451     char arg3[] = "SHA384withECDSA";
452     char* argv[] = { arg0, arg1, arg2, arg3 };
453     int argc = 4;
454 
455     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
456 
457     EXPECT_EQ(ret, false);
458 }
459 
460 /*
461 * @tc.name: processcmd_test_017
462 * @tc.desc: Check that the -inForm value is formatted correct.
463 * @tc.type: FUNC
464 * @tc.require:
465 */
HWTEST_F(ProcessCmdTest, processcmd_test_017, testing::ext::TestSize.Level1)466 HWTEST_F(ProcessCmdTest, processcmd_test_017, testing::ext::TestSize.Level1)
467 {
468     char arg0[] = "";
469     char arg1[] = "verify-app";
470     char arg2[] = "-inForm";
471     char arg3[] = "abcd";
472     char* argv[] = { arg0, arg1, arg2, arg3 };
473     int argc = 4;
474 
475     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
476 
477     EXPECT_EQ(ret, false);
478 }
479 
480 /*
481 * @tc.name: processcmd_test_018
482 * @tc.desc: Check that the -outForm argument is correctly formatted.
483 * @tc.type: FUNC
484 * @tc.require:
485 */
HWTEST_F(ProcessCmdTest, processcmd_test_018, testing::ext::TestSize.Level1)486 HWTEST_F(ProcessCmdTest, processcmd_test_018, testing::ext::TestSize.Level1)
487 {
488     char arg0[] = "";
489     char arg1[] = "generate-app-cert";
490     char arg2[] = "-outForm";
491     char arg3[] = "abcd";
492     char* argv[] = { arg0, arg1, arg2, arg3 };
493     int argc = 4;
494 
495     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
496 
497     EXPECT_EQ(ret, false);
498 }
499 
500 /*
501 * @tc.name: processcmd_test_019
502 * @tc.desc: Check the generate-app-cert module for required parameters.
503 * @tc.type: FUNC
504 * @tc.require:
505 */
HWTEST_F(ProcessCmdTest, processcmd_test_019, testing::ext::TestSize.Level1)506 HWTEST_F(ProcessCmdTest, processcmd_test_019, testing::ext::TestSize.Level1)
507 {
508     char arg0[] = "";
509     char arg1[] = "generate-app-cert";
510     char* argv[] = { arg0, arg1 };
511     int argc = 2;
512 
513     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
514 
515     EXPECT_EQ(ret, false);
516 }
517 
518 /*
519  * @tc.name: processcmd_test_020
520  * @tc.desc: Printing help documents.
521  * @tc.type: FUNC
522  * @tc.require:
523  */
HWTEST_F(ProcessCmdTest, processcmd_test_020, testing::ext::TestSize.Level1)524 HWTEST_F(ProcessCmdTest, processcmd_test_020, testing::ext::TestSize.Level1)
525 {
526     char arg0[] = "";
527     char arg1[] = "-help";
528     char* argv[] = { arg0, arg1 };
529     int argc = 2;
530     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
531 
532     EXPECT_EQ(ret, true);
533 }
534 
535 /*
536  * @tc.name: processcmd_test_021
537  * @tc.desc: Print version number.
538  * @tc.type: FUNC
539  * @tc.require:
540  */
HWTEST_F(ProcessCmdTest, processcmd_test_021, testing::ext::TestSize.Level1)541 HWTEST_F(ProcessCmdTest, processcmd_test_021, testing::ext::TestSize.Level1)
542 {
543     char arg0[] = "";
544     char arg1[] = "-version";
545     char* argv[] = { arg0, arg1 };
546     int argc = 2;
547     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
548 
549     EXPECT_EQ(ret, true);
550 }
551 
552 /*
553  * @tc.name: processcmd_test_022
554  * @tc.desc: Print help documentation when an empty command is passed.
555  * @tc.type: FUNC
556  * @tc.require:
557  */
HWTEST_F(ProcessCmdTest, processcmd_test_022, testing::ext::TestSize.Level1)558 HWTEST_F(ProcessCmdTest, processcmd_test_022, testing::ext::TestSize.Level1)
559 {
560     bool ret = ParamsRunTool::ProcessCmd(nullptr, 5);
561     EXPECT_EQ(ret, true);
562 }
563 
564 /*
565  * @tc.name: processcmd_test_023
566  * @tc.desc: Check whether keyUsageCritical parameter for [ 1, 0, true, false, true, false ].
567  * @tc.type: FUNC
568  * @tc.require:
569  */
HWTEST_F(ProcessCmdTest, processcmd_test_023, testing::ext::TestSize.Level1)570 HWTEST_F(ProcessCmdTest, processcmd_test_023, testing::ext::TestSize.Level1)
571 {
572     char arg0[] = "";
573     char arg1[] = "generate-cert";
574     char arg2[] = "-keyAlias";
575     char arg3[] = "oh-profile1-key-v1";
576     char arg4[] = "-keyPwd";
577     char arg5[] = "123456";
578     char arg6[] = "-issuer";
579     char arg7[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA";
580     char arg8[] = "-issuerKeyAlias";
581     char arg9[] = "oh-profile-sign-srv-ca-key-v1";
582     char arg10[] = "-subject";
583     char arg11[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
584     char arg12[] = "-validity";
585     char arg13[] = "365";
586     char arg14[] = "-signAlg";
587     char arg15[] = "SHA384withECDSA";
588     char arg16[] = "-keystoreFile";
589     char arg17[] = "./generateKeyPair/OpenHarmony.p12";
590     char arg18[] = "-keystorePwd";
591     char arg19[] = "123456";
592     char arg20[] = "-outFile";
593     char arg21[] = "./generateKeyPair/general.cer";
594     char arg22[] = "-keyUsageCritical";
595     char arg23[] = "TRUE";
596     char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
597                      arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22, arg23 };
598     int argc = 24;
599 
600     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
601 
602     EXPECT_EQ(ret, false);
603 }
604 
605 /*
606  * @tc.name: processcmd_test_024
607  * @tc.desc: Check whether keyUsageCritical parameter for [ 1, 0, true, false, true, false ].
608  * @tc.type: FUNC
609  * @tc.require:
610  */
HWTEST_F(ProcessCmdTest, processcmd_test_024, testing::ext::TestSize.Level1)611 HWTEST_F(ProcessCmdTest, processcmd_test_024, testing::ext::TestSize.Level1)
612 {
613     char arg0[] = "";
614     char arg1[] = "generate-cert";
615     char arg2[] = "-keyAlias";
616     char arg3[] = "oh-profile1-key-v1";
617     char arg4[] = "-keyPwd";
618     char arg5[] = "123456";
619     char arg6[] = "-issuer";
620     char arg7[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA";
621     char arg8[] = "-issuerKeyAlias";
622     char arg9[] = "oh-profile-sign-srv-ca-key-v1";
623     char arg10[] = "-subject";
624     char arg11[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
625     char arg12[] = "-validity";
626     char arg13[] = "365";
627     char arg14[] = "-signAlg";
628     char arg15[] = "SHA384withECDSA";
629     char arg16[] = "-keystoreFile";
630     char arg17[] = "./generateKeyPair/OpenHarmony.p12";
631     char arg18[] = "-keystorePwd";
632     char arg19[] = "123456";
633     char arg20[] = "-outFile";
634     char arg21[] = "./generateKeyPair/general.cer";
635     char arg22[] = "-keyUsageCritical";
636     char arg23[] = "true";
637     char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
638                      arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22, arg23 };
639     int argc = 24;
640 
641     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
642 
643     EXPECT_EQ(ret, false);
644 }
645 
646 /*
647  * @tc.name: processcmd_test_025
648  * @tc.desc: Check whether extKeyUsageCritical parameter for [ 1, 0, true, false, true, false ].
649  * @tc.type: FUNC
650  * @tc.require:
651  */
HWTEST_F(ProcessCmdTest, processcmd_test_025, testing::ext::TestSize.Level1)652 HWTEST_F(ProcessCmdTest, processcmd_test_025, testing::ext::TestSize.Level1)
653 {
654     char arg0[] = "";
655     char arg1[] = "generate-cert";
656     char arg2[] = "-keyAlias";
657     char arg3[] = "oh-profile1-key-v1";
658     char arg4[] = "-keyPwd";
659     char arg5[] = "123456";
660     char arg6[] = "-issuer";
661     char arg7[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA";
662     char arg8[] = "-issuerKeyAlias";
663     char arg9[] = "oh-profile-sign-srv-ca-key-v1";
664     char arg10[] = "-subject";
665     char arg11[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
666     char arg12[] = "-validity";
667     char arg13[] = "365";
668     char arg14[] = "-signAlg";
669     char arg15[] = "SHA384withECDSA";
670     char arg16[] = "-keystoreFile";
671     char arg17[] = "./generateKeyPair/OpenHarmony.p12";
672     char arg18[] = "-keystorePwd";
673     char arg19[] = "123456";
674     char arg20[] = "-outFile";
675     char arg21[] = "./generateKeyPair/general.cer";
676     char arg22[] = "-extKeyUsageCritical";
677     char arg23[] = "1";
678     char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
679                      arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22, arg23 };
680     int argc = 24;
681 
682     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
683 
684     EXPECT_EQ(ret, false);
685 }
686 
687 /*
688  * @tc.name: processcmd_test_026
689  * @tc.desc: Check whether extKeyUsageCritical parameter for [ 1, 0, true, false, true, false ].
690  * @tc.type: FUNC
691  * @tc.require:
692  */
HWTEST_F(ProcessCmdTest, processcmd_test_026, testing::ext::TestSize.Level1)693 HWTEST_F(ProcessCmdTest, processcmd_test_026, testing::ext::TestSize.Level1)
694 {
695     char arg0[] = "";
696     char arg1[] = "generate-cert";
697     char arg2[] = "-keyAlias";
698     char arg3[] = "oh-profile1-key-v1";
699     char arg4[] = "-keyPwd";
700     char arg5[] = "123456";
701     char arg6[] = "-issuer";
702     char arg7[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA";
703     char arg8[] = "-issuerKeyAlias";
704     char arg9[] = "oh-profile-sign-srv-ca-key-v1";
705     char arg10[] = "-subject";
706     char arg11[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
707     char arg12[] = "-validity";
708     char arg13[] = "365";
709     char arg14[] = "-signAlg";
710     char arg15[] = "SHA384withECDSA";
711     char arg16[] = "-keystoreFile";
712     char arg17[] = "./generateKeyPair/OpenHarmony.p12";
713     char arg18[] = "-keystorePwd";
714     char arg19[] = "123456";
715     char arg20[] = "-outFile";
716     char arg21[] = "./generateKeyPair/general.cer";
717     char arg22[] = "-extKeyUsageCritical";
718     char arg23[] = "true";
719     char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
720                      arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22, arg23 };
721     int argc = 24;
722 
723     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
724 
725     EXPECT_EQ(ret, false);
726 }
727 
728 /*
729  * @tc.name: processcmd_test_027
730  * @tc.desc: Check whether extKeyUsageCritical parameter for [ 1, 0, true, false, true, false ].
731  * @tc.type: FUNC
732  * @tc.require:
733  */
HWTEST_F(ProcessCmdTest, processcmd_test_027, testing::ext::TestSize.Level1)734 HWTEST_F(ProcessCmdTest, processcmd_test_027, testing::ext::TestSize.Level1)
735 {
736     char arg0[] = "";
737     char arg1[] = "generate-cert";
738     char arg2[] = "-keyAlias";
739     char arg3[] = "oh-profile1-key-v1";
740     char arg4[] = "-keyPwd";
741     char arg5[] = "123456";
742     char arg6[] = "-issuer";
743     char arg7[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA";
744     char arg8[] = "-issuerKeyAlias";
745     char arg9[] = "oh-profile-sign-srv-ca-key-v1";
746     char arg10[] = "-subject";
747     char arg11[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
748     char arg12[] = "-validity";
749     char arg13[] = "365";
750     char arg14[] = "-signAlg";
751     char arg15[] = "SHA384withECDSA";
752     char arg16[] = "-keystoreFile";
753     char arg17[] = "./generateKeyPair/OpenHarmony.p12";
754     char arg18[] = "-keystorePwd";
755     char arg19[] = "123456";
756     char arg20[] = "-outFile";
757     char arg21[] = "./generateKeyPair/general.cer";
758     char arg22[] = "-extKeyUsageCritical";
759     char arg23[] = "TRUE";
760     char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
761                      arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22, arg23 };
762     int argc = 24;
763 
764     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
765 
766     EXPECT_EQ(ret, false);
767 }
768 
769 /*
770  * @tc.name: processcmd_test_028
771  * @tc.desc: Check whether basicConstraints parameter for [ 1, 0, true, false, true, false ].
772  * @tc.type: FUNC
773  * @tc.require:
774  */
HWTEST_F(ProcessCmdTest, processcmd_test_028, testing::ext::TestSize.Level1)775 HWTEST_F(ProcessCmdTest, processcmd_test_028, testing::ext::TestSize.Level1)
776 {
777     char arg0[] = "";
778     char arg1[] = "generate-cert";
779     char arg2[] = "-keyAlias";
780     char arg3[] = "oh-profile1-key-v1";
781     char arg4[] = "-keyPwd";
782     char arg5[] = "123456";
783     char arg6[] = "-issuer";
784     char arg7[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA";
785     char arg8[] = "-issuerKeyAlias";
786     char arg9[] = "oh-profile-sign-srv-ca-key-v1";
787     char arg10[] = "-subject";
788     char arg11[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
789     char arg12[] = "-validity";
790     char arg13[] = "365";
791     char arg14[] = "-signAlg";
792     char arg15[] = "SHA384withECDSA";
793     char arg16[] = "-keystoreFile";
794     char arg17[] = "./generateKeyPair/OpenHarmony.p12";
795     char arg18[] = "-keystorePwd";
796     char arg19[] = "123456";
797     char arg20[] = "-outFile";
798     char arg21[] = "./generateKeyPair/general.cer";
799     char arg22[] = "-basicConstraints";
800     char arg23[] = "TRUE";
801     char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
802                      arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22, arg23 };
803     int argc = 24;
804 
805     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
806 
807     EXPECT_EQ(ret, false);
808 }
809 
810 /*
811  * @tc.name: processcmd_test_029
812  * @tc.desc: Check whether basicConstraints parameter for [ 1, 0, true, false, true, false ].
813  * @tc.type: FUNC
814  * @tc.require:
815  */
HWTEST_F(ProcessCmdTest, processcmd_test_029, testing::ext::TestSize.Level1)816 HWTEST_F(ProcessCmdTest, processcmd_test_029, testing::ext::TestSize.Level1)
817 {
818     char arg0[] = "";
819     char arg1[] = "generate-cert";
820     char arg2[] = "-keyAlias";
821     char arg3[] = "oh-profile1-key-v1";
822     char arg4[] = "-keyPwd";
823     char arg5[] = "123456";
824     char arg6[] = "-issuer";
825     char arg7[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA";
826     char arg8[] = "-issuerKeyAlias";
827     char arg9[] = "oh-profile-sign-srv-ca-key-v1";
828     char arg10[] = "-subject";
829     char arg11[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
830     char arg12[] = "-validity";
831     char arg13[] = "365";
832     char arg14[] = "-signAlg";
833     char arg15[] = "SHA384withECDSA";
834     char arg16[] = "-keystoreFile";
835     char arg17[] = "./generateKeyPair/OpenHarmony.p12";
836     char arg18[] = "-keystorePwd";
837     char arg19[] = "123456";
838     char arg20[] = "-outFile";
839     char arg21[] = "./generateKeyPair/general.cer";
840     char arg22[] = "-basicConstraints";
841     char arg23[] = "1";
842     char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
843                      arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22, arg23 };
844     int argc = 24;
845 
846     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
847 
848     EXPECT_EQ(ret, false);
849 }
850 
851 /*
852  * @tc.name: processcmd_test_030
853  * @tc.desc: Check whether basicConstraints parameter for [ 1, 0, true, false, true, false ].
854  * @tc.type: FUNC
855  * @tc.require:
856  */
HWTEST_F(ProcessCmdTest, processcmd_test_030, testing::ext::TestSize.Level1)857 HWTEST_F(ProcessCmdTest, processcmd_test_030, testing::ext::TestSize.Level1)
858 {
859     char arg0[] = "";
860     char arg1[] = "generate-cert";
861     char arg2[] = "-keyAlias";
862     char arg3[] = "oh-profile1-key-v1";
863     char arg4[] = "-keyPwd";
864     char arg5[] = "123456";
865     char arg6[] = "-issuer";
866     char arg7[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA";
867     char arg8[] = "-issuerKeyAlias";
868     char arg9[] = "oh-profile-sign-srv-ca-key-v1";
869     char arg10[] = "-subject";
870     char arg11[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
871     char arg12[] = "-validity";
872     char arg13[] = "365";
873     char arg14[] = "-signAlg";
874     char arg15[] = "SHA384withECDSA";
875     char arg16[] = "-keystoreFile";
876     char arg17[] = "./generateKeyPair/OpenHarmony.p12";
877     char arg18[] = "-keystorePwd";
878     char arg19[] = "123456";
879     char arg20[] = "-outFile";
880     char arg21[] = "./generateKeyPair/general.cer";
881     char arg22[] = "-basicConstraints";
882     char arg23[] = "true";
883     char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
884                      arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22, arg23 };
885     int argc = 24;
886 
887     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
888 
889     EXPECT_EQ(ret, false);
890 }
891 
892 /*
893  * @tc.name: processcmd_test_031
894  * @tc.desc: Check whether basicConstraintsCritical parameter for [ 1, 0, true, false, true, false ].
895  * @tc.type: FUNC
896  * @tc.require:
897  */
HWTEST_F(ProcessCmdTest, processcmd_test_031, testing::ext::TestSize.Level1)898 HWTEST_F(ProcessCmdTest, processcmd_test_031, testing::ext::TestSize.Level1)
899 {
900     char arg0[] = "";
901     char arg1[] = "generate-cert";
902     char arg2[] = "-keyAlias";
903     char arg3[] = "oh-profile1-key-v1";
904     char arg4[] = "-keyPwd";
905     char arg5[] = "123456";
906     char arg6[] = "-issuer";
907     char arg7[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA";
908     char arg8[] = "-issuerKeyAlias";
909     char arg9[] = "oh-profile-sign-srv-ca-key-v1";
910     char arg10[] = "-subject";
911     char arg11[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
912     char arg12[] = "-validity";
913     char arg13[] = "365";
914     char arg14[] = "-signAlg";
915     char arg15[] = "SHA384withECDSA";
916     char arg16[] = "-keystoreFile";
917     char arg17[] = "./generateKeyPair/OpenHarmony.p12";
918     char arg18[] = "-keystorePwd";
919     char arg19[] = "123456";
920     char arg20[] = "-outFile";
921     char arg21[] = "./generateKeyPair/general.cer";
922     char arg22[] = "-basicConstraintsCritical";
923     char arg23[] = "true";
924     char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
925                      arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22, arg23 };
926     int argc = 24;
927 
928     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
929 
930     EXPECT_EQ(ret, false);
931 }
932 
933 /*
934  * @tc.name: processcmd_test_032
935  * @tc.desc: Check whether basicConstraintsCritical parameter for [ 1, 0, true, false, true, false ].
936  * @tc.type: FUNC
937  * @tc.require:
938  */
HWTEST_F(ProcessCmdTest, processcmd_test_032, testing::ext::TestSize.Level1)939 HWTEST_F(ProcessCmdTest, processcmd_test_032, testing::ext::TestSize.Level1)
940 {
941     char arg0[] = "";
942     char arg1[] = "generate-cert";
943     char arg2[] = "-keyAlias";
944     char arg3[] = "oh-profile1-key-v1";
945     char arg4[] = "-keyPwd";
946     char arg5[] = "123456";
947     char arg6[] = "-issuer";
948     char arg7[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA";
949     char arg8[] = "-issuerKeyAlias";
950     char arg9[] = "oh-profile-sign-srv-ca-key-v1";
951     char arg10[] = "-subject";
952     char arg11[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
953     char arg12[] = "-validity";
954     char arg13[] = "365";
955     char arg14[] = "-signAlg";
956     char arg15[] = "SHA384withECDSA";
957     char arg16[] = "-keystoreFile";
958     char arg17[] = "./generateKeyPair/OpenHarmony.p12";
959     char arg18[] = "-keystorePwd";
960     char arg19[] = "123456";
961     char arg20[] = "-outFile";
962     char arg21[] = "./generateKeyPair/general.cer";
963     char arg22[] = "-basicConstraintsCritical";
964     char arg23[] = "TRUE";
965     char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
966                      arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22, arg23 };
967     int argc = 24;
968 
969     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
970 
971     EXPECT_EQ(ret, false);
972 }
973 
974 /*
975  * @tc.name: processcmd_test_033
976  * @tc.desc: Check whether basicConstraintsCritical parameter for [ 1, 0, true, false, true, false ].
977  * @tc.type: FUNC
978  * @tc.require:
979  */
HWTEST_F(ProcessCmdTest, processcmd_test_033, testing::ext::TestSize.Level1)980 HWTEST_F(ProcessCmdTest, processcmd_test_033, testing::ext::TestSize.Level1)
981 {
982     char arg0[] = "";
983     char arg1[] = "generate-cert";
984     char arg2[] = "-keyAlias";
985     char arg3[] = "oh-profile1-key-v1";
986     char arg4[] = "-keyPwd";
987     char arg5[] = "123456";
988     char arg6[] = "-issuer";
989     char arg7[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA";
990     char arg8[] = "-issuerKeyAlias";
991     char arg9[] = "oh-profile-sign-srv-ca-key-v1";
992     char arg10[] = "-subject";
993     char arg11[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
994     char arg12[] = "-validity";
995     char arg13[] = "365";
996     char arg14[] = "-signAlg";
997     char arg15[] = "SHA384withECDSA";
998     char arg16[] = "-keystoreFile";
999     char arg17[] = "./generateKeyPair/OpenHarmony.p12";
1000     char arg18[] = "-keystorePwd";
1001     char arg19[] = "123456";
1002     char arg20[] = "-outFile";
1003     char arg21[] = "./generateKeyPair/general.cer";
1004     char arg22[] = "-basicConstraintsCritical";
1005     char arg23[] = "1";
1006     char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
1007                      arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22, arg23 };
1008     int argc = 24;
1009 
1010     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
1011 
1012     EXPECT_EQ(ret, false);
1013 }
1014 
1015 /*
1016  * @tc.name: processcmd_test_034
1017  * @tc.desc: Check whether basicConstraintsCa parameter for [ 1, 0, true, false, true, false ].
1018  * @tc.type: FUNC
1019  * @tc.require:
1020  */
HWTEST_F(ProcessCmdTest, processcmd_test_034, testing::ext::TestSize.Level1)1021 HWTEST_F(ProcessCmdTest, processcmd_test_034, testing::ext::TestSize.Level1)
1022 {
1023     char arg0[] = "";
1024     char arg1[] = "generate-cert";
1025     char arg2[] = "-keyAlias";
1026     char arg3[] = "oh-profile1-key-v1";
1027     char arg4[] = "-keyPwd";
1028     char arg5[] = "123456";
1029     char arg6[] = "-issuer";
1030     char arg7[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA";
1031     char arg8[] = "-issuerKeyAlias";
1032     char arg9[] = "oh-profile-sign-srv-ca-key-v1";
1033     char arg10[] = "-subject";
1034     char arg11[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
1035     char arg12[] = "-validity";
1036     char arg13[] = "365";
1037     char arg14[] = "-signAlg";
1038     char arg15[] = "SHA384withECDSA";
1039     char arg16[] = "-keystoreFile";
1040     char arg17[] = "./generateKeyPair/OpenHarmony.p12";
1041     char arg18[] = "-keystorePwd";
1042     char arg19[] = "123456";
1043     char arg20[] = "-outFile";
1044     char arg21[] = "./generateKeyPair/general.cer";
1045     char arg22[] = "-basicConstraintsCa";
1046     char arg23[] = "1";
1047     char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
1048                      arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22, arg23 };
1049     int argc = 24;
1050 
1051     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
1052 
1053     EXPECT_EQ(ret, false);
1054 }
1055 
1056 /*
1057  * @tc.name: processcmd_test_035
1058  * @tc.desc: Check that the inFile argument is correct.
1059  * @tc.type: FUNC
1060  * @tc.require:
1061  */
HWTEST_F(ProcessCmdTest, processcmd_test_035, testing::ext::TestSize.Level1)1062 HWTEST_F(ProcessCmdTest, processcmd_test_035, testing::ext::TestSize.Level1)
1063 {
1064     std::shared_ptr<Options> params = std::make_shared<Options>();
1065     std::string inFile = "./generateKeyPair";
1066     (*params)["inFile"] = inFile;
1067     bool ret = CmdUtil::UpdateParamForCheckInFile(params.get(), {Options::IN_FILE});
1068 
1069     EXPECT_EQ(ret, false);
1070 }
1071 
1072 /*
1073  * @tc.name: processcmd_test_036
1074  * @tc.desc: Check that the inFile argument is correct.
1075  * @tc.type: FUNC
1076  * @tc.require:
1077  */
HWTEST_F(ProcessCmdTest, processcmd_test_036, testing::ext::TestSize.Level1)1078 HWTEST_F(ProcessCmdTest, processcmd_test_036, testing::ext::TestSize.Level1)
1079 {
1080     std::shared_ptr<Options> params = std::make_shared<Options>();
1081     std::string inFile = "generateKeyPair";
1082     (*params)["inFile"] = inFile;
1083     bool ret = CmdUtil::UpdateParamForCheckOutFile(params.get(), {Options::IN_FILE});
1084 
1085     EXPECT_EQ(ret, true);
1086 }
1087 
1088 /*
1089  * @tc.name: processcmd_test_037
1090  * @tc.desc: Check that the profileSigned argument is correct.
1091  * @tc.type: FUNC
1092  * @tc.require:
1093  */
HWTEST_F(ProcessCmdTest, processcmd_test_037, testing::ext::TestSize.Level1)1094 HWTEST_F(ProcessCmdTest, processcmd_test_037, testing::ext::TestSize.Level1)
1095 {
1096     char arg0[] = "";
1097     char arg1[] = "sign-app";
1098     char arg2[] = "-profileSigned";
1099     char arg3[] = "0";
1100     char* argv[] = {arg0, arg1, arg2, arg3};
1101     int argc = 4;
1102 
1103     bool ret = ParamsRunTool::ProcessCmd(argv, argc);
1104 
1105     EXPECT_EQ(ret, false);
1106 }
1107 } // namespace SignatureTools
1108 } // namespace OHOS