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 "ecmascript/tests/test_helper.h"
17 #include "tooling/base/pt_base64.h"
18
19 using namespace panda::ecmascript::tooling;
20
21 namespace panda::test {
22 class PtBase64Test : public testing::Test {
23 public:
SetUpTestCase()24 static void SetUpTestCase()
25 {
26 GTEST_LOG_(INFO) << "SetUpTestCase";
27 }
28
TearDownTestCase()29 static void TearDownTestCase()
30 {
31 GTEST_LOG_(INFO) << "TearDownCase";
32 }
33
34 void SetUp() override
35 {
36 }
37
38 void TearDown() override
39 {
40 }
41 };
42
43
HWTEST_F_L0(PtBase64Test, EncodeAndDecodeEmptyString)44 HWTEST_F_L0(PtBase64Test, EncodeAndDecodeEmptyString)
45 {
46 std::string src;
47 std::string dest;
48
49 dest.resize(PtBase64::DecodedSize(src.size()));
50 auto [numOctets, done] = PtBase64::Decode(dest.data(), src.data(), src.size());
51 dest.resize(numOctets);
52 EXPECT_EQ(numOctets, 0u);
53 EXPECT_FALSE(done);
54
55 size_t len = PtBase64::Encode(dest.data(), src.data(), src.size());
56 EXPECT_EQ(len, 0u);
57 EXPECT_EQ(dest, "");
58 }
59
HWTEST_F_L0(PtBase64Test, EncodeAndDecodeShortText001)60 HWTEST_F_L0(PtBase64Test, EncodeAndDecodeShortText001)
61 {
62 std::string src;
63 std::string dest;
64 size_t len = 0;
65
66 {
67 src = "1";
68 dest.resize(PtBase64::EncodedSize(src.size()));
69 len = PtBase64::Encode(dest.data(), src.data(), src.size());
70 EXPECT_EQ(len, 4u);
71 EXPECT_EQ(dest, "MQ==");
72 src = dest;
73 dest.resize(PtBase64::DecodedSize(src.size()));
74 auto [numOctets, done] = PtBase64::Decode(dest.data(), src.data(), src.size());
75 dest.resize(numOctets);
76 EXPECT_EQ(numOctets, 1u);
77 EXPECT_EQ(dest, "1");
78 }
79
80 {
81 src = "12";
82 dest.resize(PtBase64::EncodedSize(src.size()));
83 len = PtBase64::Encode(dest.data(), src.data(), src.size());
84 EXPECT_EQ(len, 4u);
85 EXPECT_EQ(dest, "MTI=");
86 src = dest;
87 dest.resize(PtBase64::DecodedSize(src.size()));
88 auto [numOctets, done] = PtBase64::Decode(dest.data(), src.data(), src.size());
89 dest.resize(numOctets);
90 EXPECT_EQ(numOctets, 2u);
91 EXPECT_EQ(dest, "12");
92 }
93
94 {
95 src = "123";
96 dest.resize(PtBase64::EncodedSize(src.size()));
97 len = PtBase64::Encode(dest.data(), src.data(), src.size());
98 EXPECT_EQ(len, 4u);
99 EXPECT_EQ(dest, "MTIz");
100 src = dest;
101 auto [numOctets, done] = PtBase64::Decode(dest.data(), src.data(), src.size());
102 dest.resize(numOctets);
103 EXPECT_EQ(numOctets, 3u);
104 EXPECT_EQ(dest, "123");
105 }
106 }
107
HWTEST_F_L0(PtBase64Test, EncodeAndDecodeShortText002)108 HWTEST_F_L0(PtBase64Test, EncodeAndDecodeShortText002)
109 {
110 std::string dest;
111 std::string src = "hello";
112 dest.resize(PtBase64::EncodedSize(src.size()));
113 size_t len = PtBase64::Encode(dest.data(), src.data(), src.size());
114 EXPECT_EQ(len, 8u);
115 EXPECT_EQ(dest, "aGVsbG8=");
116 src = dest;
117 dest.resize(PtBase64::DecodedSize(src.size()));
118 auto [numOctets, done] = PtBase64::Decode(dest.data(), src.data(), src.size());
119 dest.resize(numOctets);
120 EXPECT_EQ(numOctets, 5u);
121 EXPECT_TRUE(done);
122 EXPECT_EQ(dest, "hello");
123 }
124
HWTEST_F_L0(PtBase64Test, EncodeAndDecodeLongText)125 HWTEST_F_L0(PtBase64Test, EncodeAndDecodeLongText)
126 {
127 std::string src = "If you can see this message, it means that PtBase64Decode works well";
128 std::string dest;
129 std::string encoded = "SWYgeW91IGNhbiBzZWUgdGhpcyBtZXNzYWdlLCBpdCBtZWFucyB0aGF0IFB0QmFzZ" \
130 "TY0RGVjb2RlIHdvcmtzIHdlbGw=";
131
132 dest.resize(PtBase64::EncodedSize(src.size()));
133 size_t len = PtBase64::Encode(dest.data(), src.data(), src.size());
134 EXPECT_EQ(len, 92u);
135 EXPECT_EQ(dest, encoded);
136
137 std::string decoded;
138 decoded.resize(PtBase64::DecodedSize(encoded.size()));
139 auto [numOctets, done] = PtBase64::Decode(decoded.data(), encoded.data(), encoded.size());
140 decoded.resize(numOctets);
141 EXPECT_EQ(numOctets, 68u);
142 EXPECT_TRUE(done);
143 EXPECT_EQ(decoded, src);
144 }
145
HWTEST_F_L0(PtBase64Test, EncodeUnprintableCharacter)146 HWTEST_F_L0(PtBase64Test, EncodeUnprintableCharacter)
147 {
148 std::string src = {1, 2, 3, 4, 5, 6, 7, 8, 9};
149 std::string dest;
150 dest.resize(PtBase64::EncodedSize(src.size()));
151 size_t len = PtBase64::Encode(dest.data(), src.data(), src.size());
152 EXPECT_EQ(len, 12u);
153 EXPECT_EQ(dest, "AQIDBAUGBwgJ");
154 }
155
HWTEST_F_L0(PtBase64Test, DecodeErrorNumberBase64Text)156 HWTEST_F_L0(PtBase64Test, DecodeErrorNumberBase64Text)
157 {
158 std::string src;
159 std::string dest;
160 {
161 src = "ABC";
162 dest.resize(PtBase64::DecodedSize(src.size()));
163 auto [numOctets, done] = PtBase64::Decode(dest.data(), src.data(), src.size());
164 dest.resize(numOctets);
165 EXPECT_EQ(numOctets, 0u);
166 EXPECT_EQ(dest, "");
167 }
168
169 {
170 src = "ABCDE";
171 dest.resize(PtBase64::DecodedSize(src.size()));
172 auto [numOctets, done] = PtBase64::Decode(dest.data(), src.data(), src.size());
173 dest.resize(numOctets);
174 EXPECT_EQ(numOctets, 0u);
175 EXPECT_EQ(dest, "");
176 }
177
178 {
179 src = "ABCDEF";
180 dest.resize(PtBase64::DecodedSize(src.size()));
181 auto [numOctets, done] = PtBase64::Decode(dest.data(), src.data(), src.size());
182 dest.resize(numOctets);
183 EXPECT_EQ(numOctets, 0u);
184 EXPECT_EQ(dest, "");
185 }
186 }
187
HWTEST_F_L0(PtBase64Test, EncodeAndDecodeBytesArray)188 HWTEST_F_L0(PtBase64Test, EncodeAndDecodeBytesArray)
189 {
190 std::vector<uint8_t> src = {
191 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
192 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
193 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
194 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
195 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
196 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
197 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
198 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
199 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
200 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
201 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
202 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
203 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
204 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
205 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
206 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
207 };
208 std::string dest;
209 std::string encoded = "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4O" \
210 "To7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3Bxcn" \
211 "N0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6y" \
212 "trq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm" \
213 "5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w==";
214 dest.resize(PtBase64::EncodedSize(src.size()));
215 size_t len = PtBase64::Encode(dest.data(), src.data(), src.size());
216 EXPECT_EQ(len, 344u);
217 EXPECT_EQ(dest, encoded);
218
219 std::vector<uint8_t> decoded;
220 decoded.resize(PtBase64::DecodedSize(encoded.size()));
221 auto [numOctets, done] = PtBase64::Decode(decoded.data(), encoded.data(), encoded.size());
222 decoded.resize(numOctets);
223 EXPECT_EQ(numOctets, 256u);
224 EXPECT_TRUE(done);
225 EXPECT_EQ(memcmp(decoded.data(), src.data(), numOctets), 0);
226 }
227
HWTEST_F_L0(PtBase64Test, EncodeAndDecodeUnicodeCharacter001)228 HWTEST_F_L0(PtBase64Test, EncodeAndDecodeUnicodeCharacter001)
229 {
230 std::string src = u8"�";
231 std::string dest;
232 dest.resize(PtBase64::EncodedSize(src.size()));
233 size_t len = PtBase64::Encode(dest.data(), src.data(), src.size());
234 EXPECT_EQ(len, 8u);
235 EXPECT_EQ(dest, "8J+YgA==");
236 src = dest;
237 dest.resize(PtBase64::DecodedSize(src.size()));
238 auto [numOctets, done] = PtBase64::Decode(dest.data(), src.data(), src.size());
239 dest.resize(numOctets);
240 EXPECT_EQ(numOctets, 4u);
241 EXPECT_TRUE(done);
242 EXPECT_EQ(dest, u8"�");
243 }
244
HWTEST_F_L0(PtBase64Test, EncodeAndDecodeUnicodeCharacter002)245 HWTEST_F_L0(PtBase64Test, EncodeAndDecodeUnicodeCharacter002)
246 {
247 std::string src = "测试Base64加密解密";
248 std::string dest;
249 dest.resize(PtBase64::EncodedSize(src.size()));
250 size_t len = PtBase64::Encode(dest.data(), src.data(), src.size());
251 EXPECT_EQ(len, 32u);
252 EXPECT_EQ(dest, "5rWL6K+VQmFzZTY05Yqg5a+G6Kej5a+G");
253 src = dest;
254 dest.resize(PtBase64::DecodedSize(src.size()));
255 auto [numOctets, done] = PtBase64::Decode(dest.data(), src.data(), src.size());
256 dest.resize(numOctets);
257 EXPECT_EQ(numOctets, 24u);
258 EXPECT_TRUE(done);
259 EXPECT_EQ(dest, "测试Base64加密解密");
260 }
261
HWTEST_F_L0(PtBase64Test, EncodeAndDecodeInvalidCharacters)262 HWTEST_F_L0(PtBase64Test, EncodeAndDecodeInvalidCharacters)
263 {
264 std::string src;
265 std::string dest;
266 {
267 src = "AB#=";
268 dest.resize(PtBase64::DecodedSize(src.size()));
269 auto [numOctets, done] = PtBase64::Decode(dest.data(), src.data(), src.size());
270 EXPECT_EQ(numOctets, 1u);
271 EXPECT_FALSE(done);
272 }
273
274 {
275 src = "#AB=";
276 dest.resize(PtBase64::DecodedSize(src.size()));
277 auto [numOctets, done] = PtBase64::Decode(dest.data(), src.data(), src.size());
278 EXPECT_EQ(numOctets, 0u);
279 EXPECT_FALSE(done);
280 }
281
282 {
283 src = "AB=#";
284 dest.resize(PtBase64::DecodedSize(src.size()));
285 auto [numOctets, done] = PtBase64::Decode(dest.data(), src.data(), src.size());
286 EXPECT_EQ(numOctets, 1u);
287 EXPECT_FALSE(done);
288 }
289
290 {
291 src = "Zm9vYmFy \r\n\t";
292 dest.resize(PtBase64::DecodedSize(src.size()));
293 auto [numOctets, done] = PtBase64::Decode(dest.data(), src.data(), src.size());
294 EXPECT_EQ(numOctets, 6u);
295 EXPECT_FALSE(done);
296 }
297
298 {
299 src = "=ABC";
300 dest.resize(PtBase64::DecodedSize(src.size()));
301 auto [numOctets, done] = PtBase64::Decode(dest.data(), src.data(), src.size());
302 EXPECT_EQ(numOctets, 0u);
303 EXPECT_FALSE(done);
304 }
305
306 {
307 src = "==AB";
308 dest.resize(PtBase64::DecodedSize(src.size()));
309 auto [numOctets, done] = PtBase64::Decode(dest.data(), src.data(), src.size());
310 EXPECT_EQ(numOctets, 0u);
311 EXPECT_FALSE(done);
312 }
313 }
314 }