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
19using namespace panda::ecmascript::tooling;
20
21namespace panda::test {
22class PtBase64Test : public testing::Test {
23public:
24    static void SetUpTestCase()
25    {
26        GTEST_LOG_(INFO) << "SetUpTestCase";
27    }
28
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
44HWTEST_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
60HWTEST_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
108HWTEST_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
125HWTEST_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
146HWTEST_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
156HWTEST_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
188HWTEST_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
228HWTEST_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
245HWTEST_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
262HWTEST_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}