1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #define private public
18 #define protected public
19 #include "parser/lexer.h"
20
21 using namespace testing;
22 using namespace testing::ext;
23 namespace OHOS {
24 namespace Idl {
25
26 class LexerUnitTest : public testing::Test {
27 public:
LexerUnitTest()28 LexerUnitTest() {}
29
~LexerUnitTest()30 virtual ~LexerUnitTest() {}
31
32 static void SetUpTestCase();
33
34 static void TearDownTestCase();
35
36 void SetUp();
37
38 void TearDown();
39 };
40
SetUpTestCase()41 void LexerUnitTest::SetUpTestCase() {}
42
TearDownTestCase()43 void LexerUnitTest::TearDownTestCase() {}
44
SetUp()45 void LexerUnitTest::SetUp() {}
46
TearDown()47 void LexerUnitTest::TearDown() {}
48
49 /*
50 * @tc.name: OpenSourceFileTest_0100
51 * @tc.desc: test Lexer's OpenSourceFile function return false.
52 * @tc.type: FUNC
53 * @tc.require:
54 */
55 HWTEST_F(LexerUnitTest, OpenSourceFileTest_0100, Function | MediumTest | Level1)
56 {
57 GTEST_LOG_(INFO)
58 << "LexerUnitTest, OpenSourceFileTest_0100, TestSize.Level1";
59 Lexer imageLexer;
60 String filePath = "";
61 bool result = imageLexer.OpenSourceFile(filePath);
62 EXPECT_EQ(result, false);
63 }
64
65 /*
66 * @tc.name: TokenToCharTest_0100
67 * @tc.desc: test the token in Lexer's TokenToChar function is ANGLE_BRACKETS_LEFT.
68 * @tc.type: FUNC
69 * @tc.require:
70 */
71 HWTEST_F(LexerUnitTest, TokenToCharTest_0100, Function | MediumTest | Level1)
72 {
73 GTEST_LOG_(INFO)
74 << "LexerUnitTest, TokenToCharTest_0100, TestSize.Level1";
75 Lexer imageLexer;
76 Token token = Token::ANGLE_BRACKETS_LEFT;
77 int result = imageLexer.TokenToChar(token);
78 EXPECT_EQ(result, 60);
79 }
80
81 /*
82 * @tc.name: TokenToCharTest_0200
83 * @tc.desc: test the token in Lexer's TokenToChar function is ANGLE_BRACKETS_RIGHT.
84 * @tc.type: FUNC
85 * @tc.require:
86 */
87 HWTEST_F(LexerUnitTest, TokenToCharTest_0200, Function | MediumTest | Level1)
88 {
89 GTEST_LOG_(INFO)
90 << "LexerUnitTest, TokenToCharTest_0200, TestSize.Level1";
91 Lexer imageLexer;
92 Token token = Token::ANGLE_BRACKETS_RIGHT;
93 int result = imageLexer.TokenToChar(token);
94 EXPECT_EQ(result, 62);
95 }
96
97 /*
98 * @tc.name: TokenToCharTest_0300
99 * @tc.desc: test the token in Lexer's TokenToChar function is BRACES_LEFT.
100 * @tc.type: FUNC
101 * @tc.require:
102 */
103 HWTEST_F(LexerUnitTest, TokenToCharTest_0300, Function | MediumTest | Level1)
104 {
105 GTEST_LOG_(INFO)
106 << "LexerUnitTest, TokenToCharTest_0300, TestSize.Level1";
107 Lexer imageLexer;
108 Token token = Token::BRACES_LEFT;
109 int result = imageLexer.TokenToChar(token);
110 EXPECT_EQ(result, 123);
111 }
112
113 /*
114 * @tc.name: TokenToCharTest_0400
115 * @tc.desc: test the token in Lexer's TokenToChar function is BRACES_RIGHT.
116 * @tc.type: FUNC
117 * @tc.require:
118 */
119 HWTEST_F(LexerUnitTest, TokenToCharTest_0400, Function | MediumTest | Level1)
120 {
121 GTEST_LOG_(INFO)
122 << "LexerUnitTest, TokenToCharTest_0400, TestSize.Level1";
123 Lexer imageLexer;
124 Token token = Token::BRACES_RIGHT;
125 int result = imageLexer.TokenToChar(token);
126 EXPECT_EQ(result, 125);
127 }
128
129 /*
130 * @tc.name: TokenToCharTest_0500
131 * @tc.desc: test the token in Lexer's TokenToChar function is BRACKETS_LEFT.
132 * @tc.type: FUNC
133 * @tc.require:
134 */
135 HWTEST_F(LexerUnitTest, TokenToCharTest_0500, Function | MediumTest | Level1)
136 {
137 GTEST_LOG_(INFO)
138 << "LexerUnitTest, TokenToCharTest_0500, TestSize.Level1";
139 Lexer imageLexer;
140 Token token = Token::BRACKETS_LEFT;
141 int result = imageLexer.TokenToChar(token);
142 EXPECT_EQ(result, 91);
143 }
144
145 /*
146 * @tc.name: TokenToCharTest_0600
147 * @tc.desc: test the token in Lexer's TokenToChar function is BRACKETS_RIGHT.
148 * @tc.type: FUNC
149 * @tc.require:
150 */
151 HWTEST_F(LexerUnitTest, TokenToCharTest_0600, Function | MediumTest | Level1)
152 {
153 GTEST_LOG_(INFO)
154 << "LexerUnitTest, TokenToCharTest_0600, TestSize.Level1";
155 Lexer imageLexer;
156 Token token = Token::BRACKETS_RIGHT;
157 int result = imageLexer.TokenToChar(token);
158 EXPECT_EQ(result, 93);
159 }
160
161 /*
162 * @tc.name: TokenToCharTest_0700
163 * @tc.desc: test the token in Lexer's TokenToChar function is COMMA.
164 * @tc.type: FUNC
165 * @tc.require:
166 */
167 HWTEST_F(LexerUnitTest, TokenToCharTest_0700, Function | MediumTest | Level1)
168 {
169 GTEST_LOG_(INFO)
170 << "LexerUnitTest, TokenToCharTest_0700, TestSize.Level1";
171 Lexer imageLexer;
172 Token token = Token::COMMA;
173 int result = imageLexer.TokenToChar(token);
174 EXPECT_EQ(result, 44);
175 }
176
177 /*
178 * @tc.name: TokenToCharTest_0800
179 * @tc.desc: test the token in Lexer's TokenToChar function is DOT.
180 * @tc.type: FUNC
181 * @tc.require:
182 */
183 HWTEST_F(LexerUnitTest, TokenToCharTest_0800, Function | MediumTest | Level1)
184 {
185 GTEST_LOG_(INFO)
186 << "LexerUnitTest, TokenToCharTest_0800, TestSize.Level1";
187 Lexer imageLexer;
188 Token token = Token::DOT;
189 int result = imageLexer.TokenToChar(token);
190 EXPECT_EQ(result, 46);
191 }
192
193 /*
194 * @tc.name: TokenToCharTest_0900
195 * @tc.desc: test the token in Lexer's TokenToChar function is PARENTHESES_LEFT.
196 * @tc.type: FUNC
197 * @tc.require:
198 */
199 HWTEST_F(LexerUnitTest, TokenToCharTest_0900, Function | MediumTest | Level1)
200 {
201 GTEST_LOG_(INFO)
202 << "LexerUnitTest, TokenToCharTest_0900, TestSize.Level1";
203 Lexer imageLexer;
204 Token token = Token::PARENTHESES_LEFT;
205 int result = imageLexer.TokenToChar(token);
206 EXPECT_EQ(result, 40);
207 }
208
209 /*
210 * @tc.name: TokenToCharTest_1000
211 * @tc.desc: test the token in Lexer's TokenToChar function is PARENTHESES_RIGHT.
212 * @tc.type: FUNC
213 * @tc.require:
214 */
215 HWTEST_F(LexerUnitTest, TokenToCharTest_1000, Function | MediumTest | Level1)
216 {
217 GTEST_LOG_(INFO)
218 << "LexerUnitTest, TokenToCharTest_1000, TestSize.Level1";
219 Lexer imageLexer;
220 Token token = Token::PARENTHESES_RIGHT;
221 int result = imageLexer.TokenToChar(token);
222 EXPECT_EQ(result, 41);
223 }
224
225 /*
226 * @tc.name: TokenToCharTest_1100
227 * @tc.desc: test the token in Lexer's TokenToChar function is other.
228 * @tc.type: FUNC
229 * @tc.require:
230 */
231 HWTEST_F(LexerUnitTest, TokenToCharTest_1100, Function | MediumTest | Level1)
232 {
233 GTEST_LOG_(INFO)
234 << "LexerUnitTest, TokenToCharTest_1100, TestSize.Level1";
235 Lexer imageLexer;
236 Token token = Token::IDENTIFIER;
237 int result = imageLexer.TokenToChar(token);
238 EXPECT_EQ(result, -1);
239 }
240
241 /*
242 * @tc.name: strToIntTest_0100
243 * @tc.desc: test str to int
244 * @tc.type: FUNC
245 * @tc.require:
246 */
247 HWTEST_F(LexerUnitTest, strToIntTest_0100, Function | MediumTest | Level1)
248 {
249 GTEST_LOG_(INFO) << "LexerUnitTest, strToIntTest_0100, TestSize.Level1";
250 Lexer imageLexer;
251 int number;
252 {
253 const char *str = "100";
254 bool result = imageLexer.strToInt(str, 3, number);
255 EXPECT_EQ(result, true);
256 EXPECT_EQ(number, 100);
257 }
258
259 {
260 const char *str = "0000100";
261 bool result = imageLexer.strToInt(str, 7, number);
262 EXPECT_EQ(result, true);
263 EXPECT_EQ(number, 100);
264 }
265
266 {
267 const char *str = "0";
268 bool result = imageLexer.strToInt(str, 1, number);
269 EXPECT_EQ(result, true);
270 EXPECT_EQ(number, 0);
271 }
272
273 {
274 const char *str = "-1";
275 bool result = imageLexer.strToInt(str, 2, number);
276 EXPECT_EQ(result, false);
277 }
278
279 // exceed the upper limit of int
280 {
281 const char *str = "2147483647";
282 bool result = imageLexer.strToInt(str, 10, number);
283 EXPECT_EQ(result, true);
284 EXPECT_EQ(number, 2147483647);
285 }
286
287 // exceed the upper limit of int
288 {
289 const char *str = "2147483648";
290 bool result = imageLexer.strToInt(str, 10, number);
291 EXPECT_EQ(result, false);
292 }
293
294 {
295 const char *str = "abdc";
296 bool result = imageLexer.strToInt(str, 4, number);
297 EXPECT_EQ(result, false);
298 }
299
300 {
301 const char *str = "0000";
302 bool result = imageLexer.strToInt(str, 4, number);
303 EXPECT_EQ(result, true);
304 EXPECT_EQ(number, 0);
305 }
306 }
307 } // namespace idl
308 } // namespace OHOS