1/*
2 * Copyright (c) 2021 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 <gtest/gtest.h>
16
17#include "begetctl.h"
18#include "securec.h"
19#include "shell.h"
20#include "shell_utils.h"
21#include "shell_bas.h"
22#include "init_param.h"
23#include "param_init.h"
24
25using namespace std;
26using namespace testing::ext;
27
28namespace init_ut {
29class ParamShellUnitTest : public testing::Test {
30public:
31    ParamShellUnitTest() {};
32    virtual ~ParamShellUnitTest() {};
33    static void SetUpTestCase(void) {};
34    static void TearDownTestCase(void) {};
35    void SetUp(void) {};
36    void TearDown(void) {};
37    void TestBody(void) {};
38    void TestInitParamShell()
39    {
40        SystemSetParameter("aaa", "aaa");
41        BShellHandle bshd = GetShellHandle();
42        if (bshd == nullptr) {
43            return;
44        }
45        const char *args[] = {"paramshell", "\n"};
46        const ParamInfo *param = BShellEnvGetReservedParam(bshd, PARAM_REVERESD_NAME_CURR_PARAMETER);
47        int ret = BShellEnvSetParam(bshd, PARAM_REVERESD_NAME_CURR_PARAMETER, "..a", PARAM_STRING, (void *)"..a");
48        EXPECT_EQ(ret, 0);
49        SetParamShellPrompt(bshd, args[1]);
50        SetParamShellPrompt(bshd, "..");
51
52        ret = BShellEnvSetParam(bshd, param->name, param->desc, param->type, (void *)"");
53        SetParamShellPrompt(bshd, "..");
54
55        SetParamShellPrompt(bshd, ".a");
56        SetParamShellPrompt(bshd, ".");
57        SetParamShellPrompt(bshd, args[1]);
58        BShellParamCmdRegister(bshd, 1);
59        BShellEnvStart(bshd);
60        ret = BShellEnvOutputPrompt(bshd, "testprompt");
61        ret = BShellEnvOutputPrompt(bshd, "testprompt1111111111111111111111111111111111111111111111111111111111");
62        BShellEnvOutputByte(bshd, 'o');
63        EXPECT_EQ(ret, 0);
64    }
65    void TestParamShellCmd()
66    {
67        BShellHandle bshd = GetShellHandle();
68        BShellKey *key = BShellEnvGetDefaultKey('\n');
69        EXPECT_NE(key, nullptr);
70        if (strcpy_s(bshd->buffer, sizeof(bshd->buffer), "cd const") != EOK) {
71            return;
72        }
73        bshd->length = strlen(bshd->buffer);
74        int ret = key->keyHandle(bshd, '\n');
75        EXPECT_EQ(ret, 0);
76        if (strcpy_s(bshd->buffer, sizeof(bshd->buffer), "cat aaa") != EOK) {
77            return;
78        }
79        bshd->length = strlen(bshd->buffer);
80        ret = key->keyHandle(bshd, '\n');
81        EXPECT_EQ(ret, 0);
82        if (strcpy_s(bshd->buffer, sizeof(bshd->buffer), "testnotcmd") != EOK) {
83            return;
84        }
85        bshd->length = strlen(bshd->buffer);
86        ret = key->keyHandle(bshd, '\n');
87        EXPECT_EQ(ret, 0);
88        // test param start with "
89        if (strcpy_s(bshd->buffer, sizeof(bshd->buffer), "\"ls") != EOK) {
90            return;
91        }
92        bshd->length = strlen(bshd->buffer);
93        ret = key->keyHandle(bshd, '\n');
94        EXPECT_EQ(ret, 0);
95        // test argc is 0
96        if (strcpy_s(bshd->buffer, sizeof(bshd->buffer), ",ls") != EOK) {
97            return;
98        }
99        bshd->length = strlen(bshd->buffer);
100        ret = key->keyHandle(bshd, '\n');
101        EXPECT_EQ(ret, 0);
102        if (strcpy_s(bshd->buffer, sizeof(bshd->buffer), "$test$") != EOK) {
103            return;
104        }
105        bshd->length = strlen(bshd->buffer);
106        ret = key->keyHandle(bshd, '\n');
107        EXPECT_EQ(ret, 0);
108        if (strcpy_s(bshd->buffer, sizeof(bshd->buffer), "exit") != EOK) {
109            return;
110        }
111        bshd->length = strlen(bshd->buffer);
112        ret = key->keyHandle(bshd, '\n');
113        EXPECT_EQ(ret, 0);
114    }
115    void TestParamShellCmd1()
116    {
117        BShellHandle bshd = GetShellHandle();
118        BShellKey *key = BShellEnvGetDefaultKey('\n');
119        EXPECT_NE(key, nullptr);
120        if (strcpy_s(bshd->buffer, sizeof(bshd->buffer), "pwd") != EOK) {
121            return;
122        }
123        bshd->length = strlen(bshd->buffer);
124        int ret = key->keyHandle(bshd, '\n');
125        EXPECT_EQ(ret, 0);
126        if (strcpy_s(bshd->buffer, sizeof(bshd->buffer), "help") != EOK) {
127            return;
128        }
129        bshd->length = strlen(bshd->buffer);
130        ret = key->keyHandle(bshd, '\n');
131        EXPECT_EQ(ret, 0);
132        if (strcpy_s(bshd->buffer, sizeof(bshd->buffer), "dump") != EOK) {
133            return;
134        }
135        bshd->length = strlen(bshd->buffer);
136        ret = key->keyHandle(bshd, '\n');
137        EXPECT_EQ(ret, 0);
138        if (strcpy_s(bshd->buffer, sizeof(bshd->buffer), "dump verbose") != EOK) {
139            return;
140        }
141        bshd->length = strlen(bshd->buffer);
142        ret = key->keyHandle(bshd, '\n');
143        EXPECT_EQ(ret, 0);
144    }
145    void TestParamShellcmdEndkey()
146    {
147        BShellHandle bshd = GetShellHandle();
148        bshd->input(nullptr, 0);
149        BShellKey *key = BShellEnvGetDefaultKey('\b');
150        EXPECT_NE(key, nullptr);
151        if (strcpy_s(bshd->buffer, sizeof(bshd->buffer), "testbbackspace") != EOK) {
152            return;
153        }
154        bshd->length = strlen(bshd->buffer);
155        bshd->cursor = strlen("testb");
156        int ret = key->keyHandle(bshd, '\b');
157        EXPECT_EQ(ret, 0);
158        if (strcpy_s(bshd->buffer, sizeof(bshd->buffer), "testbbackspace") != EOK) {
159            return;
160        }
161        bshd->length = strlen(bshd->buffer);
162        bshd->cursor = strlen(bshd->buffer);
163        ret = key->keyHandle(bshd, '\b');
164        EXPECT_EQ(ret, 0);
165
166        key = BShellEnvGetDefaultKey('\t');
167        if (strcpy_s(bshd->buffer, sizeof(bshd->buffer), "testtab") != EOK) {
168            return;
169        }
170        bshd->length = strlen(bshd->buffer);
171        ret = key->keyHandle(bshd, '\t');
172        EXPECT_NE(key, nullptr);
173        BShellEnvProcessInput(bshd, (char)3); // 3 is ctrl c
174        BShellEnvProcessInput(bshd, '\e');
175        BShellEnvProcessInput(bshd, '[');
176        bshd->length = 1;
177        bshd->cursor = 1;
178        BShellEnvProcessInput(bshd, 'C');
179        BShellEnvProcessInput(bshd, 'D');
180    }
181};
182
183HWTEST_F(ParamShellUnitTest, Init_TestInitParamShell_001, TestSize.Level1)
184{
185    ParamShellUnitTest test;
186    test.TestInitParamShell();
187    test.TestParamShellCmd();
188    test.TestParamShellCmd1();
189}
190HWTEST_F(ParamShellUnitTest, Init_TestParamShellInput_001, TestSize.Level1)
191{
192    BShellHandle bshd = GetShellHandle();
193    BShellEnvProcessInput(bshd, '\n');
194
195    BShellEnvProcessInput(bshd, 'l');
196    bshd->length = BSH_COMMAND_MAX_LENGTH;
197
198    BShellEnvProcessInput(bshd, 'l');
199    bshd->length = sizeof('l');
200    bshd->cursor = 0;
201    BShellEnvProcessInput(bshd, 's');
202    BShellEnvProcessInput(bshd, '\n');
203
204    BShellEnvProcessInput(bshd, '\n'); // test bshd buff length is 0
205
206    int ret = BShellEnvRegisterKeyHandle(bshd, 'z', (BShellkeyHandle)(void*)0x409600); // 0x409600 construct address
207    EXPECT_EQ(ret, 0);
208}
209HWTEST_F(ParamShellUnitTest, Init_TestParamShellcmd_001, TestSize.Level1)
210{
211    ParamShellUnitTest test;
212    test.TestParamShellcmdEndkey();
213    GetSystemCommitId();
214    BShellEnvLoop(nullptr);
215    BShellEnvErrString(GetShellHandle(), 1);
216    BShellEnvOutputResult(GetShellHandle(), 1);
217}
218}  // namespace init_ut
219