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 #include "parser/lexer.h"
18
19 using namespace testing;
20 using namespace testing::ext;
21 using namespace OHOS::Idl;
22
23 class LexerUnitTest : public testing::Test {
24 public:
LexerUnitTest()25 LexerUnitTest() {}
26
~LexerUnitTest()27 virtual ~LexerUnitTest() {}
28
29 static void SetUpTestCase();
30
31 static void TearDownTestCase();
32
33 void SetUp();
34
35 void TearDown();
36 };
37
SetUpTestCase()38 void LexerUnitTest::SetUpTestCase() {}
39
TearDownTestCase()40 void LexerUnitTest::TearDownTestCase() {}
41
SetUp()42 void LexerUnitTest::SetUp() {}
43
TearDown()44 void LexerUnitTest::TearDown() {}
45
46 /*
47 * @tc.name: OpenSourceFileTest_0100
48 * @tc.desc: test Lexer's OpenSourceFile function return false.
49 * @tc.type: FUNC
50 * @tc.require:
51 */
52 HWTEST_F(LexerUnitTest, OpenSourceFileTest_0100, Function | MediumTest | Level1)
53 {
54 GTEST_LOG_(INFO)
55 << "LexerUnitTest, OpenSourceFileTest_0100, TestSize.Level1";
56 Lexer imageLexer;
57 String filePath = "";
58 bool result = imageLexer.OpenSourceFile(filePath);
59 EXPECT_EQ(result, false);
60 }
61
62 /*
63 * @tc.name: TokenToCharTest_0100
64 * @tc.desc: test the token in Lexer's TokenToChar function is ANGLE_BRACKETS_LEFT.
65 * @tc.type: FUNC
66 * @tc.require:
67 */
68 HWTEST_F(LexerUnitTest, TokenToCharTest_0100, Function | MediumTest | Level1)
69 {
70 GTEST_LOG_(INFO)
71 << "LexerUnitTest, TokenToCharTest_0100, TestSize.Level1";
72 Lexer imageLexer;
73 Token token = Token::ANGLE_BRACKETS_LEFT;
74 int result = imageLexer.TokenToChar(token);
75 EXPECT_EQ(result, 60);
76 }
77
78 /*
79 * @tc.name: TokenToCharTest_0200
80 * @tc.desc: test the token in Lexer's TokenToChar function is ANGLE_BRACKETS_RIGHT.
81 * @tc.type: FUNC
82 * @tc.require:
83 */
84 HWTEST_F(LexerUnitTest, TokenToCharTest_0200, Function | MediumTest | Level1)
85 {
86 GTEST_LOG_(INFO)
87 << "LexerUnitTest, TokenToCharTest_0200, TestSize.Level1";
88 Lexer imageLexer;
89 Token token = Token::ANGLE_BRACKETS_RIGHT;
90 int result = imageLexer.TokenToChar(token);
91 EXPECT_EQ(result, 62);
92 }
93
94 /*
95 * @tc.name: TokenToCharTest_0300
96 * @tc.desc: test the token in Lexer's TokenToChar function is BRACES_LEFT.
97 * @tc.type: FUNC
98 * @tc.require:
99 */
100 HWTEST_F(LexerUnitTest, TokenToCharTest_0300, Function | MediumTest | Level1)
101 {
102 GTEST_LOG_(INFO)
103 << "LexerUnitTest, TokenToCharTest_0300, TestSize.Level1";
104 Lexer imageLexer;
105 Token token = Token::BRACES_LEFT;
106 int result = imageLexer.TokenToChar(token);
107 EXPECT_EQ(result, 123);
108 }
109
110 /*
111 * @tc.name: TokenToCharTest_0400
112 * @tc.desc: test the token in Lexer's TokenToChar function is BRACES_RIGHT.
113 * @tc.type: FUNC
114 * @tc.require:
115 */
116 HWTEST_F(LexerUnitTest, TokenToCharTest_0400, Function | MediumTest | Level1)
117 {
118 GTEST_LOG_(INFO)
119 << "LexerUnitTest, TokenToCharTest_0400, TestSize.Level1";
120 Lexer imageLexer;
121 Token token = Token::BRACES_RIGHT;
122 int result = imageLexer.TokenToChar(token);
123 EXPECT_EQ(result, 125);
124 }
125
126 /*
127 * @tc.name: TokenToCharTest_0500
128 * @tc.desc: test the token in Lexer's TokenToChar function is BRACKETS_LEFT.
129 * @tc.type: FUNC
130 * @tc.require:
131 */
132 HWTEST_F(LexerUnitTest, TokenToCharTest_0500, Function | MediumTest | Level1)
133 {
134 GTEST_LOG_(INFO)
135 << "LexerUnitTest, TokenToCharTest_0500, TestSize.Level1";
136 Lexer imageLexer;
137 Token token = Token::BRACKETS_LEFT;
138 int result = imageLexer.TokenToChar(token);
139 EXPECT_EQ(result, 91);
140 }
141
142 /*
143 * @tc.name: TokenToCharTest_0600
144 * @tc.desc: test the token in Lexer's TokenToChar function is BRACKETS_RIGHT.
145 * @tc.type: FUNC
146 * @tc.require:
147 */
148 HWTEST_F(LexerUnitTest, TokenToCharTest_0600, Function | MediumTest | Level1)
149 {
150 GTEST_LOG_(INFO)
151 << "LexerUnitTest, TokenToCharTest_0600, TestSize.Level1";
152 Lexer imageLexer;
153 Token token = Token::BRACKETS_RIGHT;
154 int result = imageLexer.TokenToChar(token);
155 EXPECT_EQ(result, 93);
156 }
157
158 /*
159 * @tc.name: TokenToCharTest_0700
160 * @tc.desc: test the token in Lexer's TokenToChar function is COMMA.
161 * @tc.type: FUNC
162 * @tc.require:
163 */
164 HWTEST_F(LexerUnitTest, TokenToCharTest_0700, Function | MediumTest | Level1)
165 {
166 GTEST_LOG_(INFO)
167 << "LexerUnitTest, TokenToCharTest_0700, TestSize.Level1";
168 Lexer imageLexer;
169 Token token = Token::COMMA;
170 int result = imageLexer.TokenToChar(token);
171 EXPECT_EQ(result, 44);
172 }
173
174 /*
175 * @tc.name: TokenToCharTest_0800
176 * @tc.desc: test the token in Lexer's TokenToChar function is DOT.
177 * @tc.type: FUNC
178 * @tc.require:
179 */
180 HWTEST_F(LexerUnitTest, TokenToCharTest_0800, Function | MediumTest | Level1)
181 {
182 GTEST_LOG_(INFO)
183 << "LexerUnitTest, TokenToCharTest_0800, TestSize.Level1";
184 Lexer imageLexer;
185 Token token = Token::DOT;
186 int result = imageLexer.TokenToChar(token);
187 EXPECT_EQ(result, 46);
188 }
189
190 /*
191 * @tc.name: TokenToCharTest_0900
192 * @tc.desc: test the token in Lexer's TokenToChar function is PARENTHESES_LEFT.
193 * @tc.type: FUNC
194 * @tc.require:
195 */
196 HWTEST_F(LexerUnitTest, TokenToCharTest_0900, Function | MediumTest | Level1)
197 {
198 GTEST_LOG_(INFO)
199 << "LexerUnitTest, TokenToCharTest_0900, TestSize.Level1";
200 Lexer imageLexer;
201 Token token = Token::PARENTHESES_LEFT;
202 int result = imageLexer.TokenToChar(token);
203 EXPECT_EQ(result, 40);
204 }
205
206 /*
207 * @tc.name: TokenToCharTest_1000
208 * @tc.desc: test the token in Lexer's TokenToChar function is PARENTHESES_RIGHT.
209 * @tc.type: FUNC
210 * @tc.require:
211 */
212 HWTEST_F(LexerUnitTest, TokenToCharTest_1000, Function | MediumTest | Level1)
213 {
214 GTEST_LOG_(INFO)
215 << "LexerUnitTest, TokenToCharTest_1000, TestSize.Level1";
216 Lexer imageLexer;
217 Token token = Token::PARENTHESES_RIGHT;
218 int result = imageLexer.TokenToChar(token);
219 EXPECT_EQ(result, 41);
220 }
221
222 /*
223 * @tc.name: TokenToCharTest_1100
224 * @tc.desc: test the token in Lexer's TokenToChar function is other.
225 * @tc.type: FUNC
226 * @tc.require:
227 */
228 HWTEST_F(LexerUnitTest, TokenToCharTest_1100, Function | MediumTest | Level1)
229 {
230 GTEST_LOG_(INFO)
231 << "LexerUnitTest, TokenToCharTest_1100, TestSize.Level1";
232 Lexer imageLexer;
233 Token token = Token::IDENTIFIER;
234 int result = imageLexer.TokenToChar(token);
235 EXPECT_EQ(result, -1);
236 }
237