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 "test.h"
17
18 #include "napi/native_api.h"
19 #include "napi/native_node_api.h"
20
21 #include "converter.h"
22 #include "js_blob.h"
23 #include "js_buffer.h"
24 #include "tools/log.h"
25
26 #include <limits>
27
28 #define ASSERT_CHECK_CALL(call) \
29 { \
30 ASSERT_EQ(call, napi_ok); \
31 }
32
33 #define ASSERT_CHECK_VALUE_TYPE(env, value, type) \
34 { \
35 napi_valuetype valueType = napi_undefined; \
36 ASSERT_TRUE(value != nullptr); \
37 ASSERT_CHECK_CALL(napi_typeof(env, value, &valueType)); \
38 ASSERT_EQ(valueType, type); \
39 }
FillZero(OHOS::buffer::Buffer * buf,size_t size)40 void FillZero(OHOS::buffer::Buffer *buf, size_t size)
41 {
42 for (size_t i = 0; i < size; i++) {
43 buf->Set(i, 0);
44 }
45 }
46
47 /**
48 * @tc.name: ConstructorTest001
49 * @tc.desc: Buffer Constructor.
50 * @tc.type: FUNC
51 * @tc.require:issueI5J5Z3
52 */
53 HWTEST_F(NativeEngineTest, ConstructorTest001, testing::ext::TestSize.Level0)
54 {
55 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
56 buf->Init(10);
57 ASSERT_EQ(buf->GetLength(), 10);
58 }
59
60 /**
61 * @tc.name: ConstructorTest002
62 * @tc.desc: Buffer Constructor.
63 * @tc.type: FUNC
64 * @tc.require:issueI5J5Z3
65 */
66 HWTEST_F(NativeEngineTest, ConstructorTest002, testing::ext::TestSize.Level0)
67 {
68 OHOS::buffer::Buffer *buf1 = new OHOS::buffer::Buffer();
69 buf1->Init(10);
70 OHOS::buffer::Buffer *buf2 = new OHOS::buffer::Buffer();
71 buf2->Init(buf1);
72 ASSERT_EQ(buf2->GetLength(), 10);
73 }
74
75
76 /**
77 * @tc.name: ConstructorTest003
78 * @tc.desc: Buffer Constructor.
79 * @tc.type: FUNC
80 * @tc.require:issueI5J5Z3
81 */
82 HWTEST_F(NativeEngineTest, ConstructorTest003, testing::ext::TestSize.Level0)
83 {
84 OHOS::buffer::Buffer *poolBuffer = new OHOS::buffer::Buffer();
85 poolBuffer->Init(1024 * 8);
86 OHOS::buffer::Buffer *buf2 = new OHOS::buffer::Buffer();
87 buf2->Init(poolBuffer, 0, 5);
88 ASSERT_EQ(buf2->GetLength(), 5);
89 ASSERT_EQ(buf2->GetByteOffset(), 0);
90
91 OHOS::buffer::Buffer *buf3 = new OHOS::buffer::Buffer();
92 buf3->Init(poolBuffer, 5, 6);
93 ASSERT_EQ(buf3->GetLength(), 6);
94 ASSERT_EQ(buf3->GetByteOffset(), 5);
95 }
96
97 /**
98 * @tc.name: ConstructorTest004
99 * @tc.desc: Buffer Constructor.
100 * @tc.type: FUNC
101 * @tc.require:issueI5J5Z3
102 */
103 HWTEST_F(NativeEngineTest, ConstructorTest004, testing::ext::TestSize.Level0)
104 {
105 OHOS::buffer::Buffer *buf2 = new OHOS::buffer::Buffer();
106 uint8_t data[4] = {1, 2, 3, 4};
107 buf2->Init(data, 0, 4);
108 ASSERT_EQ(buf2->GetLength(), 4);
109 ASSERT_EQ(buf2->GetByteOffset(), 0);
110 }
111
112 /**
113 * @tc.name: ConstructorTest005
114 * @tc.desc: Buffer Constructor.
115 * @tc.type: FUNC
116 * @tc.require:issueI5J5Z3
117 */
118 HWTEST_F(NativeEngineTest, ConstructorTest005, testing::ext::TestSize.Level0)
119 {
120 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
121 buf->Init(1);
122 ASSERT_EQ(buf->GetLength(), 1);
123 uint32_t res = buf->Copy(nullptr, 0, 0, 0);
124 ASSERT_EQ(res, 0);
125 int result = buf->Compare(nullptr, 0, 0, 0);
126 ASSERT_EQ(result, 0);
127 buf->ReadBytes(nullptr, 0, 0);
128 buf->FillString("abc", 1, 0, "utf16le");
129 buf->FillString("abc", 1, 0, "binary");
130 buf->FillString("abc", 1, 0, "sos");
131 buf->FillString("abc", 1, 0, "hex");
132 std::vector<uint8_t> array;
133 buf->FillNumber(array, 0, 0);
134 OHOS::buffer::Buffer *buffer = new OHOS::buffer::Buffer();
135 buf->FillBuffer(buffer, 0, 0);
136 buf->FillBuffer(nullptr, 1, 0);
137 buf->SetArray(array, 0);
138 result = buf->LastIndexOf(nullptr, 0, 0);
139 ASSERT_EQ(result, -1);
140 uint64_t resultIndex = 0;
141 result = buf->IndexOf(nullptr, 0, 0, resultIndex);
142 ASSERT_EQ(result, -1);
143 delete buf;
144 buf = nullptr;
145 delete buffer;
146 buffer = nullptr;
147 }
148
149 /**
150 * @tc.name: DestructorTest001
151 * @tc.desc: Buffer Destructor.
152 * @tc.type: FUNC
153 * @tc.require:issueI5J5Z3
154 */
155 HWTEST_F(NativeEngineTest, DestructorTest001, testing::ext::TestSize.Level0)
156 {
157 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
158 uint8_t data[4] = {1, 2, 3, 4};
159 buf->Init(data, 0, 4);
160 ASSERT_EQ(buf->GetLength(), 4);
161 delete buf;
162 buf = nullptr;
163 }
164
165 /**
166 * @tc.name: GetLengthTest001
167 * @tc.desc: Get buffer Length.
168 * @tc.type: FUNC
169 * @tc.require:issueI5J5Z3
170 */
171 HWTEST_F(NativeEngineTest, GetLengthTest001, testing::ext::TestSize.Level0)
172 {
173 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
174 ASSERT_EQ(buf->GetLength(), 0);
175 }
176
177 /**
178 * @tc.name: GetLengthTest002
179 * @tc.desc: Get buffer Length.
180 * @tc.type: FUNC
181 * @tc.require:issueI5J5Z3
182 */
183 HWTEST_F(NativeEngineTest, GetLengthTest002, testing::ext::TestSize.Level0)
184 {
185 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
186 buf->Init(6);
187 ASSERT_EQ(buf->GetLength(), 6);
188 }
189
190 /**
191 * @tc.name: SetLengthTest001
192 * @tc.desc: Set buffer Length.
193 * @tc.type: FUNC
194 * @tc.require:issueI5J5Z3
195 */
196 HWTEST_F(NativeEngineTest, SetLengthTest001, testing::ext::TestSize.Level0)
197 {
198 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
199 buf->Init(6);
200 buf->SetLength(7);
201 ASSERT_EQ(buf->GetLength(), 7);
202 }
203
204 /**
205 * @tc.name: GetByteOffsetTest001
206 * @tc.desc: Get buffer byteOffset.
207 * @tc.type: FUNC
208 * @tc.require:issueI5J5Z3
209 */
210 HWTEST_F(NativeEngineTest, GetByteOffsetTest001, testing::ext::TestSize.Level0)
211 {
212 OHOS::buffer::Buffer *poolBuffer = new OHOS::buffer::Buffer();
213 poolBuffer->Init(1024 * 8);
214 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
215 buf->Init(poolBuffer, 2, 5);
216 ASSERT_EQ(buf->GetByteOffset(), 2);
217 }
218
219 /**
220 * @tc.name: GetAndSetTest001
221 * @tc.desc: Get And Set method.
222 * @tc.type: FUNC
223 * @tc.require:issueI5J5Z3
224 */
225 HWTEST_F(NativeEngineTest, GetAndSetTest001, testing::ext::TestSize.Level0)
226 {
227 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
228 buf->Init(3);
229 buf->Set(0, 1);
230 int32_t value = buf->Get(0);
231 ASSERT_EQ(value, 1);
232 }
233
234 /**
235 * @tc.name: GetAndSetTest002
236 * @tc.desc: Get And Set method.
237 * @tc.type: FUNC
238 * @tc.require:issueI5J5Z3
239 */
240 HWTEST_F(NativeEngineTest, GetAndSetTest002, testing::ext::TestSize.Level0)
241 {
242 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
243 buf->Init(3);
244 buf->Set(0, 1);
245 buf->Set(1, 2);
246 buf->Set(2, 3);
247 int32_t value = buf->Get(2);
248 ASSERT_EQ(value, 3);
249 }
250
251 /**
252 * @tc.name: WriteInt32BEAndReadInt32BETest001
253 * @tc.desc: Writes value to buf at the specified offset as big-endian. The value must be a valid signed 32-bit integer
254 * Reads a signed, big-endian 32-bit integer from buf at the specified offset.
255 * @tc.type: FUNC
256 * @tc.require:issueI5J5Z3
257 */
258 HWTEST_F(NativeEngineTest, WriteInt32BEAndReadInt32BETest001, testing::ext::TestSize.Level0)
259 {
260 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
261 buf->Init(4);
262 FillZero(buf, 4);
263 buf->WriteInt32BE(0x12345678, 0);
264 int32_t res = buf->ReadInt32BE(0);
265 ASSERT_EQ(res, 0x12345678);
266 }
267
268 /**
269 * @tc.name: WriteInt32BEAndReadInt32BETest002
270 * @tc.desc: Writes value to buf at the specified offset as big-endian. The value must be a valid signed 32-bit integer
271 * Reads a signed, big-endian 32-bit integer from buf at the specified offset.
272 * @tc.type: FUNC
273 * @tc.require:issueI5J5Z3
274 */
275 HWTEST_F(NativeEngineTest, WriteInt32BEAndReadInt32BETest002, testing::ext::TestSize.Level0)
276 {
277 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
278 buf->Init(5);
279 FillZero(buf, 5);
280 buf->WriteInt32BE(0x12345678, 1);
281 int32_t res = buf->ReadInt32BE(1);
282 ASSERT_EQ(res, 0x12345678);
283 }
284
285 /**
286 * @tc.name: WriteInt32BEAndReadInt32BETest003
287 * @tc.desc: Writes value to buf at the specified offset as big-endian. The value must be a valid signed 32-bit integer
288 * Reads a signed, big-endian 32-bit integer from buf at the specified offset.
289 * @tc.type: FUNC
290 * @tc.require:issueI5J5Z3
291 */
292 HWTEST_F(NativeEngineTest, WriteInt32BEAndReadInt32BETest003, testing::ext::TestSize.Level0)
293 {
294 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
295 buf->Init(5);
296 FillZero(buf, 5);
297 buf->WriteInt32BE(0x12345678, 1);
298 int32_t res = buf->ReadInt32BE(1);
299 ASSERT_EQ(res, 0x12345678);
300 }
301
302 /**
303 * @tc.name: WriteInt32LEAndReadInt32LETest001
304 * @tc.desc: Writes value to buf at the specified offset as little-endian.
305 * The value must be a valid signed 32-bit integer.
306 * Reads a signed, little-endian 32-bit integer from buf at the specified offset.
307 * @tc.type: FUNC
308 * @tc.require:issueI5J5Z3
309 */
310 HWTEST_F(NativeEngineTest, WriteInt32LEAndReadInt32LETest001, testing::ext::TestSize.Level0)
311 {
312 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
313 buf->Init(4);
314 FillZero(buf, 4);
315 buf->WriteInt32LE(0x12345678, 0);
316 int32_t res = buf->ReadInt32LE(0);
317 ASSERT_EQ(res, 0x12345678);
318 res = buf->ReadInt32BE(0);
319 ASSERT_EQ(res, 0x78563412);
320 }
321
322 /**
323 * @tc.name: WriteInt32LEAndReadInt32LETest002
324 * @tc.desc: Writes value to buf at the specified offset as little-endian.
325 * The value must be a valid signed 32-bit integer.
326 * Reads a signed, little-endian 32-bit integer from buf at the specified offset.
327 * @tc.type: FUNC
328 * @tc.require:issueI5J5Z3
329 */
330 HWTEST_F(NativeEngineTest, WriteInt32LEAndReadInt32LETest002, testing::ext::TestSize.Level0)
331 {
332 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
333 buf->Init(5);
334 FillZero(buf, 5);
335 buf->WriteInt32LE(0x12345678, 1);
336 int32_t res = buf->ReadInt32LE(0);
337 ASSERT_EQ(res, 0x34567800);
338 }
339
340 /**
341 * @tc.name: WriteInt32LEAndReadInt32LETest003
342 * @tc.desc: Writes value to buf at the specified offset as little-endian.
343 * The value must be a valid signed 32-bit integer.
344 * Reads a signed, little-endian 32-bit integer from buf at the specified offset.
345 * @tc.type: FUNC
346 * @tc.require:issueI5J5Z3
347 */
348 HWTEST_F(NativeEngineTest, WriteInt32LEAndReadInt32LETest003, testing::ext::TestSize.Level0)
349 {
350 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
351 buf->Init(5);
352 FillZero(buf, 5);
353 buf->WriteInt32LE(0x12345678, 1);
354 int32_t res = buf->ReadInt32LE(1);
355 ASSERT_EQ(res, 0x12345678);
356 }
357
358 /**
359 * @tc.name: WriteUInt32BEAndReadUInt32BETest001
360 * @tc.desc: Writes value to buf at the specified offset as big-endian.
361 * The value must be a valid unsigned 32-bit integer.
362 * Reads an unsigned, big-endian 32-bit integer from buf at the specified offset.
363 * @tc.type: FUNC
364 * @tc.require:issueI5J5Z3
365 */
366 HWTEST_F(NativeEngineTest, WriteUInt32BEAndReadUInt32BETest001, testing::ext::TestSize.Level0)
367 {
368 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
369 buf->Init(4);
370 FillZero(buf, 4);
371 buf->WriteUInt32BE(0x12345678, 0);
372 int32_t res = buf->ReadUInt32BE(0);
373 ASSERT_EQ(res, 0x12345678);
374 }
375
376 /**
377 * @tc.name: WriteUInt32BEAndReadUInt32BETest002
378 * @tc.desc: Writes value to buf at the specified offset as big-endian.
379 * The value must be a valid unsigned 32-bit integer.
380 * Reads an unsigned, big-endian 32-bit integer from buf at the specified offset.
381 * @tc.type: FUNC
382 * @tc.require:issueI5J5Z3
383 */
384 HWTEST_F(NativeEngineTest, WriteUInt32BEAndReadUInt32BETest002, testing::ext::TestSize.Level0)
385 {
386 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
387 buf->Init(5);
388 FillZero(buf, 5);
389 buf->WriteUInt32BE(0x12345678, 1);
390 int32_t res = buf->ReadUInt32BE(0);
391 ASSERT_EQ(res, 0x123456);
392 }
393
394 /**
395 * @tc.name: WriteUInt32BEAndReadUInt32BETest003
396 * @tc.desc: Writes value to buf at the specified offset as big-endian.
397 * The value must be a valid unsigned 32-bit integer.
398 * Reads an unsigned, big-endian 32-bit integer from buf at the specified offset.
399 * @tc.type: FUNC
400 * @tc.require:issueI5J5Z3
401 */
402 HWTEST_F(NativeEngineTest, WriteUInt32BEAndReadUInt32BETest003, testing::ext::TestSize.Level0)
403 {
404 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
405 buf->Init(5);
406 FillZero(buf, 5);
407 buf->WriteUInt32BE(0x12345678, 1);
408 int32_t res = buf->ReadUInt32BE(1);
409 ASSERT_EQ(res, 0x12345678);
410 }
411
412 /**
413 * @tc.name: WriteUInt32LEAndReadUInt32LETest001
414 * @tc.desc: Writes value to buf at the specified offset as little-endian.
415 * The value must be a valid unsigned 32-bit integer.
416 * Reads an unsigned, little-endian 32-bit integer from buf at the specified offset.
417 * @tc.type: FUNC
418 * @tc.require:issueI5J5Z3
419 */
420 HWTEST_F(NativeEngineTest, WriteUInt32LEAndReadUInt32LETest001, testing::ext::TestSize.Level0)
421 {
422 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
423 buf->Init(4);
424 FillZero(buf, 4);
425 buf->WriteUInt32LE(0x12345678, 0);
426 int32_t res = buf->ReadUInt32LE(0);
427 ASSERT_EQ(res, 0x12345678);
428 }
429
430 /**
431 * @tc.name: WriteUInt32LEAndReadUInt32LETest002
432 * @tc.desc: Writes value to buf at the specified offset as little-endian.
433 * The value must be a valid unsigned 32-bit integer.
434 * Reads an unsigned, little-endian 32-bit integer from buf at the specified offset.
435 * @tc.type: FUNC
436 * @tc.require:issueI5J5Z3
437 */
438 HWTEST_F(NativeEngineTest, WriteUInt32LEAndReadUInt32LETest002, testing::ext::TestSize.Level0)
439 {
440 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
441 buf->Init(5);
442 FillZero(buf, 5);
443 buf->WriteUInt32LE(0x12345678, 1);
444 int32_t res = buf->ReadUInt32LE(0);
445 ASSERT_EQ(res, 0x34567800);
446 }
447
448 /**
449 * @tc.name: WriteUInt32LEAndReadUInt32LETest003
450 * @tc.desc: Writes value to buf at the specified offset as little-endian.
451 * The value must be a valid unsigned 32-bit integer.
452 * Reads an unsigned, little-endian 32-bit integer from buf at the specified offset.
453 * @tc.type: FUNC
454 * @tc.require:issueI5J5Z3
455 */
456 HWTEST_F(NativeEngineTest, WriteUInt32LEAndReadUInt32LETest003, testing::ext::TestSize.Level0)
457 {
458 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
459 buf->Init(5);
460 FillZero(buf, 5);
461 buf->WriteUInt32LE(0x12345678, 1);
462 int32_t res = buf->ReadUInt32LE(1);
463 ASSERT_EQ(res, 0x12345678);
464 }
465
466 /**
467 * @tc.name: ReadBytesTest001
468 * @tc.desc: Read value from buffer.
469 * @tc.type: FUNC
470 * @tc.require:issueI5J5Z3
471 */
472 HWTEST_F(NativeEngineTest, ReadBytesTest001, testing::ext::TestSize.Level0)
473 {
474 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
475 buf->Init(4);
476 FillZero(buf, 4);
477 buf->WriteUInt32BE(0x12345678, 0);
478 uint32_t length = buf->GetLength();
479 uint8_t data[length];
480 buf->ReadBytes(data, 0, length);
481 uint8_t res[4] = {0x12, 0x34, 0x56, 0x78};
482 for (size_t i = 0; i < length; i++) {
483 ASSERT_EQ(data[i], res[i]);
484 }
485 }
486
487 /**
488 * @tc.name: ReadBytesTest002
489 * @tc.desc: Read value error when length is zero.
490 * @tc.type: FUNC
491 * @tc.require:issueI5J5Z3
492 */
493 HWTEST_F(NativeEngineTest, ReadBytesTest002, testing::ext::TestSize.Level0)
494 {
495 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
496 buf->Init(4);
497 FillZero(buf, 4);
498 buf->WriteUInt32BE(0x12345678, 0);
499 uint32_t length = buf->GetLength();
500 uint8_t data[length];
501 buf->ReadBytes(data, 0, 0);
502 uint8_t res[4] = {0x12, 0x34, 0x56, 0x78};
503 ASSERT_NE(data[0], res[0]);
504 }
505
506 /**
507 * @tc.name: WriteStringTest001
508 * @tc.desc: Write string to buffer.
509 * @tc.type: FUNC
510 * @tc.require:issueI5J5Z3
511 */
512 HWTEST_F(NativeEngineTest, WriteStringTest001, testing::ext::TestSize.Level0)
513 {
514 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
515 buf->Init(10);
516 std::string str = "1234567890";
517 unsigned int size = buf->WriteString(str, 10);
518 ASSERT_EQ(size, 10);
519 }
520
521 /**
522 * @tc.name: WriteStringTest002
523 * @tc.desc: Write string to buffer.
524 * @tc.type: FUNC
525 * @tc.require:issueI5J5Z3
526 */
527 HWTEST_F(NativeEngineTest, WriteStringTest002, testing::ext::TestSize.Level0)
528 {
529 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
530 buf->Init(9);
531 std::string str = "123456789";
532 unsigned int size = buf->WriteString(str, 9);
533 uint8_t data[size];
534 buf->ReadBytes(data, 0, size);
535 uint8_t value = 49;
536 for (size_t i = 0; i < size; i++) {
537 ASSERT_EQ(data[i], value);
538 value++;
539 }
540 }
541
542 /**
543 * @tc.name: WriteStringTest003
544 * @tc.desc: Write string to buffer.
545 * @tc.type: FUNC
546 * @tc.require:issueI5J5Z3
547 */
548 HWTEST_F(NativeEngineTest, WriteStringTest003, testing::ext::TestSize.Level0)
549 {
550 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
551 buf->Init(9);
552 std::string str = "123456789";
553 unsigned int size = buf->WriteString(str, 0, 9);
554 uint8_t data[size];
555 buf->ReadBytes(data, 0, size);
556 uint8_t value = 49;
557 for (size_t i = 0; i < size; i++) {
558 ASSERT_EQ(data[i], value);
559 value++;
560 }
561 }
562
563 /**
564 * @tc.name: WriteStringTest004
565 * @tc.desc: Write string to buffer.
566 * @tc.type: FUNC
567 * @tc.require:issueI5J5Z3
568 */
569 HWTEST_F(NativeEngineTest, WriteStringTest004, testing::ext::TestSize.Level0)
570 {
571 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
572 buf->Init(9);
573 std::string str = "123456789";
574 unsigned int size = buf->WriteString(str, 2, 7);
575 uint8_t data[size];
576 buf->ReadBytes(data, 0, size);
577 uint8_t value = 49;
578 for (size_t i = 2; i < size; i++) {
579 ASSERT_EQ(data[i], value);
580 value++;
581 }
582 }
583
584 /**
585 * @tc.name: WriteStringTest005
586 * @tc.desc: Write string to buffer.
587 * @tc.type: FUNC
588 * @tc.require:issueI5J5Z3
589 */
590 HWTEST_F(NativeEngineTest, WriteStringTest005, testing::ext::TestSize.Level0)
591 {
592 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
593 buf->Init(9);
594 std::string str = "123456789";
595 unsigned int size = buf->WriteString(str, 0, 9, "utf8");
596 uint8_t data[size];
597 buf->ReadBytes(data, 0, size);
598 uint8_t value = 49;
599 for (size_t i = 0; i < size; i++) {
600 ASSERT_EQ(data[i], value);
601 value++;
602 }
603 }
604
605 /**
606 * @tc.name: WriteStringTest006
607 * @tc.desc: Write string to buffer.
608 * @tc.type: FUNC
609 * @tc.require:issueI5J5Z3
610 */
611 HWTEST_F(NativeEngineTest, WriteStringTest006, testing::ext::TestSize.Level0)
612 {
613 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
614 buf->Init(16);
615 FillZero(buf, 16);
616 std::string str = "12345678";
617 unsigned int size = buf->WriteString(str, 0, 16, "utf16le");
618 ASSERT_EQ(size, 16);
619 uint8_t data[size];
620 buf->ReadBytes(data, 0, size);
621 uint8_t value = 49;
622 for (size_t i = 0; i < size; i++) {
623 if (i % 2 == 0) {
624 ASSERT_EQ(data[i], value);
625 value++;
626 } else {
627 ASSERT_EQ(data[i], 0);
628 }
629 }
630 }
631
632 /**
633 * @tc.name: SubBufferTest001
634 * @tc.desc: Returns a new Buffer that references the same memory as the original,
635 * but offset and cropped by the start and end indices.
636 * @tc.type: FUNC
637 * @tc.require:issueI5J5Z3
638 */
639 HWTEST_F(NativeEngineTest, SubBufferTest001, testing::ext::TestSize.Level0)
640 {
641 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
642 buf->SubBuffer(nullptr, 0, 10);
643
644 OHOS::buffer::Buffer *buf1 = new OHOS::buffer::Buffer();
645 buf1->Init(10);
646 FillZero(buf1, 10);
647 std::string str = "1234567890";
648 buf1->WriteString(str, 0, 10);
649 OHOS::buffer::Buffer *buf2 = new OHOS::buffer::Buffer();
650 buf2->SubBuffer(buf1, 0, 10);
651 buf1->ReadBytesForArrayBuffer(NULL, 0);
652
653 ASSERT_EQ(buf2->GetLength(), 10);
654 uint8_t data[11];
655 buf2->ReadBytes(data, 0, 10);
656 data[10] = 0;
657 ASSERT_STREQ(reinterpret_cast<char*>(data), str.c_str());
658 }
659
660 /**
661 * @tc.name: SubBufferTest002
662 * @tc.desc: Returns a new Buffer that references the same memory as the original,
663 * but offset and cropped by the start and end indices.
664 * @tc.type: FUNC
665 * @tc.require:issueI5J5Z3
666 */
667 HWTEST_F(NativeEngineTest, SubBufferTest002, testing::ext::TestSize.Level0)
668 {
669 OHOS::buffer::Buffer *buf1 = new OHOS::buffer::Buffer();
670 buf1->Init(10);
671 FillZero(buf1, 10);
672 std::string str = "1234567890";
673 buf1->WriteString(str, 0, 10);
674 OHOS::buffer::Buffer *buf2 = new OHOS::buffer::Buffer();
675 buf2->SubBuffer(buf1, 2, 10);
676 ASSERT_EQ(buf2->GetLength(), 8);
677 uint8_t data[9];
678 buf2->ReadBytes(data, 0, 8);
679 data[8] = 0;
680 ASSERT_STREQ(reinterpret_cast<char*>(data), "34567890");
681 }
682
683 /**
684 * @tc.name: CopyTest001
685 * @tc.desc: Copies data from a region of buf to a region in target,
686 * even if the target memory region overlaps with buf.
687 * @tc.type: FUNC
688 * @tc.require:issueI5J5Z3
689 */
690 HWTEST_F(NativeEngineTest, CopyTest001, testing::ext::TestSize.Level0)
691 {
692 OHOS::buffer::Buffer *buffer = new OHOS::buffer::Buffer();
693 buffer->Init(20);
694
695 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
696 buf->Init(20);
697 buf->WriteString("this is a string", 16);
698
699 unsigned int tOffset = 1;
700 unsigned int sOffset = 0;
701 unsigned int tEnd = 16;
702 unsigned int sEnd = 16;
703 buf->Copy(buffer, tOffset, sOffset, sEnd);
704 uint8_t data[20] = {0};
705 buffer->ReadBytes(data, tOffset, tEnd);
706 ASSERT_STREQ(reinterpret_cast<char*>(data), "this is a string");
707 }
708
709 /**
710 * @tc.name: CopyTest002
711 * @tc.desc: Copies data with len 0
712 * @tc.type: FUNC
713 * @tc.require:issueI5J5Z3
714 */
715 HWTEST_F(NativeEngineTest, CopyTest002, testing::ext::TestSize.Level0)
716 {
717 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
718 buf->Init(20);
719 std::string value = "YWJjZA";
720 ASSERT_EQ(buf->Copy(buf, 0, 2, 2), 0);
721 }
722 /**
723 * @tc.name: CopyTest003
724 * @tc.desc: Buffer Copy.
725 * @tc.type: FUNC
726 * @tc.require:issueI5J5Z3
727 */
728 HWTEST_F(NativeEngineTest, CopyTest003, testing::ext::TestSize.Level0)
729 {
730 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
731 uint8_t data[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
732 buf->Init(data, 0, 10);
733 uint32_t res = buf->Copy(buf, 0, 4, 10);
734 ASSERT_EQ(res, 6);
735 res = buf->Copy(buf, 0, 0, 0);
736 ASSERT_EQ(res, 0);
737 delete buf;
738 OHOS::buffer::Buffer *buf1 = new OHOS::buffer::Buffer();
739 res = buf1->Copy(buf1, 0, 4, 10);
740 delete buf1;
741 ASSERT_EQ(res, 0);
742 }
743
744 /**
745 * @tc.name: CompareTest001
746 * @tc.desc: Compares buf with target and returns a number indicating whether buf comes before, after,
747 * or is the same as target in sort order. Comparison is based on the actual sequence of bytes in each Buffer
748 * @tc.type: FUNC
749 * @tc.require:issueI5J5Z3
750 */
751 HWTEST_F(NativeEngineTest, CompareTest001, testing::ext::TestSize.Level0)
752 {
753 OHOS::buffer::Buffer *buffer = new OHOS::buffer::Buffer();
754 buffer->Init(20);
755 buffer->WriteString("this is a string", 16);
756
757 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
758 buf->Init(20);
759 buf->WriteString("this is a string", 1, 16);
760
761 int result = buf->Compare(buffer, 0, 1, 16);
762 ASSERT_EQ(result, 0);
763 }
764
765 /**
766 * @tc.name: IndexOfTest001
767 * @tc.desc: The index of the first occurrence of value in buf.
768 * @tc.type: FUNC
769 * @tc.require:issueI5J5Z3
770 */
771 HWTEST_F(NativeEngineTest, IndexOfTest001, testing::ext::TestSize.Level0)
772 {
773 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
774 buf->Init(20);
775 buf->WriteString("this is a string", 16);
776 uint64_t resultIndex = 0;
777 int index = buf->IndexOf("is", 0, 2, resultIndex);
778 ASSERT_EQ(index, -2);
779 ASSERT_EQ(resultIndex, 2);
780 }
781
782 /**
783 * @tc.name: IndexOfTest002
784 * @tc.desc: The index of the first occurrence of value in buf.
785 * @tc.type: FUNC
786 * @tc.require:issueI5J5Z3
787 */
788 HWTEST_F(NativeEngineTest, IndexOfTest002, testing::ext::TestSize.Level0)
789 {
790 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
791 buf->Init(7);
792 buf->WriteString("3363333", 7);
793 uint64_t resultIndex = 0;
794 int index = buf->IndexOf("36", 0, 2, resultIndex);
795 ASSERT_EQ(index, -2);
796 ASSERT_EQ(resultIndex, 1);
797 }
798
799 /**
800 * @tc.name: IndexOfTest003
801 * @tc.desc: The index of the first occurrence of value in buf.
802 * @tc.type: FUNC
803 * @tc.require:issueI5J5Z3
804 */
805 HWTEST_F(NativeEngineTest, IndexOfTest003, testing::ext::TestSize.Level0)
806 {
807 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
808 buf->Init(12);
809 buf->WriteString("322362326233", 12);
810 uint64_t resultIndex = 0;
811 int index = buf->IndexOf("2623", 0, 4, resultIndex);
812 ASSERT_EQ(index, -2);
813 ASSERT_EQ(resultIndex, 7);
814 }
815
816 /**
817 * @tc.name: IndexOfTest004
818 * @tc.desc: Data is not in buf.
819 * @tc.type: FUNC
820 * @tc.require:issueI5J5Z3
821 */
822 HWTEST_F(NativeEngineTest, IndexOfTest004, testing::ext::TestSize.Level0)
823 {
824 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
825 buf->Init(12);
826 buf->WriteString("322362326233", 12);
827 uint64_t resultIndex = 0;
828 int index = buf->IndexOf("99", 0, 2, resultIndex);
829 ASSERT_EQ(index, -1);
830 }
831
832 /**
833 * @tc.name: LastIndexOfTest001
834 * @tc.desc: The index of the last occurrence of value in buf.
835 * @tc.type: FUNC
836 * @tc.require:issueI5J5Z3
837 */
838 HWTEST_F(NativeEngineTest, LastIndexOfTest001, testing::ext::TestSize.Level0)
839 {
840 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
841 buf->Init(20);
842 buf->WriteString("this is a string", 16);
843 int index = buf->LastIndexOf("is", 0, 2);
844 ASSERT_EQ(index, 5);
845 }
846
847 /**
848 * @tc.name: LastIndexOfTest002
849 * @tc.desc: The index of the last occurrence of value in buf.
850 * @tc.type: FUNC
851 * @tc.require:issueI5J5Z3
852 */
853 HWTEST_F(NativeEngineTest, LastIndexOfTest002, testing::ext::TestSize.Level0)
854 {
855 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
856 buf->Init(7);
857 buf->WriteString("3363333", 7);
858 int index = buf->LastIndexOf("36", 0, 2);
859 ASSERT_EQ(index, 1);
860 }
861
862 /**
863 * @tc.name: LastIndexOfTest003
864 * @tc.desc: The index of the last occurrence of value in buf.
865 * @tc.type: FUNC
866 * @tc.require:issueI5J5Z3
867 */
868 HWTEST_F(NativeEngineTest, LastIndexOfTest003, testing::ext::TestSize.Level0)
869 {
870 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
871 buf->Init(11);
872 buf->WriteString("32236326233", 11);
873 int index = buf->LastIndexOf("236", 0, 3);
874 ASSERT_EQ(index, 2);
875 }
876
877 /**
878 * @tc.name: LastIndexOfTest004
879 * @tc.desc: The index of the last occurrence of value in buf.
880 * @tc.type: FUNC
881 * @tc.require:issueI5J5Z3
882 */
883 HWTEST_F(NativeEngineTest, LastIndexOfTest004, testing::ext::TestSize.Level0)
884 {
885 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
886 buf->Init(12);
887 buf->WriteString("322362326233", 12);
888 int index = buf->LastIndexOf("2236", 0, 4);
889 ASSERT_EQ(index, 1);
890 }
891
892 /**
893 * @tc.name: LastIndexOfTest005
894 * @tc.desc: The index of the last occurrence of value in buf.
895 * @tc.type: FUNC
896 * @tc.require:issueI5J5Z3
897 */
898 HWTEST_F(NativeEngineTest, LastIndexOfTest005, testing::ext::TestSize.Level0)
899 {
900 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
901 buf->Init(12);
902 buf->WriteString("322362326233", 12);
903 int index = buf->LastIndexOf("136", 0, 3);
904 ASSERT_EQ(index, -1);
905 }
906
907
908 /**
909 * @tc.name: ToBase64Test001
910 * @tc.desc: Convert the contents of the buffer into a string in Base64 format.
911 * @tc.type: FUNC
912 * @tc.require:issueI5J5Z3
913 */
914 HWTEST_F(NativeEngineTest, ToBase64Test001, testing::ext::TestSize.Level0)
915 {
916 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
917 buf->Init(20);
918 buf->WriteString("this is a string", 16);
919 std::string base64Str = buf->ToBase64(0, 16);
920 ASSERT_STREQ(base64Str.c_str(), "dGhpcyBpcyBhIHN0cmluZw==");
921 }
922
923 /**
924 * @tc.name: ToBase64Test002
925 * @tc.desc: Convert the contents of the buffer into a string in Base64 format.
926 * @tc.type: FUNC
927 * @tc.require:issueI5J5Z3
928 */
929 HWTEST_F(NativeEngineTest, ToBase64Test002, testing::ext::TestSize.Level0)
930 {
931 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
932 buf->Init(30);
933 buf->WriteString("this is a big string", 20);
934 std::string base64Str = buf->ToBase64(0, 20);
935 ASSERT_STREQ(base64Str.c_str(), "dGhpcyBpcyBhIGJpZyBzdHJpbmc=");
936 }
937
938 /**
939 * @tc.name: ToBase64Test003
940 * @tc.desc: Convert to base64 with length 0.
941 * @tc.type: FUNC
942 * @tc.require:issueI5J5Z3
943 */
944 HWTEST_F(NativeEngineTest, ToBase64Test003, testing::ext::TestSize.Level0)
945 {
946 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
947 buf->Init(30);
948 buf->WriteString("this is a big string", 20);
949 std::string base64Str = buf->ToBase64(0, 0);
950 ASSERT_STREQ(base64Str.c_str(), "");
951 }
952
953 /**
954 * @tc.name: ToBase64UrlTest001
955 * @tc.desc: Convert the contents of the buffer into a string in Base64 format.
956 * @tc.type: FUNC
957 * @tc.require:issueI5J5Z3
958 */
959 HWTEST_F(NativeEngineTest, ToBase64UrlTest001, testing::ext::TestSize.Level0)
960 {
961 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
962 buf->Init(20);
963 buf->WriteString("this is a string", 16);
964 std::string base64Str = buf->ToBase64Url(0, 16);
965 std::string stra = OHOS::buffer::Base64Encode(nullptr, 10, OHOS::buffer::BASE64URL);
966 ASSERT_STREQ(base64Str.c_str(), "dGhpcyBpcyBhIHN0cmluZw");
967 }
968
969 /**
970 * @tc.name: GetEncodingTypeTest001
971 * @tc.desc: Get encoding type.
972 * @tc.type: FUNC
973 * @tc.require:issueI5J5Z3
974 */
975 HWTEST_F(NativeEngineTest, GetEncodingTypeTest001, testing::ext::TestSize.Level0)
976 {
977 std::map <std::string, int> _typeMap =
978 {
979 {"hex", OHOS::buffer::HEX},
980 {"base64url", OHOS::buffer::BASE64URL},
981 {"ascii", OHOS::buffer::ASCII},
982 {"base64", OHOS::buffer::BASE64},
983 {"latin1", OHOS::buffer::LATIN1},
984 {"binary", OHOS::buffer::BINARY},
985 {"utf16le", OHOS::buffer::UTF16LE},
986 {"utf8", OHOS::buffer::UTF8},
987 };
988
989 for (auto item =_typeMap.begin(); item != _typeMap.end(); item++)
990 {
991 std::string type = item->first;
992 OHOS::buffer::EncodingType et = OHOS::buffer::Buffer::GetEncodingType(type);
993 ASSERT_EQ(et, item->second);
994 }
995 }
996
997 /**
998 * @tc.name: SetArrayTest001
999 * @tc.desc: Put the contents of the array into the buffer.
1000 * @tc.type: FUNC
1001 * @tc.require:issueI5J5Z3
1002 */
1003 HWTEST_F(NativeEngineTest, SetArrayTest001, testing::ext::TestSize.Level0)
1004 {
1005 OHOS::buffer::Buffer *buffer = new OHOS::buffer::Buffer();
1006 buffer->Init(20);
1007 std::vector<uint8_t> numbers;
1008 for (int i = 0; i < 10; i++) {
1009 numbers.push_back(i);
1010 }
1011 buffer->SetArray(numbers);
1012 unsigned int offset = 0;
1013 unsigned int end = 10;
1014 uint8_t data[20] = {0};
1015 buffer->ReadBytes(data, offset, end);
1016 for (int j = 0; j < 10; j++) {
1017 ASSERT_EQ(data[j], j);
1018 }
1019 }
1020
1021 /**
1022 * @tc.name: FillBufferTest001
1023 * @tc.desc: Fill the buffer with the buffer object
1024 * @tc.type: FUNC
1025 * @tc.require:issueI5J5Z3
1026 */
1027 HWTEST_F(NativeEngineTest, FillBufferTest001, testing::ext::TestSize.Level0)
1028 {
1029 OHOS::buffer::Buffer *buffer = new OHOS::buffer::Buffer();
1030 buffer->Init(10);
1031 std::vector<uint8_t> numbers;
1032 for (int i = 0; i < 10; i++) {
1033 numbers.push_back(i);
1034 }
1035 buffer->SetArray(numbers);
1036 unsigned int offset = 0;
1037 unsigned int end = 10;
1038 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
1039 buf->Init(20);
1040 buf->FillBuffer(buffer, offset, end);
1041 uint8_t data[20] = {0};
1042 buf->ReadBytes(data, offset, end);
1043 for (int j = 0; j < 10; j++) {
1044 ASSERT_EQ(data[j], j);
1045 }
1046 }
1047
1048 /**
1049 * @tc.name: FillNumberTest001
1050 * @tc.desc: Fill the buffer with the number
1051 * @tc.type: FUNC
1052 * @tc.require:issueI5J5Z3
1053 */
1054 HWTEST_F(NativeEngineTest, FillNumberTest001, testing::ext::TestSize.Level0)
1055 {
1056 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
1057 buf->Init(20);
1058 std::vector<uint8_t> numbers;
1059 for (int i = 0; i < 10; i++) {
1060 numbers.push_back(i);
1061 }
1062 unsigned int offset = 0;
1063 unsigned int end = 10;
1064 buf->FillNumber(numbers, offset, end);
1065 uint8_t data[20] = {0};
1066 buf->ReadBytes(data, offset, end);
1067 for (int j = 0; j < 10; j++) {
1068 ASSERT_EQ(data[j], j);
1069 }
1070 }
1071
1072 /**
1073 * @tc.name: FillStringTest001
1074 * @tc.desc: Fill the buffer with the string
1075 * @tc.type: FUNC
1076 * @tc.require:issueI5J5Z3
1077 */
1078 HWTEST_F(NativeEngineTest, FillStringTest001, testing::ext::TestSize.Level0)
1079 {
1080 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
1081 buf->Init(20);
1082 std::string value = "abcd";
1083 std::string encoding = "ascii";
1084 buf->FillString(value, 1, 1, encoding);
1085
1086 unsigned int offset = 0;
1087 unsigned int end = 10;
1088 buf->FillString(value, offset, end, encoding);
1089 uint8_t data[20] = {0};
1090 buf->ReadBytes(data, offset, end);
1091 ASSERT_STREQ(reinterpret_cast<char*>(data), "abcdabcdab");
1092 }
1093
1094 /**
1095 * @tc.name: FillStringTest002
1096 * @tc.desc: Fill the buffer with the string
1097 * @tc.type: FUNC
1098 * @tc.require:issueI5J5Z3
1099 */
1100 HWTEST_F(NativeEngineTest, FillStringTest002, testing::ext::TestSize.Level0)
1101 {
1102 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
1103 buf->Init(20);
1104 std::string value = "扡摣";
1105 unsigned int offset = 0;
1106 unsigned int end = 10;
1107 std::string encoding = "utf16le";
1108 buf->FillString(value, offset, end, encoding);
1109 uint8_t data[20] = {0};
1110 buf->ReadBytes(data, offset, end);
1111 ASSERT_STREQ(reinterpret_cast<char*>(data), "abcdabcdab");
1112 }
1113
1114 /**
1115 * @tc.name: FillStringTest003
1116 * @tc.desc: Fill the buffer with the string
1117 * @tc.type: FUNC
1118 * @tc.require:issueI5J5Z3
1119 */
1120 HWTEST_F(NativeEngineTest, FillStringTest003, testing::ext::TestSize.Level0)
1121 {
1122 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
1123 buf->Init(20);
1124 std::string value = "YWJjZA";
1125 unsigned int offset = 0;
1126 unsigned int end = 10;
1127 std::string encoding = "base64";
1128 buf->FillString(value, offset, end, encoding);
1129 uint8_t data[20] = {0};
1130 buf->ReadBytes(data, offset, end);
1131 ASSERT_STREQ(reinterpret_cast<char*>(data), "abcdabcdab");
1132 }
1133
1134 /**
1135 * @tc.name: BlobConstructorTest001
1136 * @tc.desc: Blob Constructor
1137 * @tc.type: FUNC
1138 * @tc.require:issueI5J5Z3
1139 */
1140 HWTEST_F(NativeEngineTest, BlobConstructorTest001, testing::ext::TestSize.Level0)
1141 {
1142 OHOS::buffer::Blob *blob = new OHOS::buffer::Blob();
1143 uint8_t data[4] = {1, 2, 3, 4};
1144 blob->Init(data, 4);
1145 ASSERT_EQ(blob->GetLength(), 4);
1146 }
1147
1148 /**
1149 * @tc.name: BlobConstructorTest002
1150 * @tc.desc: Blob Constructor
1151 * @tc.type: FUNC
1152 * @tc.require:issueI5J5Z3
1153 */
1154 HWTEST_F(NativeEngineTest, BlobConstructorTest002, testing::ext::TestSize.Level0)
1155 {
1156 OHOS::buffer::Blob *blob = new OHOS::buffer::Blob();
1157 uint8_t data[4] = {1, 2, 3, 4};
1158 blob->Init(data, 4);
1159
1160 OHOS::buffer::Blob *blob2 = new OHOS::buffer::Blob();
1161 blob2->Init(blob, 0);
1162
1163 ASSERT_EQ(blob2->GetLength(), 4);
1164 }
1165
1166 /**
1167 * @tc.name: BlobConstructorTest003
1168 * @tc.desc: Blob Constructor
1169 * @tc.type: FUNC
1170 * @tc.require:issueI5J5Z3
1171 */
1172 HWTEST_F(NativeEngineTest, BlobConstructorTest003, testing::ext::TestSize.Level0)
1173 {
1174 OHOS::buffer::Blob *blob = new OHOS::buffer::Blob();
1175 uint8_t data[4] = {1, 2, 3, 4};
1176 blob->Init(data, 4);
1177
1178 OHOS::buffer::Blob *blob2 = new OHOS::buffer::Blob();
1179 blob2->Init(blob, 1, 4);
1180
1181 ASSERT_EQ(blob2->GetLength(), 3);
1182 }
1183
1184 /**
1185 * @tc.name: BlobConstructorTest004
1186 * @tc.desc: Blob Constructor
1187 * @tc.type: FUNC
1188 * @tc.require:issueI5J5Z3
1189 */
1190 HWTEST_F(NativeEngineTest, BlobConstructorTest004, testing::ext::TestSize.Level0)
1191 {
1192 OHOS::buffer::Blob *blob = new OHOS::buffer::Blob();
1193 uint8_t data[1] = {1};
1194 OHOS::buffer::Blob *blob1 = new OHOS::buffer::Blob();
1195 blob->Init(blob1, 1, 0);
1196 blob->Init(blob1, 1, -1);
1197 blob->Init(blob1, -1, 1);
1198 blob->Init(nullptr, 0, 1);
1199 blob->Init(data, 1);
1200 ASSERT_EQ(blob->GetLength(), 1);
1201 delete blob;
1202 blob = nullptr;
1203 delete blob1;
1204 blob1 = nullptr;
1205 }
1206
1207 /**
1208 * @tc.name: BlobDestructorTest001
1209 * @tc.desc: Blob Destructor.
1210 * @tc.type: FUNC
1211 * @tc.require:issueI5J5Z3
1212 */
1213 HWTEST_F(NativeEngineTest, BlobDestructorTest001, testing::ext::TestSize.Level0)
1214 {
1215 OHOS::buffer::Blob *blob = new OHOS::buffer::Blob();
1216 uint8_t data[4] = {1, 2, 3, 4};
1217 blob->Init(data, 4);
1218 unsigned int len = blob->GetLength();
1219 ASSERT_EQ(len, 4);
1220 delete blob;
1221 blob = nullptr;
1222 }
1223
1224 /**
1225 * @tc.name: BlobGetByteTest001
1226 * @tc.desc: Get a byte in blob
1227 * @tc.type: FUNC
1228 * @tc.require:issueI5J5Z3
1229 */
1230 HWTEST_F(NativeEngineTest, BlobGetByteTest001, testing::ext::TestSize.Level0)
1231 {
1232 OHOS::buffer::Blob *blob = new OHOS::buffer::Blob();
1233 uint8_t data[4] = {1, 2, 3, 4};
1234 blob->Init(data, 4);
1235
1236 uint8_t byte = blob->GetByte(2);
1237
1238 ASSERT_EQ(byte, 3);
1239 }
1240
1241 /**
1242 * @tc.name: BlobGetRawTest001
1243 * @tc.desc: Get the raw in blob
1244 * @tc.type: FUNC
1245 * @tc.require:issueI5J5Z3
1246 */
1247 HWTEST_F(NativeEngineTest, BlobGetRawTest001, testing::ext::TestSize.Level0)
1248 {
1249 OHOS::buffer::Blob *blob = new OHOS::buffer::Blob();
1250 uint8_t data[4] = {1, 2, 3, 4};
1251 blob->Init(data, 4);
1252
1253 uint8_t *raw = blob->GetRaw();
1254
1255 ASSERT_TRUE(raw != nullptr);
1256 }
1257
1258 /**
1259 * @tc.name: BlobGetLengthTest001
1260 * @tc.desc: Get the length in blob
1261 * @tc.type: FUNC
1262 * @tc.require:issueI5J5Z3
1263 */
1264 HWTEST_F(NativeEngineTest, BlobGetLengthTest001, testing::ext::TestSize.Level0)
1265 {
1266 OHOS::buffer::Blob *blob = new OHOS::buffer::Blob();
1267 uint8_t data[4] = {1, 2, 3, 4};
1268 blob->Init(data, 4);
1269
1270 unsigned int len = blob->GetLength();
1271
1272 ASSERT_EQ(len, 4);
1273 }
1274
1275 /**
1276 * @tc.name: BlobGetLengthTest001
1277 * @tc.desc: Read blob object bytes
1278 * @tc.type: FUNC
1279 * @tc.require:issueI5J5Z3
1280 */
1281 HWTEST_F(NativeEngineTest, BlobReadBytesTest001, testing::ext::TestSize.Level0)
1282 {
1283 OHOS::buffer::Blob *blob = new OHOS::buffer::Blob();
1284 uint8_t data[10] = {0};
1285 for (int i = 0; i < 10; i++) {
1286 data[i] = i;
1287 }
1288 blob->Init(data, 10);
1289
1290 uint8_t dat[10] = {0};
1291 blob->ReadBytes(dat, 10);
1292
1293 for (int i = 0; i < 10; i++) {
1294 ASSERT_EQ(dat[i], i);
1295 }
1296 }
1297
1298 /**
1299 * @tc.name: Utf8ToUtf16BETest001
1300 * @tc.desc: convert utf8 bytes to utf16 bytes
1301 * @tc.type: FUNC
1302 * @tc.require:issueI5J5Z3
1303 */
1304 HWTEST_F(NativeEngineTest, Utf8ToUtf16BETest001, testing::ext::TestSize.Level0)
1305 {
1306 std::string str8 = "";
1307 // one byte
1308 str8.append(1, 0x41);
1309 // two bytes
1310 str8.append(1, 0xC3);
1311 str8.append(1, 0x84);
1312 // three bytes
1313 str8.append(1, 0xE5);
1314 str8.append(1, 0x88);
1315 str8.append(1, 0x98);
1316 // four bytes
1317 str8.append(1, 0xf0);
1318 str8.append(1, 0x9f);
1319 str8.append(1, 0x90);
1320 str8.append(1, 0x85);
1321
1322 // another four bytes
1323 str8.append(1, 0xf0);
1324 str8.append(1, 0x8f);
1325 str8.append(1, 0x90);
1326 str8.append(1, 0x85);
1327
1328 bool isOk = false;
1329 std::u16string str16 = OHOS::buffer::Utf8ToUtf16BE(str8, &isOk);
1330
1331 char16_t results[] = {0x41, 0xc4, 0x5218, 0xd83d, 0xdc05, 0xf405};
1332 for (int i = 0; i < 6; i++) {
1333 ASSERT_EQ(results[i], str16[i]);
1334 }
1335 }
1336
1337 /**
1338 * @tc.name: HexDecodeTest001
1339 * @tc.desc: decode a hex string
1340 * @tc.type: FUNC
1341 * @tc.require:issueI5J5Z3
1342 */
1343 HWTEST_F(NativeEngineTest, HexDecodeTest001, testing::ext::TestSize.Level0)
1344 {
1345 std::string ret = OHOS::buffer::HexDecode("313g");
1346 ASSERT_EQ(ret, "1");
1347 }
1348
1349 /**
1350 * @tc.name: Utf16BEToLETest001
1351 * @tc.desc: Utf16BEToLE
1352 * @tc.type: FUNC
1353 * @tc.require:issueI5J5Z3
1354 */
1355 HWTEST_F(NativeEngineTest, Utf16BEToLETest001, testing::ext::TestSize.Level0)
1356 {
1357 std::u16string wstrBE = u"\x0041\x0042\x0043";
1358 std::u16string re = OHOS::buffer::Utf16BEToLE(wstrBE);
1359 char16_t results[] = {0x4100, 0x4200, 0x4300};
1360 for (int i = 0; i < 3; i++) {
1361 ASSERT_EQ(results[i], re[i]);
1362 }
1363 }
1364
1365 /**
1366 * @tc.name: Base64EncodeTest001
1367 * @tc.desc: Base64 encode with max size_t
1368 * @tc.type: FUNC
1369 * @tc.require:issueI5J5Z3
1370 */
1371 HWTEST_F(NativeEngineTest, Base64EncodeTest001, testing::ext::TestSize.Level0)
1372 {
1373 unsigned char data[] = {0x1A, 0x2B, 0x3C, 0x4D};
1374 size_t len = std::numeric_limits<size_t>::max();
1375 std::string stra = OHOS::buffer::Base64Encode(data, len, OHOS::buffer::BASE64URL);
1376 ASSERT_EQ(stra, "");
1377 }
1378
1379 /**
1380 * @tc.name: Base64EncodeTest002
1381 * @tc.desc: Base64 encode
1382 * @tc.type: FUNC
1383 * @tc.require:issueI5J5Z3
1384 */
1385 HWTEST_F(NativeEngineTest, Base64EncodeTest002, testing::ext::TestSize.Level0)
1386 {
1387 std::string value = "abc";
1388 std::string strb = OHOS::buffer::Base64Decode(value, OHOS::buffer::BASE64URL);
1389
1390 unsigned char data[] = {0x1A, 0x2B, 0x3C, 0x4D};
1391 std::string stra = OHOS::buffer::Base64Encode(data, 4, OHOS::buffer::BASE64URL);
1392 ASSERT_EQ(stra, "Gis8TQ");
1393 }
1394
1395 /**
1396 * @tc.name: GetGoodSuffixLengthByLastCharTest001
1397 * @tc.desc: Get good suffix length by last char
1398 * @tc.type: FUNC
1399 * @tc.require:issueI5J5Z3
1400 */
1401 HWTEST_F(NativeEngineTest, GetGoodSuffixLengthByLastCharTest001, testing::ext::TestSize.Level0)
1402 {
1403 uint8_t pat[] = "ababcab";
1404 int patLen = sizeof(pat) - 1;
1405 int patIndex = 4;
1406
1407 int length = OHOS::buffer::GetGoodSuffixLengthByLastChar(pat, patIndex, patLen);
1408 ASSERT_EQ(length, 3);
1409 }
1410
1411 /**
1412 * @tc.name: FindLastIndexTest001
1413 * @tc.desc: Find last index with error
1414 * @tc.type: FUNC
1415 * @tc.require:issueI5J5Z3
1416 */
1417 HWTEST_F(NativeEngineTest, FindLastIndexTest001, testing::ext::TestSize.Level0)
1418 {
1419 int rel1 = OHOS::buffer::FindLastIndex(nullptr, nullptr, 2, 1);
1420 ASSERT_EQ(rel1, -1);
1421
1422 uint8_t data[] = "abc";
1423 int rel2 = OHOS::buffer::FindLastIndex(data, data, 2, 0);
1424 ASSERT_EQ(rel2, -1);
1425 }
1426
1427 /**
1428 * @tc.name: FindIndex005
1429 * @tc.desc: Find index with error.
1430 * @tc.type: FUNC
1431 * @tc.require:issueI5J5Z3
1432 */
1433 HWTEST_F(NativeEngineTest, FindIndex005, testing::ext::TestSize.Level0)
1434 {
1435 int rel1 = OHOS::buffer::FindIndex(nullptr, nullptr, 2, 1);
1436 ASSERT_EQ(rel1, -1);
1437
1438 uint8_t data[] = "abc";
1439 int rel2 = OHOS::buffer::FindIndex(data, data, 2, 0);
1440 ASSERT_EQ(rel2, -1);
1441 }
1442
1443 /**
1444 * @tc.name: FindIndex001
1445 * @tc.desc: Buffer FindIndex.
1446 * @tc.type: FUNC
1447 * @tc.require:issueI5J5Z3
1448 */
1449 HWTEST_F(NativeEngineTest, FindIndex001, testing::ext::TestSize.Level0)
1450 {
1451 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
1452 buf->Init(15);
1453 buf->WriteString("This is a buffer", 15);
1454 uint64_t resultIndex = 0;
1455 int index = buf->IndexOf("2623", 0, 4, resultIndex);
1456 ASSERT_EQ(index, -1);
1457 }
1458
1459 /**
1460 * @tc.name: FindIndex002
1461 * @tc.desc: Buffer FindIndex.
1462 * @tc.type: FUNC
1463 * @tc.require:issueI5J5Z3
1464 */
1465 HWTEST_F(NativeEngineTest, FindIndex002, testing::ext::TestSize.Level0)
1466 {
1467 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
1468 buf->Init(15);
1469 buf->WriteString("This is a buffer", 15);
1470 uint64_t resultIndex = 0;
1471 int index = buf->IndexOf("f", 0, 1, resultIndex);
1472 ASSERT_EQ(index, -2);
1473 ASSERT_EQ(resultIndex, 12);
1474 }
1475
1476 /**
1477 * @tc.name: FindIndex003
1478 * @tc.desc: Buffer FindIndex.
1479 * @tc.type: FUNC
1480 * @tc.require:issueI5J5Z3
1481 */
1482 HWTEST_F(NativeEngineTest, FindIndex003, testing::ext::TestSize.Level0)
1483 {
1484 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
1485 buf->Init(15);
1486 buf->WriteString("23456789abcdefg", 15);
1487 uint64_t resultIndex = 0;
1488 int index = buf->IndexOf("3", 0, 1, resultIndex);
1489 ASSERT_EQ(index, -2);
1490 ASSERT_EQ(resultIndex, 1);
1491 }
1492
1493 /**
1494 * @tc.name: FindIndex004
1495 * @tc.desc: Buffer FindIndex.
1496 * @tc.type: FUNC
1497 * @tc.require:issueI5J5Z3
1498 */
1499 HWTEST_F(NativeEngineTest, FindIndex004, testing::ext::TestSize.Level0)
1500 {
1501 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
1502 buf->Init(15);
1503 buf->WriteString("23456789abcdefg", 15);
1504 uint64_t resultIndex = 0;
1505 int index = buf->IndexOf("3", 10, 1, resultIndex);
1506 ASSERT_EQ(index, -1);
1507 }
1508
1509 /**
1510 * @tc.name: BlobGetLengthTest002
1511 * @tc.desc: Get the length in blob
1512 * @tc.type: FUNC
1513 * @tc.require:issueI5J5Z3
1514 */
1515 HWTEST_F(NativeEngineTest, BlobGetLengthTest002, testing::ext::TestSize.Level0)
1516 {
1517 OHOS::buffer::Blob *blob = new OHOS::buffer::Blob();
1518 uint8_t data[5] = {'a', 'b', 'c', 'd', 'e'};
1519 blob->Init(data, 5);
1520 unsigned int len = blob->GetLength();
1521 ASSERT_EQ(len, 5);
1522 }
1523
1524 /**
1525 * @tc.name: BlobGetByteTest002
1526 * @tc.desc: Get a byte in blob
1527 * @tc.type: FUNC
1528 * @tc.require:issueI5J5Z3
1529 */
1530 HWTEST_F(NativeEngineTest, BlobGetByteTest002, testing::ext::TestSize.Level0)
1531 {
1532 OHOS::buffer::Blob *blob = new OHOS::buffer::Blob();
1533 uint8_t data[5] = {'a', 'b', 'c', 'd', 'e'};
1534 blob->Init(data, 5);
1535 uint8_t byte = blob->GetByte(2);
1536 ASSERT_EQ(byte, 99);
1537 }
1538
1539 /**
1540 * @tc.name: GetLength001
1541 * @tc.desc: Buffer GetLength001.
1542 * @tc.type: FUNC
1543 * @tc.require:issueI5J5Z3
1544 */
1545 HWTEST_F(NativeEngineTest, GetLength001, testing::ext::TestSize.Level0)
1546 {
1547 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
1548 uint32_t size = 0;
1549 buf->Init(size);
1550 unsigned int len = buf->GetLength();
1551 ASSERT_EQ(len, 0);
1552 }
1553
1554 /**
1555 * @tc.name: GetLength002
1556 * @tc.desc: Buffer GetLength002.
1557 * @tc.type: FUNC
1558 * @tc.require:issueI5J5Z3
1559 */
1560 HWTEST_F(NativeEngineTest, GetLength002, testing::ext::TestSize.Level0)
1561 {
1562 OHOS::buffer::Buffer *buf = new OHOS::buffer::Buffer();
1563 uint32_t size = 3;
1564 buf->Init(size);
1565 unsigned int len = buf->GetLength();
1566 ASSERT_EQ(len, 3);
1567 }