1 /* 2 * Copyright (c) 2025 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 #include <codecvt> 18 19 #include "commonlibrary/ets_utils/js_util_module/util/js_uuid.h" 20 #include "ohos/init_data.h" 21 #include "tools/log.h" 22 #include "napi/native_api.h" 23 #include "napi/native_node_api.h" 24 #include "securec.h" 25 26 /* @tc.name: DoParseUUIDTest005 27 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 28 * @tc.type: FUNC 29 */ 30 HWTEST_F(NativeEngineTest, DoParseUUIDTest005, testing::ext::TestSize.Level0) 31 { 32 napi_env env = (napi_env)engine_; 33 napi_value src = nullptr; 34 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100005", NAPI_AUTO_LENGTH, &src); 35 napi_value arr = OHOS::Util::DoParseUUID(env, src); 36 napi_typedarray_type type = napi_int8_array; 37 size_t byteOffset = 0; 38 size_t length = 0; 39 void* resultData = nullptr; 40 napi_value resultBuffer = nullptr; 41 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 42 ASSERT_EQ(length, 16); 43 } 44 45 /* @tc.name: DoParseUUIDTest006 46 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 47 * @tc.type: FUNC 48 */ 49 HWTEST_F(NativeEngineTest, DoParseUUIDTest006, testing::ext::TestSize.Level0) 50 { 51 napi_env env = (napi_env)engine_; 52 napi_value src = nullptr; 53 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100006", NAPI_AUTO_LENGTH, &src); 54 napi_value arr = OHOS::Util::DoParseUUID(env, src); 55 napi_typedarray_type type = napi_int8_array; 56 size_t byteOffset = 0; 57 size_t length = 0; 58 void* resultData = nullptr; 59 napi_value resultBuffer = nullptr; 60 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 61 ASSERT_EQ(length, 16); 62 } 63 64 /* @tc.name: DoParseUUIDTest007 65 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 66 * @tc.type: FUNC 67 */ 68 HWTEST_F(NativeEngineTest, DoParseUUIDTest007, testing::ext::TestSize.Level0) 69 { 70 napi_env env = (napi_env)engine_; 71 napi_value src = nullptr; 72 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100007", NAPI_AUTO_LENGTH, &src); 73 napi_value arr = OHOS::Util::DoParseUUID(env, src); 74 napi_typedarray_type type = napi_int8_array; 75 size_t byteOffset = 0; 76 size_t length = 0; 77 void* resultData = nullptr; 78 napi_value resultBuffer = nullptr; 79 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 80 ASSERT_EQ(length, 16); 81 } 82 83 /* @tc.name: DoParseUUIDTest008 84 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 85 * @tc.type: FUNC 86 */ 87 HWTEST_F(NativeEngineTest, DoParseUUIDTest008, testing::ext::TestSize.Level0) 88 { 89 napi_env env = (napi_env)engine_; 90 napi_value src = nullptr; 91 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100008", NAPI_AUTO_LENGTH, &src); 92 napi_value arr = OHOS::Util::DoParseUUID(env, src); 93 napi_typedarray_type type = napi_int8_array; 94 size_t byteOffset = 0; 95 size_t length = 0; 96 void* resultData = nullptr; 97 napi_value resultBuffer = nullptr; 98 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 99 ASSERT_EQ(length, 16); 100 } 101 102 /* @tc.name: DoParseUUIDTest009 103 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 104 * @tc.type: FUNC 105 */ 106 HWTEST_F(NativeEngineTest, DoParseUUIDTest009, testing::ext::TestSize.Level0) 107 { 108 napi_env env = (napi_env)engine_; 109 napi_value src = nullptr; 110 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100009", NAPI_AUTO_LENGTH, &src); 111 napi_value arr = OHOS::Util::DoParseUUID(env, src); 112 napi_typedarray_type type = napi_int8_array; 113 size_t byteOffset = 0; 114 size_t length = 0; 115 void* resultData = nullptr; 116 napi_value resultBuffer = nullptr; 117 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 118 ASSERT_EQ(length, 16); 119 } 120 121 /* @tc.name: DoParseUUIDTest010 122 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 123 * @tc.type: FUNC 124 */ 125 HWTEST_F(NativeEngineTest, DoParseUUIDTest010, testing::ext::TestSize.Level0) 126 { 127 napi_env env = (napi_env)engine_; 128 napi_value src = nullptr; 129 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100010", NAPI_AUTO_LENGTH, &src); 130 napi_value arr = OHOS::Util::DoParseUUID(env, src); 131 napi_typedarray_type type = napi_int8_array; 132 size_t byteOffset = 0; 133 size_t length = 0; 134 void* resultData = nullptr; 135 napi_value resultBuffer = nullptr; 136 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 137 ASSERT_EQ(length, 16); 138 } 139 140 /* @tc.name: DoParseUUIDTest011 141 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 142 * @tc.type: FUNC 143 */ 144 HWTEST_F(NativeEngineTest, DoParseUUIDTest011, testing::ext::TestSize.Level0) 145 { 146 napi_env env = (napi_env)engine_; 147 napi_value src = nullptr; 148 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100011", NAPI_AUTO_LENGTH, &src); 149 napi_value arr = OHOS::Util::DoParseUUID(env, src); 150 napi_typedarray_type type = napi_int8_array; 151 size_t byteOffset = 0; 152 size_t length = 0; 153 void* resultData = nullptr; 154 napi_value resultBuffer = nullptr; 155 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 156 ASSERT_EQ(length, 16); 157 } 158 159 /* @tc.name: DoParseUUIDTest012 160 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 161 * @tc.type: FUNC 162 */ 163 HWTEST_F(NativeEngineTest, DoParseUUIDTest012, testing::ext::TestSize.Level0) 164 { 165 napi_env env = (napi_env)engine_; 166 napi_value src = nullptr; 167 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100012", NAPI_AUTO_LENGTH, &src); 168 napi_value arr = OHOS::Util::DoParseUUID(env, src); 169 napi_typedarray_type type = napi_int8_array; 170 size_t byteOffset = 0; 171 size_t length = 0; 172 void* resultData = nullptr; 173 napi_value resultBuffer = nullptr; 174 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 175 ASSERT_EQ(length, 16); 176 } 177 178 /* @tc.name: DoParseUUIDTest013 179 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 180 * @tc.type: FUNC 181 */ 182 HWTEST_F(NativeEngineTest, DoParseUUIDTest013, testing::ext::TestSize.Level0) 183 { 184 napi_env env = (napi_env)engine_; 185 napi_value src = nullptr; 186 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100013", NAPI_AUTO_LENGTH, &src); 187 napi_value arr = OHOS::Util::DoParseUUID(env, src); 188 napi_typedarray_type type = napi_int8_array; 189 size_t byteOffset = 0; 190 size_t length = 0; 191 void* resultData = nullptr; 192 napi_value resultBuffer = nullptr; 193 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 194 ASSERT_EQ(length, 16); 195 } 196 197 /* @tc.name: DoParseUUIDTest014 198 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 199 * @tc.type: FUNC 200 */ 201 HWTEST_F(NativeEngineTest, DoParseUUIDTest014, testing::ext::TestSize.Level0) 202 { 203 napi_env env = (napi_env)engine_; 204 napi_value src = nullptr; 205 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100014", NAPI_AUTO_LENGTH, &src); 206 napi_value arr = OHOS::Util::DoParseUUID(env, src); 207 napi_typedarray_type type = napi_int8_array; 208 size_t byteOffset = 0; 209 size_t length = 0; 210 void* resultData = nullptr; 211 napi_value resultBuffer = nullptr; 212 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 213 ASSERT_EQ(length, 16); 214 } 215 216 /* @tc.name: DoParseUUIDTest015 217 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 218 * @tc.type: FUNC 219 */ 220 HWTEST_F(NativeEngineTest, DoParseUUIDTest015, testing::ext::TestSize.Level0) 221 { 222 napi_env env = (napi_env)engine_; 223 napi_value src = nullptr; 224 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100015", NAPI_AUTO_LENGTH, &src); 225 napi_value arr = OHOS::Util::DoParseUUID(env, src); 226 napi_typedarray_type type = napi_int8_array; 227 size_t byteOffset = 0; 228 size_t length = 0; 229 void* resultData = nullptr; 230 napi_value resultBuffer = nullptr; 231 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 232 ASSERT_EQ(length, 16); 233 } 234 235 /* @tc.name: DoParseUUIDTest016 236 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 237 * @tc.type: FUNC 238 */ 239 HWTEST_F(NativeEngineTest, DoParseUUIDTest016, testing::ext::TestSize.Level0) 240 { 241 napi_env env = (napi_env)engine_; 242 napi_value src = nullptr; 243 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100016", NAPI_AUTO_LENGTH, &src); 244 napi_value arr = OHOS::Util::DoParseUUID(env, src); 245 napi_typedarray_type type = napi_int8_array; 246 size_t byteOffset = 0; 247 size_t length = 0; 248 void* resultData = nullptr; 249 napi_value resultBuffer = nullptr; 250 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 251 ASSERT_EQ(length, 16); 252 } 253 254 /* @tc.name: DoParseUUIDTest017 255 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 256 * @tc.type: FUNC 257 */ 258 HWTEST_F(NativeEngineTest, DoParseUUIDTest017, testing::ext::TestSize.Level0) 259 { 260 napi_env env = (napi_env)engine_; 261 napi_value src = nullptr; 262 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100017", NAPI_AUTO_LENGTH, &src); 263 napi_value arr = OHOS::Util::DoParseUUID(env, src); 264 napi_typedarray_type type = napi_int8_array; 265 size_t byteOffset = 0; 266 size_t length = 0; 267 void* resultData = nullptr; 268 napi_value resultBuffer = nullptr; 269 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 270 ASSERT_EQ(length, 16); 271 } 272 273 /* @tc.name: DoParseUUIDTest018 274 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 275 * @tc.type: FUNC 276 */ 277 HWTEST_F(NativeEngineTest, DoParseUUIDTest018, testing::ext::TestSize.Level0) 278 { 279 napi_env env = (napi_env)engine_; 280 napi_value src = nullptr; 281 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100018", NAPI_AUTO_LENGTH, &src); 282 napi_value arr = OHOS::Util::DoParseUUID(env, src); 283 napi_typedarray_type type = napi_int8_array; 284 size_t byteOffset = 0; 285 size_t length = 0; 286 void* resultData = nullptr; 287 napi_value resultBuffer = nullptr; 288 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 289 ASSERT_EQ(length, 16); 290 } 291 292 /* @tc.name: DoParseUUIDTest019 293 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 294 * @tc.type: FUNC 295 */ 296 HWTEST_F(NativeEngineTest, DoParseUUIDTest019, testing::ext::TestSize.Level0) 297 { 298 napi_env env = (napi_env)engine_; 299 napi_value src = nullptr; 300 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100019", NAPI_AUTO_LENGTH, &src); 301 napi_value arr = OHOS::Util::DoParseUUID(env, src); 302 napi_typedarray_type type = napi_int8_array; 303 size_t byteOffset = 0; 304 size_t length = 0; 305 void* resultData = nullptr; 306 napi_value resultBuffer = nullptr; 307 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 308 ASSERT_EQ(length, 16); 309 } 310 311 /* @tc.name: DoParseUUIDTest020 312 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 313 * @tc.type: FUNC 314 */ 315 HWTEST_F(NativeEngineTest, DoParseUUIDTest020, testing::ext::TestSize.Level0) 316 { 317 napi_env env = (napi_env)engine_; 318 napi_value src = nullptr; 319 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100020", NAPI_AUTO_LENGTH, &src); 320 napi_value arr = OHOS::Util::DoParseUUID(env, src); 321 napi_typedarray_type type = napi_int8_array; 322 size_t byteOffset = 0; 323 size_t length = 0; 324 void* resultData = nullptr; 325 napi_value resultBuffer = nullptr; 326 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 327 ASSERT_EQ(length, 16); 328 } 329 330 /* @tc.name: DoParseUUIDTest021 331 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 332 * @tc.type: FUNC 333 */ 334 HWTEST_F(NativeEngineTest, DoParseUUIDTest021, testing::ext::TestSize.Level0) 335 { 336 napi_env env = (napi_env)engine_; 337 napi_value src = nullptr; 338 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100021", NAPI_AUTO_LENGTH, &src); 339 napi_value arr = OHOS::Util::DoParseUUID(env, src); 340 napi_typedarray_type type = napi_int8_array; 341 size_t byteOffset = 0; 342 size_t length = 0; 343 void* resultData = nullptr; 344 napi_value resultBuffer = nullptr; 345 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 346 ASSERT_EQ(length, 16); 347 } 348 349 /* @tc.name: DoParseUUIDTest022 350 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 351 * @tc.type: FUNC 352 */ 353 HWTEST_F(NativeEngineTest, DoParseUUIDTest022, testing::ext::TestSize.Level0) 354 { 355 napi_env env = (napi_env)engine_; 356 napi_value src = nullptr; 357 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100022", NAPI_AUTO_LENGTH, &src); 358 napi_value arr = OHOS::Util::DoParseUUID(env, src); 359 napi_typedarray_type type = napi_int8_array; 360 size_t byteOffset = 0; 361 size_t length = 0; 362 void* resultData = nullptr; 363 napi_value resultBuffer = nullptr; 364 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 365 ASSERT_EQ(length, 16); 366 } 367 368 /* @tc.name: DoParseUUIDTest023 369 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 370 * @tc.type: FUNC 371 */ 372 HWTEST_F(NativeEngineTest, DoParseUUIDTest023, testing::ext::TestSize.Level0) 373 { 374 napi_env env = (napi_env)engine_; 375 napi_value src = nullptr; 376 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100023", NAPI_AUTO_LENGTH, &src); 377 napi_value arr = OHOS::Util::DoParseUUID(env, src); 378 napi_typedarray_type type = napi_int8_array; 379 size_t byteOffset = 0; 380 size_t length = 0; 381 void* resultData = nullptr; 382 napi_value resultBuffer = nullptr; 383 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 384 ASSERT_EQ(length, 16); 385 } 386 387 /* @tc.name: DoParseUUIDTest024 388 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 389 * @tc.type: FUNC 390 */ 391 HWTEST_F(NativeEngineTest, DoParseUUIDTest024, testing::ext::TestSize.Level0) 392 { 393 napi_env env = (napi_env)engine_; 394 napi_value src = nullptr; 395 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100024", NAPI_AUTO_LENGTH, &src); 396 napi_value arr = OHOS::Util::DoParseUUID(env, src); 397 napi_typedarray_type type = napi_int8_array; 398 size_t byteOffset = 0; 399 size_t length = 0; 400 void* resultData = nullptr; 401 napi_value resultBuffer = nullptr; 402 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 403 ASSERT_EQ(length, 16); 404 } 405 406 /* @tc.name: DoParseUUIDTest025 407 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 408 * @tc.type: FUNC 409 */ 410 HWTEST_F(NativeEngineTest, DoParseUUIDTest025, testing::ext::TestSize.Level0) 411 { 412 napi_env env = (napi_env)engine_; 413 napi_value src = nullptr; 414 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100025", NAPI_AUTO_LENGTH, &src); 415 napi_value arr = OHOS::Util::DoParseUUID(env, src); 416 napi_typedarray_type type = napi_int8_array; 417 size_t byteOffset = 0; 418 size_t length = 0; 419 void* resultData = nullptr; 420 napi_value resultBuffer = nullptr; 421 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 422 ASSERT_EQ(length, 16); 423 } 424 425 /* @tc.name: DoParseUUIDTest026 426 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 427 * @tc.type: FUNC 428 */ 429 HWTEST_F(NativeEngineTest, DoParseUUIDTest026, testing::ext::TestSize.Level0) 430 { 431 napi_env env = (napi_env)engine_; 432 napi_value src = nullptr; 433 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100026", NAPI_AUTO_LENGTH, &src); 434 napi_value arr = OHOS::Util::DoParseUUID(env, src); 435 napi_typedarray_type type = napi_int8_array; 436 size_t byteOffset = 0; 437 size_t length = 0; 438 void* resultData = nullptr; 439 napi_value resultBuffer = nullptr; 440 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 441 ASSERT_EQ(length, 16); 442 } 443 444 /* @tc.name: DoParseUUIDTest027 445 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 446 * @tc.type: FUNC 447 */ 448 HWTEST_F(NativeEngineTest, DoParseUUIDTest027, testing::ext::TestSize.Level0) 449 { 450 napi_env env = (napi_env)engine_; 451 napi_value src = nullptr; 452 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100027", NAPI_AUTO_LENGTH, &src); 453 napi_value arr = OHOS::Util::DoParseUUID(env, src); 454 napi_typedarray_type type = napi_int8_array; 455 size_t byteOffset = 0; 456 size_t length = 0; 457 void* resultData = nullptr; 458 napi_value resultBuffer = nullptr; 459 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 460 ASSERT_EQ(length, 16); 461 } 462 463 /* @tc.name: DoParseUUIDTest028 464 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 465 * @tc.type: FUNC 466 */ 467 HWTEST_F(NativeEngineTest, DoParseUUIDTest028, testing::ext::TestSize.Level0) 468 { 469 napi_env env = (napi_env)engine_; 470 napi_value src = nullptr; 471 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100028", NAPI_AUTO_LENGTH, &src); 472 napi_value arr = OHOS::Util::DoParseUUID(env, src); 473 napi_typedarray_type type = napi_int8_array; 474 size_t byteOffset = 0; 475 size_t length = 0; 476 void* resultData = nullptr; 477 napi_value resultBuffer = nullptr; 478 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 479 ASSERT_EQ(length, 16); 480 } 481 482 /* @tc.name: DoParseUUIDTest029 483 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 484 * @tc.type: FUNC 485 */ 486 HWTEST_F(NativeEngineTest, DoParseUUIDTest029, testing::ext::TestSize.Level0) 487 { 488 napi_env env = (napi_env)engine_; 489 napi_value src = nullptr; 490 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100029", NAPI_AUTO_LENGTH, &src); 491 napi_value arr = OHOS::Util::DoParseUUID(env, src); 492 napi_typedarray_type type = napi_int8_array; 493 size_t byteOffset = 0; 494 size_t length = 0; 495 void* resultData = nullptr; 496 napi_value resultBuffer = nullptr; 497 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 498 ASSERT_EQ(length, 16); 499 } 500 501 /* @tc.name: DoParseUUIDTest030 502 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 503 * @tc.type: FUNC 504 */ 505 HWTEST_F(NativeEngineTest, DoParseUUIDTest030, testing::ext::TestSize.Level0) 506 { 507 napi_env env = (napi_env)engine_; 508 napi_value src = nullptr; 509 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100030", NAPI_AUTO_LENGTH, &src); 510 napi_value arr = OHOS::Util::DoParseUUID(env, src); 511 napi_typedarray_type type = napi_int8_array; 512 size_t byteOffset = 0; 513 size_t length = 0; 514 void* resultData = nullptr; 515 napi_value resultBuffer = nullptr; 516 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 517 ASSERT_EQ(length, 16); 518 } 519 520 /* @tc.name: DoParseUUIDTest031 521 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 522 * @tc.type: FUNC 523 */ 524 HWTEST_F(NativeEngineTest, DoParseUUIDTest031, testing::ext::TestSize.Level0) 525 { 526 napi_env env = (napi_env)engine_; 527 napi_value src = nullptr; 528 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100031", NAPI_AUTO_LENGTH, &src); 529 napi_value arr = OHOS::Util::DoParseUUID(env, src); 530 napi_typedarray_type type = napi_int8_array; 531 size_t byteOffset = 0; 532 size_t length = 0; 533 void* resultData = nullptr; 534 napi_value resultBuffer = nullptr; 535 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 536 ASSERT_EQ(length, 16); 537 } 538 539 /* @tc.name: DoParseUUIDTest032 540 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 541 * @tc.type: FUNC 542 */ 543 HWTEST_F(NativeEngineTest, DoParseUUIDTest032, testing::ext::TestSize.Level0) 544 { 545 napi_env env = (napi_env)engine_; 546 napi_value src = nullptr; 547 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100032", NAPI_AUTO_LENGTH, &src); 548 napi_value arr = OHOS::Util::DoParseUUID(env, src); 549 napi_typedarray_type type = napi_int8_array; 550 size_t byteOffset = 0; 551 size_t length = 0; 552 void* resultData = nullptr; 553 napi_value resultBuffer = nullptr; 554 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 555 ASSERT_EQ(length, 16); 556 } 557 558 /* @tc.name: DoParseUUIDTest033 559 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 560 * @tc.type: FUNC 561 */ 562 HWTEST_F(NativeEngineTest, DoParseUUIDTest033, testing::ext::TestSize.Level0) 563 { 564 napi_env env = (napi_env)engine_; 565 napi_value src = nullptr; 566 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100033", NAPI_AUTO_LENGTH, &src); 567 napi_value arr = OHOS::Util::DoParseUUID(env, src); 568 napi_typedarray_type type = napi_int8_array; 569 size_t byteOffset = 0; 570 size_t length = 0; 571 void* resultData = nullptr; 572 napi_value resultBuffer = nullptr; 573 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 574 ASSERT_EQ(length, 16); 575 } 576 577 /* @tc.name: DoParseUUIDTest034 578 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 579 * @tc.type: FUNC 580 */ 581 HWTEST_F(NativeEngineTest, DoParseUUIDTest034, testing::ext::TestSize.Level0) 582 { 583 napi_env env = (napi_env)engine_; 584 napi_value src = nullptr; 585 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100034", NAPI_AUTO_LENGTH, &src); 586 napi_value arr = OHOS::Util::DoParseUUID(env, src); 587 napi_typedarray_type type = napi_int8_array; 588 size_t byteOffset = 0; 589 size_t length = 0; 590 void* resultData = nullptr; 591 napi_value resultBuffer = nullptr; 592 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 593 ASSERT_EQ(length, 16); 594 } 595 596 /* @tc.name: DoParseUUIDTest035 597 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 598 * @tc.type: FUNC 599 */ 600 HWTEST_F(NativeEngineTest, DoParseUUIDTest035, testing::ext::TestSize.Level0) 601 { 602 napi_env env = (napi_env)engine_; 603 napi_value src = nullptr; 604 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100035", NAPI_AUTO_LENGTH, &src); 605 napi_value arr = OHOS::Util::DoParseUUID(env, src); 606 napi_typedarray_type type = napi_int8_array; 607 size_t byteOffset = 0; 608 size_t length = 0; 609 void* resultData = nullptr; 610 napi_value resultBuffer = nullptr; 611 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 612 ASSERT_EQ(length, 16); 613 } 614 615 /* @tc.name: DoParseUUIDTest036 616 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 617 * @tc.type: FUNC 618 */ 619 HWTEST_F(NativeEngineTest, DoParseUUIDTest036, testing::ext::TestSize.Level0) 620 { 621 napi_env env = (napi_env)engine_; 622 napi_value src = nullptr; 623 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100036", NAPI_AUTO_LENGTH, &src); 624 napi_value arr = OHOS::Util::DoParseUUID(env, src); 625 napi_typedarray_type type = napi_int8_array; 626 size_t byteOffset = 0; 627 size_t length = 0; 628 void* resultData = nullptr; 629 napi_value resultBuffer = nullptr; 630 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 631 ASSERT_EQ(length, 16); 632 } 633 634 /* @tc.name: DoParseUUIDTest037 635 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 636 * @tc.type: FUNC 637 */ 638 HWTEST_F(NativeEngineTest, DoParseUUIDTest037, testing::ext::TestSize.Level0) 639 { 640 napi_env env = (napi_env)engine_; 641 napi_value src = nullptr; 642 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100037", NAPI_AUTO_LENGTH, &src); 643 napi_value arr = OHOS::Util::DoParseUUID(env, src); 644 napi_typedarray_type type = napi_int8_array; 645 size_t byteOffset = 0; 646 size_t length = 0; 647 void* resultData = nullptr; 648 napi_value resultBuffer = nullptr; 649 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 650 ASSERT_EQ(length, 16); 651 } 652 653 /* @tc.name: DoParseUUIDTest038 654 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 655 * @tc.type: FUNC 656 */ 657 HWTEST_F(NativeEngineTest, DoParseUUIDTest038, testing::ext::TestSize.Level0) 658 { 659 napi_env env = (napi_env)engine_; 660 napi_value src = nullptr; 661 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100038", NAPI_AUTO_LENGTH, &src); 662 napi_value arr = OHOS::Util::DoParseUUID(env, src); 663 napi_typedarray_type type = napi_int8_array; 664 size_t byteOffset = 0; 665 size_t length = 0; 666 void* resultData = nullptr; 667 napi_value resultBuffer = nullptr; 668 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 669 ASSERT_EQ(length, 16); 670 } 671 672 /* @tc.name: DoParseUUIDTest039 673 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 674 * @tc.type: FUNC 675 */ 676 HWTEST_F(NativeEngineTest, DoParseUUIDTest039, testing::ext::TestSize.Level0) 677 { 678 napi_env env = (napi_env)engine_; 679 napi_value src = nullptr; 680 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100039", NAPI_AUTO_LENGTH, &src); 681 napi_value arr = OHOS::Util::DoParseUUID(env, src); 682 napi_typedarray_type type = napi_int8_array; 683 size_t byteOffset = 0; 684 size_t length = 0; 685 void* resultData = nullptr; 686 napi_value resultBuffer = nullptr; 687 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 688 ASSERT_EQ(length, 16); 689 } 690 691 /* @tc.name: DoParseUUIDTest040 692 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 693 * @tc.type: FUNC 694 */ 695 HWTEST_F(NativeEngineTest, DoParseUUIDTest040, testing::ext::TestSize.Level0) 696 { 697 napi_env env = (napi_env)engine_; 698 napi_value src = nullptr; 699 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100040", NAPI_AUTO_LENGTH, &src); 700 napi_value arr = OHOS::Util::DoParseUUID(env, src); 701 napi_typedarray_type type = napi_int8_array; 702 size_t byteOffset = 0; 703 size_t length = 0; 704 void* resultData = nullptr; 705 napi_value resultBuffer = nullptr; 706 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 707 ASSERT_EQ(length, 16); 708 } 709 710 /* @tc.name: DoParseUUIDTest041 711 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 712 * @tc.type: FUNC 713 */ 714 HWTEST_F(NativeEngineTest, DoParseUUIDTest041, testing::ext::TestSize.Level0) 715 { 716 napi_env env = (napi_env)engine_; 717 napi_value src = nullptr; 718 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100041", NAPI_AUTO_LENGTH, &src); 719 napi_value arr = OHOS::Util::DoParseUUID(env, src); 720 napi_typedarray_type type = napi_int8_array; 721 size_t byteOffset = 0; 722 size_t length = 0; 723 void* resultData = nullptr; 724 napi_value resultBuffer = nullptr; 725 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 726 ASSERT_EQ(length, 16); 727 } 728 729 /* @tc.name: DoParseUUIDTest042 730 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 731 * @tc.type: FUNC 732 */ 733 HWTEST_F(NativeEngineTest, DoParseUUIDTest042, testing::ext::TestSize.Level0) 734 { 735 napi_env env = (napi_env)engine_; 736 napi_value src = nullptr; 737 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100042", NAPI_AUTO_LENGTH, &src); 738 napi_value arr = OHOS::Util::DoParseUUID(env, src); 739 napi_typedarray_type type = napi_int8_array; 740 size_t byteOffset = 0; 741 size_t length = 0; 742 void* resultData = nullptr; 743 napi_value resultBuffer = nullptr; 744 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 745 ASSERT_EQ(length, 16); 746 } 747 748 /* @tc.name: DoParseUUIDTest043 749 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 750 * @tc.type: FUNC 751 */ 752 HWTEST_F(NativeEngineTest, DoParseUUIDTest043, testing::ext::TestSize.Level0) 753 { 754 napi_env env = (napi_env)engine_; 755 napi_value src = nullptr; 756 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100043", NAPI_AUTO_LENGTH, &src); 757 napi_value arr = OHOS::Util::DoParseUUID(env, src); 758 napi_typedarray_type type = napi_int8_array; 759 size_t byteOffset = 0; 760 size_t length = 0; 761 void* resultData = nullptr; 762 napi_value resultBuffer = nullptr; 763 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 764 ASSERT_EQ(length, 16); 765 } 766 767 /* @tc.name: DoParseUUIDTest044 768 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 769 * @tc.type: FUNC 770 */ 771 HWTEST_F(NativeEngineTest, DoParseUUIDTest044, testing::ext::TestSize.Level0) 772 { 773 napi_env env = (napi_env)engine_; 774 napi_value src = nullptr; 775 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100044", NAPI_AUTO_LENGTH, &src); 776 napi_value arr = OHOS::Util::DoParseUUID(env, src); 777 napi_typedarray_type type = napi_int8_array; 778 size_t byteOffset = 0; 779 size_t length = 0; 780 void* resultData = nullptr; 781 napi_value resultBuffer = nullptr; 782 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 783 ASSERT_EQ(length, 16); 784 } 785 786 /* @tc.name: DoParseUUIDTest045 787 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 788 * @tc.type: FUNC 789 */ 790 HWTEST_F(NativeEngineTest, DoParseUUIDTest045, testing::ext::TestSize.Level0) 791 { 792 napi_env env = (napi_env)engine_; 793 napi_value src = nullptr; 794 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100045", NAPI_AUTO_LENGTH, &src); 795 napi_value arr = OHOS::Util::DoParseUUID(env, src); 796 napi_typedarray_type type = napi_int8_array; 797 size_t byteOffset = 0; 798 size_t length = 0; 799 void* resultData = nullptr; 800 napi_value resultBuffer = nullptr; 801 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 802 ASSERT_EQ(length, 16); 803 } 804 805 /* @tc.name: DoParseUUIDTest046 806 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 807 * @tc.type: FUNC 808 */ 809 HWTEST_F(NativeEngineTest, DoParseUUIDTest046, testing::ext::TestSize.Level0) 810 { 811 napi_env env = (napi_env)engine_; 812 napi_value src = nullptr; 813 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100046", NAPI_AUTO_LENGTH, &src); 814 napi_value arr = OHOS::Util::DoParseUUID(env, src); 815 napi_typedarray_type type = napi_int8_array; 816 size_t byteOffset = 0; 817 size_t length = 0; 818 void* resultData = nullptr; 819 napi_value resultBuffer = nullptr; 820 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 821 ASSERT_EQ(length, 16); 822 } 823 824 /* @tc.name: DoParseUUIDTest047 825 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 826 * @tc.type: FUNC 827 */ 828 HWTEST_F(NativeEngineTest, DoParseUUIDTest047, testing::ext::TestSize.Level0) 829 { 830 napi_env env = (napi_env)engine_; 831 napi_value src = nullptr; 832 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100047", NAPI_AUTO_LENGTH, &src); 833 napi_value arr = OHOS::Util::DoParseUUID(env, src); 834 napi_typedarray_type type = napi_int8_array; 835 size_t byteOffset = 0; 836 size_t length = 0; 837 void* resultData = nullptr; 838 napi_value resultBuffer = nullptr; 839 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 840 ASSERT_EQ(length, 16); 841 } 842 843 /* @tc.name: DoParseUUIDTest048 844 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 845 * @tc.type: FUNC 846 */ 847 HWTEST_F(NativeEngineTest, DoParseUUIDTest048, testing::ext::TestSize.Level0) 848 { 849 napi_env env = (napi_env)engine_; 850 napi_value src = nullptr; 851 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100048", NAPI_AUTO_LENGTH, &src); 852 napi_value arr = OHOS::Util::DoParseUUID(env, src); 853 napi_typedarray_type type = napi_int8_array; 854 size_t byteOffset = 0; 855 size_t length = 0; 856 void* resultData = nullptr; 857 napi_value resultBuffer = nullptr; 858 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 859 ASSERT_EQ(length, 16); 860 } 861 862 /* @tc.name: DoParseUUIDTest049 863 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 864 * @tc.type: FUNC 865 */ 866 HWTEST_F(NativeEngineTest, DoParseUUIDTest049, testing::ext::TestSize.Level0) 867 { 868 napi_env env = (napi_env)engine_; 869 napi_value src = nullptr; 870 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100049", NAPI_AUTO_LENGTH, &src); 871 napi_value arr = OHOS::Util::DoParseUUID(env, src); 872 napi_typedarray_type type = napi_int8_array; 873 size_t byteOffset = 0; 874 size_t length = 0; 875 void* resultData = nullptr; 876 napi_value resultBuffer = nullptr; 877 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 878 ASSERT_EQ(length, 16); 879 } 880 881 /* @tc.name: DoParseUUIDTest050 882 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 883 * @tc.type: FUNC 884 */ 885 HWTEST_F(NativeEngineTest, DoParseUUIDTest050, testing::ext::TestSize.Level0) 886 { 887 napi_env env = (napi_env)engine_; 888 napi_value src = nullptr; 889 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100050", NAPI_AUTO_LENGTH, &src); 890 napi_value arr = OHOS::Util::DoParseUUID(env, src); 891 napi_typedarray_type type = napi_int8_array; 892 size_t byteOffset = 0; 893 size_t length = 0; 894 void* resultData = nullptr; 895 napi_value resultBuffer = nullptr; 896 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 897 ASSERT_EQ(length, 16); 898 } 899 900 /* @tc.name: DoParseUUIDTest051 901 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 902 * @tc.type: FUNC 903 */ 904 HWTEST_F(NativeEngineTest, DoParseUUIDTest051, testing::ext::TestSize.Level0) 905 { 906 napi_env env = (napi_env)engine_; 907 napi_value src = nullptr; 908 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100051", NAPI_AUTO_LENGTH, &src); 909 napi_value arr = OHOS::Util::DoParseUUID(env, src); 910 napi_typedarray_type type = napi_int8_array; 911 size_t byteOffset = 0; 912 size_t length = 0; 913 void* resultData = nullptr; 914 napi_value resultBuffer = nullptr; 915 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 916 ASSERT_EQ(length, 16); 917 } 918 919 /* @tc.name: DoParseUUIDTest052 920 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 921 * @tc.type: FUNC 922 */ 923 HWTEST_F(NativeEngineTest, DoParseUUIDTest052, testing::ext::TestSize.Level0) 924 { 925 napi_env env = (napi_env)engine_; 926 napi_value src = nullptr; 927 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100052", NAPI_AUTO_LENGTH, &src); 928 napi_value arr = OHOS::Util::DoParseUUID(env, src); 929 napi_typedarray_type type = napi_int8_array; 930 size_t byteOffset = 0; 931 size_t length = 0; 932 void* resultData = nullptr; 933 napi_value resultBuffer = nullptr; 934 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 935 ASSERT_EQ(length, 16); 936 } 937 938 /* @tc.name: DoParseUUIDTest053 939 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 940 * @tc.type: FUNC 941 */ 942 HWTEST_F(NativeEngineTest, DoParseUUIDTest053, testing::ext::TestSize.Level0) 943 { 944 napi_env env = (napi_env)engine_; 945 napi_value src = nullptr; 946 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100053", NAPI_AUTO_LENGTH, &src); 947 napi_value arr = OHOS::Util::DoParseUUID(env, src); 948 napi_typedarray_type type = napi_int8_array; 949 size_t byteOffset = 0; 950 size_t length = 0; 951 void* resultData = nullptr; 952 napi_value resultBuffer = nullptr; 953 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 954 ASSERT_EQ(length, 16); 955 } 956 957 /* @tc.name: DoParseUUIDTest054 958 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 959 * @tc.type: FUNC 960 */ 961 HWTEST_F(NativeEngineTest, DoParseUUIDTest054, testing::ext::TestSize.Level0) 962 { 963 napi_env env = (napi_env)engine_; 964 napi_value src = nullptr; 965 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100054", NAPI_AUTO_LENGTH, &src); 966 napi_value arr = OHOS::Util::DoParseUUID(env, src); 967 napi_typedarray_type type = napi_int8_array; 968 size_t byteOffset = 0; 969 size_t length = 0; 970 void* resultData = nullptr; 971 napi_value resultBuffer = nullptr; 972 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 973 ASSERT_EQ(length, 16); 974 } 975 976 /* @tc.name: DoParseUUIDTest055 977 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 978 * @tc.type: FUNC 979 */ 980 HWTEST_F(NativeEngineTest, DoParseUUIDTest055, testing::ext::TestSize.Level0) 981 { 982 napi_env env = (napi_env)engine_; 983 napi_value src = nullptr; 984 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100055", NAPI_AUTO_LENGTH, &src); 985 napi_value arr = OHOS::Util::DoParseUUID(env, src); 986 napi_typedarray_type type = napi_int8_array; 987 size_t byteOffset = 0; 988 size_t length = 0; 989 void* resultData = nullptr; 990 napi_value resultBuffer = nullptr; 991 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 992 ASSERT_EQ(length, 16); 993 } 994 995 /* @tc.name: DoParseUUIDTest056 996 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 997 * @tc.type: FUNC 998 */ 999 HWTEST_F(NativeEngineTest, DoParseUUIDTest056, testing::ext::TestSize.Level0) 1000 { 1001 napi_env env = (napi_env)engine_; 1002 napi_value src = nullptr; 1003 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100056", NAPI_AUTO_LENGTH, &src); 1004 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1005 napi_typedarray_type type = napi_int8_array; 1006 size_t byteOffset = 0; 1007 size_t length = 0; 1008 void* resultData = nullptr; 1009 napi_value resultBuffer = nullptr; 1010 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1011 ASSERT_EQ(length, 16); 1012 } 1013 1014 /* @tc.name: DoParseUUIDTest057 1015 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1016 * @tc.type: FUNC 1017 */ 1018 HWTEST_F(NativeEngineTest, DoParseUUIDTest057, testing::ext::TestSize.Level0) 1019 { 1020 napi_env env = (napi_env)engine_; 1021 napi_value src = nullptr; 1022 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100057", NAPI_AUTO_LENGTH, &src); 1023 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1024 napi_typedarray_type type = napi_int8_array; 1025 size_t byteOffset = 0; 1026 size_t length = 0; 1027 void* resultData = nullptr; 1028 napi_value resultBuffer = nullptr; 1029 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1030 ASSERT_EQ(length, 16); 1031 } 1032 1033 /* @tc.name: DoParseUUIDTest058 1034 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1035 * @tc.type: FUNC 1036 */ 1037 HWTEST_F(NativeEngineTest, DoParseUUIDTest058, testing::ext::TestSize.Level0) 1038 { 1039 napi_env env = (napi_env)engine_; 1040 napi_value src = nullptr; 1041 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100058", NAPI_AUTO_LENGTH, &src); 1042 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1043 napi_typedarray_type type = napi_int8_array; 1044 size_t byteOffset = 0; 1045 size_t length = 0; 1046 void* resultData = nullptr; 1047 napi_value resultBuffer = nullptr; 1048 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1049 ASSERT_EQ(length, 16); 1050 } 1051 1052 /* @tc.name: DoParseUUIDTest059 1053 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1054 * @tc.type: FUNC 1055 */ 1056 HWTEST_F(NativeEngineTest, DoParseUUIDTest059, testing::ext::TestSize.Level0) 1057 { 1058 napi_env env = (napi_env)engine_; 1059 napi_value src = nullptr; 1060 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100059", NAPI_AUTO_LENGTH, &src); 1061 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1062 napi_typedarray_type type = napi_int8_array; 1063 size_t byteOffset = 0; 1064 size_t length = 0; 1065 void* resultData = nullptr; 1066 napi_value resultBuffer = nullptr; 1067 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1068 ASSERT_EQ(length, 16); 1069 } 1070 1071 /* @tc.name: DoParseUUIDTest060 1072 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1073 * @tc.type: FUNC 1074 */ 1075 HWTEST_F(NativeEngineTest, DoParseUUIDTest060, testing::ext::TestSize.Level0) 1076 { 1077 napi_env env = (napi_env)engine_; 1078 napi_value src = nullptr; 1079 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100060", NAPI_AUTO_LENGTH, &src); 1080 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1081 napi_typedarray_type type = napi_int8_array; 1082 size_t byteOffset = 0; 1083 size_t length = 0; 1084 void* resultData = nullptr; 1085 napi_value resultBuffer = nullptr; 1086 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1087 ASSERT_EQ(length, 16); 1088 } 1089 1090 /* @tc.name: DoParseUUIDTest061 1091 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1092 * @tc.type: FUNC 1093 */ 1094 HWTEST_F(NativeEngineTest, DoParseUUIDTest061, testing::ext::TestSize.Level0) 1095 { 1096 napi_env env = (napi_env)engine_; 1097 napi_value src = nullptr; 1098 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100061", NAPI_AUTO_LENGTH, &src); 1099 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1100 napi_typedarray_type type = napi_int8_array; 1101 size_t byteOffset = 0; 1102 size_t length = 0; 1103 void* resultData = nullptr; 1104 napi_value resultBuffer = nullptr; 1105 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1106 ASSERT_EQ(length, 16); 1107 } 1108 1109 /* @tc.name: DoParseUUIDTest062 1110 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1111 * @tc.type: FUNC 1112 */ 1113 HWTEST_F(NativeEngineTest, DoParseUUIDTest062, testing::ext::TestSize.Level0) 1114 { 1115 napi_env env = (napi_env)engine_; 1116 napi_value src = nullptr; 1117 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100062", NAPI_AUTO_LENGTH, &src); 1118 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1119 napi_typedarray_type type = napi_int8_array; 1120 size_t byteOffset = 0; 1121 size_t length = 0; 1122 void* resultData = nullptr; 1123 napi_value resultBuffer = nullptr; 1124 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1125 ASSERT_EQ(length, 16); 1126 } 1127 1128 /* @tc.name: DoParseUUIDTest063 1129 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1130 * @tc.type: FUNC 1131 */ 1132 HWTEST_F(NativeEngineTest, DoParseUUIDTest063, testing::ext::TestSize.Level0) 1133 { 1134 napi_env env = (napi_env)engine_; 1135 napi_value src = nullptr; 1136 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100063", NAPI_AUTO_LENGTH, &src); 1137 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1138 napi_typedarray_type type = napi_int8_array; 1139 size_t byteOffset = 0; 1140 size_t length = 0; 1141 void* resultData = nullptr; 1142 napi_value resultBuffer = nullptr; 1143 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1144 ASSERT_EQ(length, 16); 1145 } 1146 1147 /* @tc.name: DoParseUUIDTest064 1148 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1149 * @tc.type: FUNC 1150 */ 1151 HWTEST_F(NativeEngineTest, DoParseUUIDTest064, testing::ext::TestSize.Level0) 1152 { 1153 napi_env env = (napi_env)engine_; 1154 napi_value src = nullptr; 1155 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100064", NAPI_AUTO_LENGTH, &src); 1156 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1157 napi_typedarray_type type = napi_int8_array; 1158 size_t byteOffset = 0; 1159 size_t length = 0; 1160 void* resultData = nullptr; 1161 napi_value resultBuffer = nullptr; 1162 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1163 ASSERT_EQ(length, 16); 1164 } 1165 1166 /* @tc.name: DoParseUUIDTest065 1167 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1168 * @tc.type: FUNC 1169 */ 1170 HWTEST_F(NativeEngineTest, DoParseUUIDTest065, testing::ext::TestSize.Level0) 1171 { 1172 napi_env env = (napi_env)engine_; 1173 napi_value src = nullptr; 1174 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100065", NAPI_AUTO_LENGTH, &src); 1175 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1176 napi_typedarray_type type = napi_int8_array; 1177 size_t byteOffset = 0; 1178 size_t length = 0; 1179 void* resultData = nullptr; 1180 napi_value resultBuffer = nullptr; 1181 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1182 ASSERT_EQ(length, 16); 1183 } 1184 1185 /* @tc.name: DoParseUUIDTest066 1186 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1187 * @tc.type: FUNC 1188 */ 1189 HWTEST_F(NativeEngineTest, DoParseUUIDTest066, testing::ext::TestSize.Level0) 1190 { 1191 napi_env env = (napi_env)engine_; 1192 napi_value src = nullptr; 1193 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100066", NAPI_AUTO_LENGTH, &src); 1194 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1195 napi_typedarray_type type = napi_int8_array; 1196 size_t byteOffset = 0; 1197 size_t length = 0; 1198 void* resultData = nullptr; 1199 napi_value resultBuffer = nullptr; 1200 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1201 ASSERT_EQ(length, 16); 1202 } 1203 1204 /* @tc.name: DoParseUUIDTest067 1205 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1206 * @tc.type: FUNC 1207 */ 1208 HWTEST_F(NativeEngineTest, DoParseUUIDTest067, testing::ext::TestSize.Level0) 1209 { 1210 napi_env env = (napi_env)engine_; 1211 napi_value src = nullptr; 1212 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100067", NAPI_AUTO_LENGTH, &src); 1213 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1214 napi_typedarray_type type = napi_int8_array; 1215 size_t byteOffset = 0; 1216 size_t length = 0; 1217 void* resultData = nullptr; 1218 napi_value resultBuffer = nullptr; 1219 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1220 ASSERT_EQ(length, 16); 1221 } 1222 1223 /* @tc.name: DoParseUUIDTest068 1224 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1225 * @tc.type: FUNC 1226 */ 1227 HWTEST_F(NativeEngineTest, DoParseUUIDTest068, testing::ext::TestSize.Level0) 1228 { 1229 napi_env env = (napi_env)engine_; 1230 napi_value src = nullptr; 1231 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100068", NAPI_AUTO_LENGTH, &src); 1232 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1233 napi_typedarray_type type = napi_int8_array; 1234 size_t byteOffset = 0; 1235 size_t length = 0; 1236 void* resultData = nullptr; 1237 napi_value resultBuffer = nullptr; 1238 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1239 ASSERT_EQ(length, 16); 1240 } 1241 1242 /* @tc.name: DoParseUUIDTest069 1243 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1244 * @tc.type: FUNC 1245 */ 1246 HWTEST_F(NativeEngineTest, DoParseUUIDTest069, testing::ext::TestSize.Level0) 1247 { 1248 napi_env env = (napi_env)engine_; 1249 napi_value src = nullptr; 1250 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100069", NAPI_AUTO_LENGTH, &src); 1251 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1252 napi_typedarray_type type = napi_int8_array; 1253 size_t byteOffset = 0; 1254 size_t length = 0; 1255 void* resultData = nullptr; 1256 napi_value resultBuffer = nullptr; 1257 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1258 ASSERT_EQ(length, 16); 1259 } 1260 1261 /* @tc.name: DoParseUUIDTest070 1262 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1263 * @tc.type: FUNC 1264 */ 1265 HWTEST_F(NativeEngineTest, DoParseUUIDTest070, testing::ext::TestSize.Level0) 1266 { 1267 napi_env env = (napi_env)engine_; 1268 napi_value src = nullptr; 1269 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100070", NAPI_AUTO_LENGTH, &src); 1270 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1271 napi_typedarray_type type = napi_int8_array; 1272 size_t byteOffset = 0; 1273 size_t length = 0; 1274 void* resultData = nullptr; 1275 napi_value resultBuffer = nullptr; 1276 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1277 ASSERT_EQ(length, 16); 1278 } 1279 1280 /* @tc.name: DoParseUUIDTest071 1281 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1282 * @tc.type: FUNC 1283 */ 1284 HWTEST_F(NativeEngineTest, DoParseUUIDTest071, testing::ext::TestSize.Level0) 1285 { 1286 napi_env env = (napi_env)engine_; 1287 napi_value src = nullptr; 1288 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100071", NAPI_AUTO_LENGTH, &src); 1289 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1290 napi_typedarray_type type = napi_int8_array; 1291 size_t byteOffset = 0; 1292 size_t length = 0; 1293 void* resultData = nullptr; 1294 napi_value resultBuffer = nullptr; 1295 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1296 ASSERT_EQ(length, 16); 1297 } 1298 1299 /* @tc.name: DoParseUUIDTest072 1300 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1301 * @tc.type: FUNC 1302 */ 1303 HWTEST_F(NativeEngineTest, DoParseUUIDTest072, testing::ext::TestSize.Level0) 1304 { 1305 napi_env env = (napi_env)engine_; 1306 napi_value src = nullptr; 1307 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100072", NAPI_AUTO_LENGTH, &src); 1308 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1309 napi_typedarray_type type = napi_int8_array; 1310 size_t byteOffset = 0; 1311 size_t length = 0; 1312 void* resultData = nullptr; 1313 napi_value resultBuffer = nullptr; 1314 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1315 ASSERT_EQ(length, 16); 1316 } 1317 1318 /* @tc.name: DoParseUUIDTest073 1319 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1320 * @tc.type: FUNC 1321 */ 1322 HWTEST_F(NativeEngineTest, DoParseUUIDTest073, testing::ext::TestSize.Level0) 1323 { 1324 napi_env env = (napi_env)engine_; 1325 napi_value src = nullptr; 1326 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100073", NAPI_AUTO_LENGTH, &src); 1327 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1328 napi_typedarray_type type = napi_int8_array; 1329 size_t byteOffset = 0; 1330 size_t length = 0; 1331 void* resultData = nullptr; 1332 napi_value resultBuffer = nullptr; 1333 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1334 ASSERT_EQ(length, 16); 1335 } 1336 1337 /* @tc.name: DoParseUUIDTest074 1338 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1339 * @tc.type: FUNC 1340 */ 1341 HWTEST_F(NativeEngineTest, DoParseUUIDTest074, testing::ext::TestSize.Level0) 1342 { 1343 napi_env env = (napi_env)engine_; 1344 napi_value src = nullptr; 1345 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100074", NAPI_AUTO_LENGTH, &src); 1346 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1347 napi_typedarray_type type = napi_int8_array; 1348 size_t byteOffset = 0; 1349 size_t length = 0; 1350 void* resultData = nullptr; 1351 napi_value resultBuffer = nullptr; 1352 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1353 ASSERT_EQ(length, 16); 1354 } 1355 1356 /* @tc.name: DoParseUUIDTest075 1357 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1358 * @tc.type: FUNC 1359 */ 1360 HWTEST_F(NativeEngineTest, DoParseUUIDTest075, testing::ext::TestSize.Level0) 1361 { 1362 napi_env env = (napi_env)engine_; 1363 napi_value src = nullptr; 1364 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100075", NAPI_AUTO_LENGTH, &src); 1365 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1366 napi_typedarray_type type = napi_int8_array; 1367 size_t byteOffset = 0; 1368 size_t length = 0; 1369 void* resultData = nullptr; 1370 napi_value resultBuffer = nullptr; 1371 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1372 ASSERT_EQ(length, 16); 1373 } 1374 1375 /* @tc.name: DoParseUUIDTest076 1376 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1377 * @tc.type: FUNC 1378 */ 1379 HWTEST_F(NativeEngineTest, DoParseUUIDTest076, testing::ext::TestSize.Level0) 1380 { 1381 napi_env env = (napi_env)engine_; 1382 napi_value src = nullptr; 1383 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100076", NAPI_AUTO_LENGTH, &src); 1384 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1385 napi_typedarray_type type = napi_int8_array; 1386 size_t byteOffset = 0; 1387 size_t length = 0; 1388 void* resultData = nullptr; 1389 napi_value resultBuffer = nullptr; 1390 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1391 ASSERT_EQ(length, 16); 1392 } 1393 1394 /* @tc.name: DoParseUUIDTest077 1395 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1396 * @tc.type: FUNC 1397 */ 1398 HWTEST_F(NativeEngineTest, DoParseUUIDTest077, testing::ext::TestSize.Level0) 1399 { 1400 napi_env env = (napi_env)engine_; 1401 napi_value src = nullptr; 1402 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100077", NAPI_AUTO_LENGTH, &src); 1403 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1404 napi_typedarray_type type = napi_int8_array; 1405 size_t byteOffset = 0; 1406 size_t length = 0; 1407 void* resultData = nullptr; 1408 napi_value resultBuffer = nullptr; 1409 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1410 ASSERT_EQ(length, 16); 1411 } 1412 1413 /* @tc.name: DoParseUUIDTest078 1414 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1415 * @tc.type: FUNC 1416 */ 1417 HWTEST_F(NativeEngineTest, DoParseUUIDTest078, testing::ext::TestSize.Level0) 1418 { 1419 napi_env env = (napi_env)engine_; 1420 napi_value src = nullptr; 1421 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100078", NAPI_AUTO_LENGTH, &src); 1422 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1423 napi_typedarray_type type = napi_int8_array; 1424 size_t byteOffset = 0; 1425 size_t length = 0; 1426 void* resultData = nullptr; 1427 napi_value resultBuffer = nullptr; 1428 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1429 ASSERT_EQ(length, 16); 1430 } 1431 1432 /* @tc.name: DoParseUUIDTest079 1433 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1434 * @tc.type: FUNC 1435 */ 1436 HWTEST_F(NativeEngineTest, DoParseUUIDTest079, testing::ext::TestSize.Level0) 1437 { 1438 napi_env env = (napi_env)engine_; 1439 napi_value src = nullptr; 1440 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100079", NAPI_AUTO_LENGTH, &src); 1441 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1442 napi_typedarray_type type = napi_int8_array; 1443 size_t byteOffset = 0; 1444 size_t length = 0; 1445 void* resultData = nullptr; 1446 napi_value resultBuffer = nullptr; 1447 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1448 ASSERT_EQ(length, 16); 1449 } 1450 1451 /* @tc.name: DoParseUUIDTest080 1452 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1453 * @tc.type: FUNC 1454 */ 1455 HWTEST_F(NativeEngineTest, DoParseUUIDTest080, testing::ext::TestSize.Level0) 1456 { 1457 napi_env env = (napi_env)engine_; 1458 napi_value src = nullptr; 1459 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100080", NAPI_AUTO_LENGTH, &src); 1460 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1461 napi_typedarray_type type = napi_int8_array; 1462 size_t byteOffset = 0; 1463 size_t length = 0; 1464 void* resultData = nullptr; 1465 napi_value resultBuffer = nullptr; 1466 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1467 ASSERT_EQ(length, 16); 1468 } 1469 1470 /* @tc.name: DoParseUUIDTest081 1471 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1472 * @tc.type: FUNC 1473 */ 1474 HWTEST_F(NativeEngineTest, DoParseUUIDTest081, testing::ext::TestSize.Level0) 1475 { 1476 napi_env env = (napi_env)engine_; 1477 napi_value src = nullptr; 1478 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100081", NAPI_AUTO_LENGTH, &src); 1479 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1480 napi_typedarray_type type = napi_int8_array; 1481 size_t byteOffset = 0; 1482 size_t length = 0; 1483 void* resultData = nullptr; 1484 napi_value resultBuffer = nullptr; 1485 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1486 ASSERT_EQ(length, 16); 1487 } 1488 1489 /* @tc.name: DoParseUUIDTest082 1490 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1491 * @tc.type: FUNC 1492 */ 1493 HWTEST_F(NativeEngineTest, DoParseUUIDTest082, testing::ext::TestSize.Level0) 1494 { 1495 napi_env env = (napi_env)engine_; 1496 napi_value src = nullptr; 1497 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100082", NAPI_AUTO_LENGTH, &src); 1498 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1499 napi_typedarray_type type = napi_int8_array; 1500 size_t byteOffset = 0; 1501 size_t length = 0; 1502 void* resultData = nullptr; 1503 napi_value resultBuffer = nullptr; 1504 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1505 ASSERT_EQ(length, 16); 1506 } 1507 1508 /* @tc.name: DoParseUUIDTest083 1509 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1510 * @tc.type: FUNC 1511 */ 1512 HWTEST_F(NativeEngineTest, DoParseUUIDTest083, testing::ext::TestSize.Level0) 1513 { 1514 napi_env env = (napi_env)engine_; 1515 napi_value src = nullptr; 1516 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100083", NAPI_AUTO_LENGTH, &src); 1517 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1518 napi_typedarray_type type = napi_int8_array; 1519 size_t byteOffset = 0; 1520 size_t length = 0; 1521 void* resultData = nullptr; 1522 napi_value resultBuffer = nullptr; 1523 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1524 ASSERT_EQ(length, 16); 1525 } 1526 1527 /* @tc.name: DoParseUUIDTest084 1528 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1529 * @tc.type: FUNC 1530 */ 1531 HWTEST_F(NativeEngineTest, DoParseUUIDTest084, testing::ext::TestSize.Level0) 1532 { 1533 napi_env env = (napi_env)engine_; 1534 napi_value src = nullptr; 1535 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100084", NAPI_AUTO_LENGTH, &src); 1536 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1537 napi_typedarray_type type = napi_int8_array; 1538 size_t byteOffset = 0; 1539 size_t length = 0; 1540 void* resultData = nullptr; 1541 napi_value resultBuffer = nullptr; 1542 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1543 ASSERT_EQ(length, 16); 1544 } 1545 1546 /* @tc.name: DoParseUUIDTest085 1547 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1548 * @tc.type: FUNC 1549 */ 1550 HWTEST_F(NativeEngineTest, DoParseUUIDTest085, testing::ext::TestSize.Level0) 1551 { 1552 napi_env env = (napi_env)engine_; 1553 napi_value src = nullptr; 1554 napi_create_string_utf8(env, "84bdf796-66cc-4655-9b89-d6218d100085", NAPI_AUTO_LENGTH, &src); 1555 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1556 napi_typedarray_type type = napi_int8_array; 1557 size_t byteOffset = 0; 1558 size_t length = 0; 1559 void* resultData = nullptr; 1560 napi_value resultBuffer = nullptr; 1561 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1562 ASSERT_EQ(length, 16); 1563 } 1564 1565 /* @tc.name: DoParseUUIDTest086 1566 * @tc.desc: Parse a UUID from the string standard representation as described in the RFC 4122 version 4. 1567 * @tc.type: FUNC 1568 */ 1569 HWTEST_F(NativeEngineTest, DoParseUUIDTest086, testing::ext::TestSize.Level0) 1570 { 1571 napi_env env = (napi_env)engine_; 1572 napi_value src = nullptr; 1573 napi_create_string_utf8(env, "84bdf796-65cc-4755-9b89-d6218d101186", NAPI_AUTO_LENGTH, &src); 1574 napi_value arr = OHOS::Util::DoParseUUID(env, src); 1575 napi_typedarray_type type = napi_int8_array; 1576 size_t byteOffset = 0; 1577 size_t length = 0; 1578 void* resultData = nullptr; 1579 napi_value resultBuffer = nullptr; 1580 napi_get_typedarray_info(env, arr, &type, &length, &resultData, &resultBuffer, &byteOffset); 1581 ASSERT_EQ(length, 16); 1582 }