1 /* 2 * Copyright (c) 2024 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 "disassembler.h" 17 18 #include <algorithm> 19 #include <cctype> 20 #include <cstdlib> 21 #include <iostream> 22 #include <string> 23 24 #include <gtest/gtest.h> 25 26 using namespace testing::ext; 27 namespace panda::disasm { 28 29 static const std::string FILE_DECLARATION_3D_ARRAY_BOOLEAN = 30 GRAPH_TEST_ABC_DIR "declaration-3d-array-boolean.abc"; 31 static const std::string FILE_DECLARATION_3D_ARRAY_ENUM_NUMBER = 32 GRAPH_TEST_ABC_DIR "declaration-3d-array-enum-number.abc"; 33 static const std::string FILE_DECLARATION_3D_ARRAY_ENUM_STRING = 34 GRAPH_TEST_ABC_DIR "declaration-3d-array-enum-string.abc"; 35 static const std::string FILE_DECLARATION_3D_ARRAY_NUMBER = 36 GRAPH_TEST_ABC_DIR "declaration-3d-array-number.abc"; 37 static const std::string FILE_DECLARATION_3D_ARRAY_STRING = 38 GRAPH_TEST_ABC_DIR "declaration-3d-array-string.abc"; 39 static const std::string FILE_DECLARATION_ARRAY_BOOLEAN = 40 GRAPH_TEST_ABC_DIR "declaration-array-boolean.abc"; 41 static const std::string FILE_DECLARATION_ARRAY_ENUM_NUMBER = 42 GRAPH_TEST_ABC_DIR "declaration-array-enum-number.abc"; 43 static const std::string FILE_DECLARATION_ARRAY_ENUM_STRING = 44 GRAPH_TEST_ABC_DIR "declaration-array-enum-string.abc"; 45 static const std::string FILE_DECLARATION_ARRAY_NUMBER = 46 GRAPH_TEST_ABC_DIR "declaration-array-number.abc"; 47 static const std::string FILE_DECLARATION_ARRAY_STRING = 48 GRAPH_TEST_ABC_DIR "declaration-array-string.abc"; 49 static const std::string FILE_DECLARATION_BOOLEAN = 50 GRAPH_TEST_ABC_DIR "declaration-boolean.abc"; 51 static const std::string FILE_DECLARATION_COMBINATION = 52 GRAPH_TEST_ABC_DIR "declaration-combination.abc"; 53 static const std::string FILE_DECLARATION_EMPTY = 54 GRAPH_TEST_ABC_DIR "declaration-empty.abc"; 55 static const std::string FILE_DECLARATION_ENUM_NUMBER = 56 GRAPH_TEST_ABC_DIR "declaration-enum-number.abc"; 57 static const std::string FILE_DECLARATION_ENUM_STRING = 58 GRAPH_TEST_ABC_DIR "declaration-enum-string.abc"; 59 static const std::string FILE_DECLARATION_NUMBER = 60 GRAPH_TEST_ABC_DIR "declaration-number.abc"; 61 static const std::string FILE_DECLARATION_STRING = 62 GRAPH_TEST_ABC_DIR "declaration-string.abc"; 63 static const std::string FILE_DECLARATION_USAGE_3D_ARRAY_BOOLEAN = 64 GRAPH_TEST_ABC_DIR "declaration-usage-3d-array-boolean.abc"; 65 static const std::string FILE_DECLARATION_USAGE_3D_ARRAY_ENUM_NUMBER = 66 GRAPH_TEST_ABC_DIR "declaration-usage-3d-array-enum-number.abc"; 67 static const std::string FILE_DECLARATION_USAGE_3D_ARRAY_ENUM_STRING = 68 GRAPH_TEST_ABC_DIR "declaration-usage-3d-array-enum-string.abc"; 69 static const std::string FILE_DECLARATION_USAGE_3D_ARRAY_NUMBER = 70 GRAPH_TEST_ABC_DIR "declaration-usage-3d-array-number.abc"; 71 static const std::string FILE_DECLARATION_USAGE_3D_ARRAY_STRING = 72 GRAPH_TEST_ABC_DIR "declaration-usage-3d-array-string.abc"; 73 static const std::string FILE_DECLARATION_USAGE_ARRAY_BOOLEAN = 74 GRAPH_TEST_ABC_DIR "declaration-usage-array-boolean.abc"; 75 static const std::string FILE_DECLARATION_USAGE_ARRAY_ENUM_NUMBER = 76 GRAPH_TEST_ABC_DIR "declaration-usage-array-enum-number.abc"; 77 static const std::string FILE_DECLARATION_USAGE_ARRAY_ENUM_STRING = 78 GRAPH_TEST_ABC_DIR "declaration-usage-array-enum-string.abc"; 79 static const std::string FILE_DECLARATION_USAGE_ARRAY_NUMBER = 80 GRAPH_TEST_ABC_DIR "declaration-usage-array-number.abc"; 81 static const std::string FILE_DECLARATION_USAGE_ARRAY_STRING = 82 GRAPH_TEST_ABC_DIR "declaration-usage-array-string.abc"; 83 static const std::string FILE_DECLARATION_USAGE_BOOLEAN = 84 GRAPH_TEST_ABC_DIR "declaration-usage-boolean.abc"; 85 static const std::string FILE_DECLARATION_USAGE_COMBINATION = 86 GRAPH_TEST_ABC_DIR "declaration-usage-combination.abc"; 87 static const std::string FILE_DECLARATION_USAGE_EMPTY = 88 GRAPH_TEST_ABC_DIR "declaration-usage-empty.abc"; 89 static const std::string FILE_DECLARATION_USAGE_ENUM_NUMBER = 90 GRAPH_TEST_ABC_DIR "declaration-usage-enum-number.abc"; 91 static const std::string FILE_DECLARATION_USAGE_ENUM_STRING = 92 GRAPH_TEST_ABC_DIR "declaration-usage-enum-string.abc"; 93 static const std::string FILE_DECLARATION_USAGE_NUMBER = 94 GRAPH_TEST_ABC_DIR "declaration-usage-number.abc"; 95 static const std::string FILE_DECLARATION_USAGE_STRING = 96 GRAPH_TEST_ABC_DIR "declaration-usage-string.abc"; 97 static const std::string FILE_EXPORT = 98 GRAPH_TEST_ABC_DIR "export.abc"; 99 static const std::string FILE_IMPORT_QUALIFIED = 100 GRAPH_TEST_ABC_DIR "import-qualified.abc"; 101 static const std::string FILE_IMPORT_UNQUALIFIED = 102 GRAPH_TEST_ABC_DIR "import-unqualified.abc"; 103 static const std::string FILE_MULTIPLE_ANNOTATIONS = 104 GRAPH_TEST_ABC_DIR "multiple-annotations.abc"; 105 106 class DisassemblerUserAnnotationTest : public testing::Test { 107 public: SetUpTestCase(void)108 static void SetUpTestCase(void) {}; TearDownTestCase(void)109 static void TearDownTestCase(void) {}; SetUp()110 void SetUp() 111 { 112 disasm = new panda::disasm::Disassembler{}; 113 }; 114 TearDown()115 void TearDown() 116 { 117 delete disasm; 118 disasm = nullptr; 119 }; 120 ValidateMethodAnnotation(const std::string & method_name,const std::string & anno_name,std::string anno_expected)121 void ValidateMethodAnnotation(const std::string &method_name, const std::string &anno_name, 122 std::string anno_expected) 123 { 124 auto anno = disasm->GetSerializedMethodAnnotation(method_name, anno_name); 125 ASSERT_NE(anno, std::nullopt); 126 std::string anno_str = anno.value(); 127 // remove whitespaces from both strings 128 auto anno_str_rem_iter = std::remove_if(anno_str.begin(), anno_str.end(), 129 [](unsigned char x) { return std::isspace(x); }); 130 anno_str.erase(anno_str_rem_iter, anno_str.end()); 131 auto anno_expected_rem_iter = std::remove_if(anno_expected.begin(), anno_expected.end(), 132 [](unsigned char x) { return std::isspace(x); }); 133 anno_expected.erase(anno_expected_rem_iter, anno_expected.end()); 134 ASSERT_EQ(anno_str, anno_expected); 135 } 136 ValidateRecord(const std::string & record_name,std::string record_expected)137 void ValidateRecord(const std::string &record_name, std::string record_expected) 138 { 139 auto record = disasm->GetSerializedRecord(record_name); 140 ASSERT_NE(record, std::nullopt); 141 std::string record_str = record.value(); 142 // remove whitespaces from both strings 143 auto record_str_rem_iter = std::remove_if(record_str.begin(), record_str.end(), 144 [](unsigned char x) { return std::isspace(x); }); 145 record_str.erase(record_str_rem_iter, record_str.end()); 146 auto record_expected_rem_iter = std::remove_if(record_expected.begin(), record_expected.end(), 147 [](unsigned char x) { return std::isspace(x); }); 148 record_expected.erase(record_expected_rem_iter, record_expected.end()); 149 ASSERT_EQ(record_str, record_expected); 150 } 151 InitDisasm(std::string file_path)152 void InitDisasm(std::string file_path) 153 { 154 disasm->Disassemble(file_path, false, false); 155 } 156 157 private: 158 panda::disasm::Disassembler *disasm = nullptr; 159 }; 160 161 /** 162 * @tc.name: test_declaration_3d_array_boolean 163 * @tc.desc: validate annotation usage 164 * @tc.type: FUNC 165 * @tc.require: file path and name 166 */ 167 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_3d_array_boolean, TestSize.Level1) 168 { 169 InitDisasm(FILE_DECLARATION_3D_ARRAY_BOOLEAN); 170 171 ValidateRecord("declaration-3d-array-boolean.Anno1", R"( 172 .language ECMAScript.record declaration-3d-array-boolean.Anno1 { 173 u1[][][] a 174 } 175 )"); 176 177 ValidateRecord("declaration-3d-array-boolean.Anno2", R"( 178 .language ECMAScript.record declaration-3d-array-boolean.Anno2 { 179 u1[][][] a = [[[]]] 180 } 181 )"); 182 183 ValidateRecord("declaration-3d-array-boolean.Anno3", R"( 184 .language ECMAScript.record declaration-3d-array-boolean.Anno3 { 185 u1[][][] a = [[[1, 0], [1, 0]]] 186 } 187 )"); 188 } 189 190 /** 191 * @tc.name: test_declaration_3d_array_enum_number 192 * @tc.desc: validate annotation usage 193 * @tc.type: FUNC 194 * @tc.require: file path and name 195 */ 196 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_3d_array_enum_number, TestSize.Level1) 197 { 198 InitDisasm(FILE_DECLARATION_3D_ARRAY_ENUM_NUMBER); 199 200 ValidateRecord("declaration-3d-array-enum-number.Anno1", R"( 201 .language ECMAScript.record declaration-3d-array-enum-number.Anno1 { 202 f64[][][] a 203 } 204 )"); 205 206 ValidateRecord("declaration-3d-array-enum-number.Anno2", R"( 207 .language ECMAScript.record declaration-3d-array-enum-number.Anno2 { 208 f64[][][] a = [[[]]] 209 } 210 )"); 211 212 ValidateRecord("declaration-3d-array-enum-number.Anno3", R"( 213 .language ECMAScript.record declaration-3d-array-enum-number.Anno3 { 214 f64[][][] a = [[[42, -314, 42]]] 215 } 216 )"); 217 } 218 219 /** 220 * @tc.name: test_declaration_3d_array_enum_string 221 * @tc.desc: validate annotation usage 222 * @tc.type: FUNC 223 * @tc.require: file path and name 224 */ 225 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_3d_array_enum_string, TestSize.Level1) 226 { 227 InitDisasm(FILE_DECLARATION_3D_ARRAY_ENUM_STRING); 228 229 ValidateRecord("declaration-3d-array-enum-string.Anno1", R"( 230 .language ECMAScript.record declaration-3d-array-enum-string.Anno1 { 231 panda.String[][][] a 232 } 233 )"); 234 235 ValidateRecord("declaration-3d-array-enum-string.Anno2", R"( 236 .language ECMAScript.record declaration-3d-array-enum-string.Anno2 { 237 panda.String[][][] a = [[[]]] 238 } 239 )"); 240 241 ValidateRecord("declaration-3d-array-enum-string.Anno3", R"( 242 .language ECMAScript.record declaration-3d-array-enum-string.Anno3 { 243 panda.String[][][] a = [[["Hello", "world!", "Hello"]]] 244 } 245 )"); 246 247 ValidateRecord("panda.String", R"( 248 .language ECMAScript.record panda.String <external> 249 )"); 250 } 251 252 /** 253 * @tc.name: test_declaration_3d_array_number 254 * @tc.desc: validate annotation usage 255 * @tc.type: FUNC 256 * @tc.require: file path and name 257 */ 258 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_3d_array_number, TestSize.Level1) 259 { 260 InitDisasm(FILE_DECLARATION_3D_ARRAY_NUMBER); 261 262 ValidateRecord("declaration-3d-array-number.Anno1", R"( 263 .language ECMAScript.record declaration-3d-array-number.Anno1 { 264 f64[][][] a 265 } 266 )"); 267 268 ValidateRecord("declaration-3d-array-number.Anno2", R"( 269 .language ECMAScript.record declaration-3d-array-number.Anno2 { 270 f64[][][] a = [[[]]] 271 } 272 )"); 273 274 ValidateRecord("declaration-3d-array-number.Anno3", R"( 275 .language ECMAScript.record declaration-3d-array-number.Anno3 { 276 f64[][][] a = [[[1, -2, 3], [4, -5, 6]]] 277 } 278 )"); 279 } 280 281 /** 282 * @tc.name: test_declaration_3d_array_string 283 * @tc.desc: validate annotation usage 284 * @tc.type: FUNC 285 * @tc.require: file path and name 286 */ 287 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_3d_array_string, TestSize.Level1) 288 { 289 InitDisasm(FILE_DECLARATION_3D_ARRAY_STRING); 290 291 ValidateRecord("declaration-3d-array-string.Anno1", R"( 292 .language ECMAScript.record declaration-3d-array-string.Anno1 { 293 panda.String[][][] a 294 } 295 )"); 296 297 ValidateRecord("declaration-3d-array-string.Anno2", R"( 298 .language ECMAScript.record declaration-3d-array-string.Anno2 { 299 panda.String[][][] a = [[[]]] 300 } 301 )"); 302 303 ValidateRecord("declaration-3d-array-string.Anno3", R"( 304 .language ECMAScript.record declaration-3d-array-string.Anno3 { 305 panda.String[][][] a = [[["hello", "world"], ["hello", "world"]]] 306 } 307 )"); 308 309 ValidateRecord("panda.String", R"( 310 .language ECMAScript.record panda.String <external> 311 )"); 312 } 313 314 /** 315 * @tc.name: test_declaration_array_boolean 316 * @tc.desc: validate annotation usage 317 * @tc.type: FUNC 318 * @tc.require: file path and name 319 */ 320 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_array_boolean, TestSize.Level1) 321 { 322 InitDisasm(FILE_DECLARATION_ARRAY_BOOLEAN); 323 324 ValidateRecord("declaration-array-boolean.Anno1", R"( 325 .language ECMAScript.record declaration-array-boolean.Anno1 { 326 u1[] a 327 } 328 )"); 329 330 ValidateRecord("declaration-array-boolean.Anno2", R"( 331 .language ECMAScript.record declaration-array-boolean.Anno2 { 332 u1[] a = [] 333 } 334 )"); 335 336 ValidateRecord("declaration-array-boolean.Anno3", R"( 337 .language ECMAScript.record declaration-array-boolean.Anno3 { 338 u1[] a = [1, 0, 1] 339 } 340 )"); 341 } 342 343 /** 344 * @tc.name: test_declaration_array_enum_number 345 * @tc.desc: validate annotation usage 346 * @tc.type: FUNC 347 * @tc.require: file path and name 348 */ 349 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_array_enum_number, TestSize.Level1) 350 { 351 InitDisasm(FILE_DECLARATION_ARRAY_ENUM_NUMBER); 352 353 ValidateRecord("declaration-array-enum-number.Anno1", R"( 354 .language ECMAScript.record declaration-array-enum-number.Anno1 { 355 f64[] a 356 } 357 )"); 358 359 ValidateRecord("declaration-array-enum-number.Anno2", R"( 360 .language ECMAScript.record declaration-array-enum-number.Anno2 { 361 f64[] a = [] 362 } 363 )"); 364 365 ValidateRecord("declaration-array-enum-number.Anno3", R"( 366 .language ECMAScript.record declaration-array-enum-number.Anno3 { 367 f64[] a = [42, -314, 42] 368 } 369 )"); 370 } 371 372 /** 373 * @tc.name: test_declaration_array_enum_string 374 * @tc.desc: validate annotation usage 375 * @tc.type: FUNC 376 * @tc.require: file path and name 377 */ 378 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_array_enum_string, TestSize.Level1) 379 { 380 InitDisasm(FILE_DECLARATION_ARRAY_ENUM_STRING); 381 382 ValidateRecord("declaration-array-enum-string.Anno1", R"( 383 .language ECMAScript.record declaration-array-enum-string.Anno1 { 384 panda.String[] a 385 } 386 )"); 387 388 ValidateRecord("declaration-array-enum-string.Anno2", R"( 389 .language ECMAScript.record declaration-array-enum-string.Anno2 { 390 panda.String[] a = [] 391 } 392 )"); 393 394 ValidateRecord("declaration-array-enum-string.Anno3", R"( 395 .language ECMAScript.record declaration-array-enum-string.Anno3 { 396 panda.String[] a = ["Hello", "world!", "Hello"] 397 } 398 )"); 399 400 ValidateRecord("panda.String", R"( 401 .language ECMAScript.record panda.String <external> 402 )"); 403 } 404 405 /** 406 * @tc.name: test_declaration_array_number 407 * @tc.desc: validate annotation usage 408 * @tc.type: FUNC 409 * @tc.require: file path and name 410 */ 411 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_array_number, TestSize.Level1) 412 { 413 InitDisasm(FILE_DECLARATION_ARRAY_NUMBER); 414 415 ValidateRecord("declaration-array-number.Anno1", R"( 416 .language ECMAScript.record declaration-array-number.Anno1 { 417 f64[] a 418 } 419 )"); 420 421 ValidateRecord("declaration-array-number.Anno2", R"( 422 .language ECMAScript.record declaration-array-number.Anno2 { 423 f64[] a = [] 424 } 425 )"); 426 427 ValidateRecord("declaration-array-number.Anno3", R"( 428 .language ECMAScript.record declaration-array-number.Anno3 { 429 f64[] a = [1, -2, 3] 430 } 431 )"); 432 } 433 434 /** 435 * @tc.name: test_declaration_array_string 436 * @tc.desc: validate annotation usage 437 * @tc.type: FUNC 438 * @tc.require: file path and name 439 */ 440 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_array_string, TestSize.Level1) 441 { 442 InitDisasm(FILE_DECLARATION_ARRAY_STRING); 443 444 ValidateRecord("declaration-array-string.Anno1", R"( 445 .language ECMAScript.record declaration-array-string.Anno1 { 446 panda.String[] a 447 } 448 )"); 449 450 ValidateRecord("declaration-array-string.Anno2", R"( 451 .language ECMAScript.record declaration-array-string.Anno2 { 452 panda.String[] a = [] 453 } 454 )"); 455 456 ValidateRecord("declaration-array-string.Anno3", R"( 457 .language ECMAScript.record declaration-array-string.Anno3 { 458 panda.String[] a = ["Hello", "world", "!"] 459 } 460 )"); 461 462 ValidateRecord("panda.String", R"( 463 .language ECMAScript.record panda.String <external> 464 )"); 465 } 466 467 /** 468 * @tc.name: test_declaration_boolean 469 * @tc.desc: validate annotation usage 470 * @tc.type: FUNC 471 * @tc.require: file path and name 472 */ 473 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_boolean, TestSize.Level1) 474 { 475 InitDisasm(FILE_DECLARATION_BOOLEAN); 476 477 ValidateRecord("declaration-boolean.Anno1", R"( 478 .language ECMAScript.record declaration-boolean.Anno1 { 479 u1 a 480 } 481 )"); 482 483 ValidateRecord("declaration-boolean.Anno2", R"( 484 .language ECMAScript.record declaration-boolean.Anno2 { 485 u1 a = 1 486 } 487 )"); 488 } 489 490 /** 491 * @tc.name: test_declaration_combination 492 * @tc.desc: validate annotation usage 493 * @tc.type: FUNC 494 * @tc.require: file path and name 495 */ 496 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_combination, TestSize.Level1) 497 { 498 InitDisasm(FILE_DECLARATION_COMBINATION); 499 500 ValidateRecord("declaration-combination.Anno", R"( 501 .language ECMAScript.record declaration-combination.Anno { 502 f64 a 503 f64[] b = [13, -10] 504 panda.String c 505 u1 d 506 f64[] e = [1, -2, 3] 507 f64[] f 508 f64 h 509 f64[][][] i 510 panda.String j 511 panda.String[][][] k 512 } 513 )"); 514 515 ValidateRecord("panda.String", R"( 516 .language ECMAScript.record panda.String <external> 517 )"); 518 } 519 520 /** 521 * @tc.name: test_declaration_empty 522 * @tc.desc: validate annotation usage 523 * @tc.type: FUNC 524 * @tc.require: file path and name 525 */ 526 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_empty, TestSize.Level1) 527 { 528 InitDisasm(FILE_DECLARATION_EMPTY); 529 530 ValidateRecord("declaration-empty.Anno", R"( 531 .language ECMAScript.record declaration-empty.Anno { 532 } 533 )"); 534 } 535 536 /** 537 * @tc.name: test_declaration_enum_number 538 * @tc.desc: validate annotation usage 539 * @tc.type: FUNC 540 * @tc.require: file path and name 541 */ 542 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_enum_number, TestSize.Level1) 543 { 544 InitDisasm(FILE_DECLARATION_ENUM_NUMBER); 545 546 ValidateRecord("declaration-enum-number.Anno1", R"( 547 .language ECMAScript.record declaration-enum-number.Anno1 { 548 f64 a 549 } 550 )"); 551 552 ValidateRecord("declaration-enum-number.Anno2", R"( 553 .language ECMAScript.record declaration-enum-number.Anno2 { 554 f64 a = 42 555 } 556 )"); 557 } 558 559 /** 560 * @tc.name: test_declaration_enum_string 561 * @tc.desc: validate annotation usage 562 * @tc.type: FUNC 563 * @tc.require: file path and name 564 */ 565 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_enum_string, TestSize.Level1) 566 { 567 InitDisasm(FILE_DECLARATION_ENUM_STRING); 568 569 ValidateRecord("declaration-enum-string.Anno1", R"( 570 .language ECMAScript.record declaration-enum-string.Anno1 { 571 panda.String a 572 } 573 )"); 574 575 ValidateRecord("declaration-enum-string.Anno2", R"( 576 .language ECMAScript.record declaration-enum-string.Anno2 { 577 panda.String a = "Hello" 578 } 579 )"); 580 581 ValidateRecord("panda.String", R"( 582 .language ECMAScript.record panda.String <external> 583 )"); 584 } 585 586 /** 587 * @tc.name: test_declaration_number 588 * @tc.desc: validate annotation usage 589 * @tc.type: FUNC 590 * @tc.require: file path and name 591 */ 592 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_number, TestSize.Level1) 593 { 594 InitDisasm(FILE_DECLARATION_NUMBER); 595 596 ValidateRecord("declaration-number.Anno1", R"( 597 .language ECMAScript.record declaration-number.Anno1 { 598 f64 a 599 } 600 )"); 601 602 ValidateRecord("declaration-number.Anno2", R"( 603 .language ECMAScript.record declaration-number.Anno2 { 604 f64 a = 42 605 } 606 )"); 607 608 ValidateRecord("declaration-number.Anno3", R"( 609 .language ECMAScript.record declaration-number.Anno3 { 610 f64 a = -314 611 } 612 )"); 613 } 614 615 /** 616 * @tc.name: test_declaration_string 617 * @tc.desc: validate annotation usage 618 * @tc.type: FUNC 619 * @tc.require: file path and name 620 */ 621 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_string, TestSize.Level1) 622 { 623 InitDisasm(FILE_DECLARATION_STRING); 624 625 ValidateRecord("declaration-string.Anno1", R"( 626 .language ECMAScript.record declaration-string.Anno1 { 627 panda.String a 628 } 629 )"); 630 631 ValidateRecord("declaration-string.Anno2", R"( 632 .language ECMAScript.record declaration-string.Anno2 { 633 panda.String a = "Hello world!" 634 } 635 )"); 636 637 ValidateRecord("panda.String", R"( 638 .language ECMAScript.record panda.String <external> 639 )"); 640 } 641 642 /** 643 * @tc.name: test_declaration_usage_3d_array_boolean 644 * @tc.desc: validate annotation usage 645 * @tc.type: FUNC 646 * @tc.require: file path and name 647 */ 648 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_usage_3d_array_boolean, TestSize.Level1) 649 { 650 InitDisasm(FILE_DECLARATION_USAGE_3D_ARRAY_BOOLEAN); 651 652 ValidateRecord("declaration-usage-3d-array-boolean.Anno", R"( 653 .language ECMAScript.record declaration-usage-3d-array-boolean.Anno { 654 u1[][][] a 655 } 656 )"); 657 658 ValidateMethodAnnotation("declaration-usage-3d-array-boolean.#~A=#A", "Ldeclaration-usage-3d-array-boolean.Anno", 659 R"( 660 Ldeclaration-usage-3d-array-boolean.Anno: 661 u1[][][] a { [[[1, 0, 1]]] } 662 )"); 663 664 ValidateMethodAnnotation("declaration-usage-3d-array-boolean.#~A>#foo", 665 "Ldeclaration-usage-3d-array-boolean.Anno", R"( 666 Ldeclaration-usage-3d-array-boolean.Anno: 667 u1[][][] a { [[[]]] } 668 )"); 669 } 670 671 /** 672 * @tc.name: test_declaration_usage_3d_array_enum_number 673 * @tc.desc: validate annotation usage 674 * @tc.type: FUNC 675 * @tc.require: file path and name 676 */ 677 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_usage_3d_array_enum_number, TestSize.Level1) 678 { 679 InitDisasm(FILE_DECLARATION_USAGE_3D_ARRAY_ENUM_NUMBER); 680 681 ValidateRecord("declaration-usage-3d-array-enum-number.Anno", R"( 682 .language ECMAScript.record declaration-usage-3d-array-enum-number.Anno { 683 f64[][][] a 684 } 685 )"); 686 687 ValidateMethodAnnotation("declaration-usage-3d-array-enum-number.#~A=#A", 688 "Ldeclaration-usage-3d-array-enum-number.Anno", R"( 689 Ldeclaration-usage-3d-array-enum-number.Anno: 690 f64[][][] a { [[[1, -2, 1]]] } 691 )"); 692 693 ValidateMethodAnnotation("declaration-usage-3d-array-enum-number.#~A>#foo", 694 "Ldeclaration-usage-3d-array-enum-number.Anno", R"( 695 Ldeclaration-usage-3d-array-enum-number.Anno: 696 f64[][][] a { [[[]]] } 697 )"); 698 } 699 700 /** 701 * @tc.name: test_declaration_usage_3d_array_enum_string 702 * @tc.desc: validate annotation usage 703 * @tc.type: FUNC 704 * @tc.require: file path and name 705 */ 706 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_usage_3d_array_enum_string, TestSize.Level1) 707 { 708 InitDisasm(FILE_DECLARATION_USAGE_3D_ARRAY_ENUM_STRING); 709 710 ValidateRecord("declaration-usage-3d-array-enum-string.Anno", R"( 711 .language ECMAScript.record declaration-usage-3d-array-enum-string.Anno { 712 panda.String[][][] a 713 } 714 )"); 715 716 ValidateRecord("panda.String", R"( 717 .language ECMAScript.record panda.String <external> 718 )"); 719 720 ValidateMethodAnnotation("declaration-usage-3d-array-enum-string.#~A=#A", 721 "Ldeclaration-usage-3d-array-enum-string.Anno", R"( 722 Ldeclaration-usage-3d-array-enum-string.Anno: 723 panda.String[][][] a { [[["Hello", "world", "Hello"]]] } 724 )"); 725 726 ValidateMethodAnnotation("declaration-usage-3d-array-enum-string.#~A>#foo", 727 "Ldeclaration-usage-3d-array-enum-string.Anno", R"( 728 Ldeclaration-usage-3d-array-enum-string.Anno: 729 panda.String[][][] a { [[[]]] } 730 )"); 731 } 732 733 /** 734 * @tc.name: test_declaration_usage_3d_array_number 735 * @tc.desc: validate annotation usage 736 * @tc.type: FUNC 737 * @tc.require: file path and name 738 */ 739 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_usage_3d_array_number, TestSize.Level1) 740 { 741 InitDisasm(FILE_DECLARATION_USAGE_3D_ARRAY_NUMBER); 742 743 ValidateRecord("declaration-usage-3d-array-number.Anno", R"( 744 .language ECMAScript.record declaration-usage-3d-array-number.Anno { 745 f64[][][] a 746 } 747 )"); 748 749 ValidateMethodAnnotation("declaration-usage-3d-array-number.#~A=#A", 750 "Ldeclaration-usage-3d-array-number.Anno", R"( 751 Ldeclaration-usage-3d-array-number.Anno: 752 f64[][][] a { [[[1, -2, 3]]] } 753 )"); 754 755 ValidateMethodAnnotation("declaration-usage-3d-array-number.#~A>#foo", 756 "Ldeclaration-usage-3d-array-number.Anno", R"( 757 Ldeclaration-usage-3d-array-number.Anno: 758 f64[][][] a { [[[]]] } 759 )"); 760 } 761 762 /** 763 * @tc.name: test_declaration_usage_3d_array_string 764 * @tc.desc: validate annotation usage 765 * @tc.type: FUNC 766 * @tc.require: file path and name 767 */ 768 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_usage_3d_array_string, TestSize.Level1) 769 { 770 InitDisasm(FILE_DECLARATION_USAGE_3D_ARRAY_STRING); 771 772 ValidateRecord("declaration-usage-3d-array-string.Anno", R"( 773 .language ECMAScript.record declaration-usage-3d-array-string.Anno { 774 panda.String[][][] a 775 } 776 )"); 777 778 ValidateRecord("panda.String", R"( 779 .language ECMAScript.record panda.String <external> 780 )"); 781 782 ValidateMethodAnnotation("declaration-usage-3d-array-string.#~A=#A", 783 "Ldeclaration-usage-3d-array-string.Anno", R"( 784 Ldeclaration-usage-3d-array-string.Anno: 785 panda.String[][][] a { [[["Hello", "world", "!"]]] } 786 )"); 787 788 ValidateMethodAnnotation("declaration-usage-3d-array-string.#~A>#foo", 789 "Ldeclaration-usage-3d-array-string.Anno", R"( 790 Ldeclaration-usage-3d-array-string.Anno: 791 panda.String[][][] a { [[[]]] } 792 )"); 793 } 794 795 /** 796 * @tc.name: test_declaration_usage_array_boolean 797 * @tc.desc: validate annotation usage 798 * @tc.type: FUNC 799 * @tc.require: file path and name 800 */ 801 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_usage_array_boolean, TestSize.Level1) 802 { 803 InitDisasm(FILE_DECLARATION_USAGE_ARRAY_BOOLEAN); 804 805 ValidateRecord("declaration-usage-array-boolean.Anno", R"( 806 .language ECMAScript.record declaration-usage-array-boolean.Anno { 807 u1[] a 808 } 809 )"); 810 811 ValidateMethodAnnotation("declaration-usage-array-boolean.#~A=#A", 812 "Ldeclaration-usage-array-boolean.Anno", R"( 813 Ldeclaration-usage-array-boolean.Anno: 814 u1[] a { [1, 0, 1] } 815 )"); 816 817 ValidateMethodAnnotation("declaration-usage-array-boolean.#~A>#foo", 818 "Ldeclaration-usage-array-boolean.Anno", R"( 819 Ldeclaration-usage-array-boolean.Anno: 820 u1[] a { [] } 821 )"); 822 } 823 824 /** 825 * @tc.name: test_declaration_usage_array_enum_number 826 * @tc.desc: validate annotation usage 827 * @tc.type: FUNC 828 * @tc.require: file path and name 829 */ 830 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_usage_array_enum_number, TestSize.Level1) 831 { 832 InitDisasm(FILE_DECLARATION_USAGE_ARRAY_ENUM_NUMBER); 833 834 ValidateRecord("declaration-usage-array-enum-number.Anno", R"( 835 .language ECMAScript.record declaration-usage-array-enum-number.Anno { 836 f64[] a 837 } 838 )"); 839 840 ValidateMethodAnnotation("declaration-usage-array-enum-number.#~A=#A", 841 "Ldeclaration-usage-array-enum-number.Anno", R"( 842 Ldeclaration-usage-array-enum-number.Anno: 843 f64[] a { [1, -2, 1] } 844 )"); 845 846 ValidateMethodAnnotation("declaration-usage-array-enum-number.#~A>#foo", 847 "Ldeclaration-usage-array-enum-number.Anno", R"( 848 Ldeclaration-usage-array-enum-number.Anno: 849 f64[] a { [] } 850 )"); 851 } 852 853 /** 854 * @tc.name: test_declaration_usage_array_enum_string 855 * @tc.desc: validate annotation usage 856 * @tc.type: FUNC 857 * @tc.require: file path and name 858 */ 859 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_usage_array_enum_string, TestSize.Level1) 860 { 861 InitDisasm(FILE_DECLARATION_USAGE_ARRAY_ENUM_STRING); 862 863 ValidateRecord("declaration-usage-array-enum-string.Anno", R"( 864 .language ECMAScript.record declaration-usage-array-enum-string.Anno { 865 panda.String[] a 866 } 867 )"); 868 869 ValidateRecord("panda.String", R"( 870 .language ECMAScript.record panda.String <external> 871 )"); 872 873 ValidateMethodAnnotation("declaration-usage-array-enum-string.#~A=#A", 874 "Ldeclaration-usage-array-enum-string.Anno", R"( 875 Ldeclaration-usage-array-enum-string.Anno: 876 panda.String[] a { ["Hello", "world", "Hello"] } 877 )"); 878 879 ValidateMethodAnnotation("declaration-usage-array-enum-string.#~A>#foo", 880 "Ldeclaration-usage-array-enum-string.Anno", R"( 881 Ldeclaration-usage-array-enum-string.Anno: 882 panda.String[] a { [] } 883 )"); 884 } 885 886 /** 887 * @tc.name: test_declaration_usage_array_number 888 * @tc.desc: validate annotation usage 889 * @tc.type: FUNC 890 * @tc.require: file path and name 891 */ 892 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_usage_array_number, TestSize.Level1) 893 { 894 InitDisasm(FILE_DECLARATION_USAGE_ARRAY_NUMBER); 895 896 ValidateRecord("declaration-usage-array-number.Anno", R"( 897 .language ECMAScript.record declaration-usage-array-number.Anno { 898 f64[] a 899 } 900 )"); 901 902 ValidateMethodAnnotation("declaration-usage-array-number.#~A=#A", "Ldeclaration-usage-array-number.Anno", R"( 903 Ldeclaration-usage-array-number.Anno: 904 f64[] a { [1, -2, 3] } 905 )"); 906 907 ValidateMethodAnnotation("declaration-usage-array-number.#~A>#foo", "Ldeclaration-usage-array-number.Anno", R"( 908 Ldeclaration-usage-array-number.Anno: 909 f64[] a { [] } 910 )"); 911 } 912 913 /** 914 * @tc.name: test_declaration_usage_array_string 915 * @tc.desc: validate annotation usage 916 * @tc.type: FUNC 917 * @tc.require: file path and name 918 */ 919 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_usage_array_string, TestSize.Level1) 920 { 921 InitDisasm(FILE_DECLARATION_USAGE_ARRAY_STRING); 922 923 ValidateRecord("declaration-usage-array-string.Anno", R"( 924 .language ECMAScript.record declaration-usage-array-string.Anno { 925 panda.String[] a 926 } 927 )"); 928 929 ValidateRecord("panda.String", R"( 930 .language ECMAScript.record panda.String <external> 931 )"); 932 933 ValidateMethodAnnotation("declaration-usage-array-string.#~A=#A", "Ldeclaration-usage-array-string.Anno", R"( 934 Ldeclaration-usage-array-string.Anno: 935 panda.String[] a { ["hello", "world", "!"] } 936 )"); 937 938 ValidateMethodAnnotation("declaration-usage-array-string.#~A>#foo", "Ldeclaration-usage-array-string.Anno", R"( 939 Ldeclaration-usage-array-string.Anno: 940 panda.String[] a { [] } 941 )"); 942 } 943 944 /** 945 * @tc.name: test_declaration_usage_boolean 946 * @tc.desc: validate annotation usage 947 * @tc.type: FUNC 948 * @tc.require: file path and name 949 */ 950 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_usage_boolean, TestSize.Level1) 951 { 952 InitDisasm(FILE_DECLARATION_USAGE_BOOLEAN); 953 954 ValidateRecord("declaration-usage-boolean.Anno", R"( 955 .language ECMAScript.record declaration-usage-boolean.Anno { 956 u1 a 957 } 958 )"); 959 960 ValidateMethodAnnotation("declaration-usage-boolean.#~A=#A", "Ldeclaration-usage-boolean.Anno", R"( 961 Ldeclaration-usage-boolean.Anno: 962 u1 a { 1 } 963 )"); 964 965 ValidateMethodAnnotation("declaration-usage-boolean.#~A>#foo", "Ldeclaration-usage-boolean.Anno", R"( 966 Ldeclaration-usage-boolean.Anno: 967 u1 a { 0 } 968 )"); 969 } 970 971 /** 972 * @tc.name: test_declaration_usage_combination 973 * @tc.desc: validate annotation usage 974 * @tc.type: FUNC 975 * @tc.require: file path and name 976 */ 977 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_usage_combination, TestSize.Level1) 978 { 979 InitDisasm(FILE_DECLARATION_USAGE_COMBINATION); 980 981 ValidateRecord("declaration-usage-combination.Anno", R"( 982 .language ECMAScript.record declaration-usage-combination.Anno { 983 f64 a 984 f64[] b = [13, -10] 985 panda.String c 986 u1 d 987 f64[] e = [1, -2, 3] 988 f64[] f 989 f64 h 990 f64[][][] i 991 panda.String j 992 panda.String[][][] k 993 } 994 )"); 995 996 ValidateMethodAnnotation("declaration-usage-combination.#~A=#A", "Ldeclaration-usage-combination.Anno", R"( 997 Ldeclaration-usage-combination.Anno: 998 f64 a { 20 } 999 f64[] b { [-13, 10] } 1000 panda.String c { "ab" } 1001 u1 d { 1 } 1002 f64[] e { [-1, 2, 3] } 1003 f64[] f { [] } 1004 f64[][][] g { [[[0]]] } 1005 f64 h { 10 } 1006 f64[][][] i { [[[]]] } 1007 panda.String j { "B" } 1008 panda.String[][][] k { [[[]]] } 1009 )"); 1010 1011 ValidateMethodAnnotation("declaration-usage-combination.#~A>#foo", "Ldeclaration-usage-combination.Anno", R"( 1012 Ldeclaration-usage-combination.Anno: 1013 f64 a { -10 } 1014 f64[] b { [1, 2, -3] } 1015 panda.String c { "cde" } 1016 u1 d { 1 } 1017 f64[] e { [1, -2, 3] } 1018 f64[] f { [1] } 1019 f64[][][] g { [[[0], [1]]] } 1020 f64 h { -10 } 1021 f64[][][] i { [[[10], [20]]] } 1022 panda.String j { "B" } 1023 panda.String[][][] k { [[["A"], ["B"]]] } 1024 )"); 1025 } 1026 1027 /** 1028 * @tc.name: test_declaration_usage_empty 1029 * @tc.desc: validate annotation usage 1030 * @tc.type: FUNC 1031 * @tc.require: file path and name 1032 */ 1033 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_usage_empty, TestSize.Level1) 1034 { 1035 InitDisasm(FILE_DECLARATION_USAGE_EMPTY); 1036 1037 ValidateRecord("declaration-usage-empty.Anno", R"( 1038 .language ECMAScript.record declaration-usage-empty.Anno { 1039 } 1040 )"); 1041 1042 ValidateMethodAnnotation("declaration-usage-empty.#~A=#A", "Ldeclaration-usage-empty.Anno", R"( 1043 Ldeclaration-usage-empty.Anno: 1044 )"); 1045 1046 ValidateMethodAnnotation("declaration-usage-empty.#~A>#foo", "Ldeclaration-usage-empty.Anno", R"( 1047 Ldeclaration-usage-empty.Anno: 1048 )"); 1049 1050 ValidateMethodAnnotation("declaration-usage-empty.#~A>#bar", "Ldeclaration-usage-empty.Anno", R"( 1051 Ldeclaration-usage-empty.Anno: 1052 )"); 1053 } 1054 1055 /** 1056 * @tc.name: test_declaration_usage_enum_number 1057 * @tc.desc: validate annotation usage 1058 * @tc.type: FUNC 1059 * @tc.require: file path and name 1060 */ 1061 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_usage_enum_number, TestSize.Level1) 1062 { 1063 InitDisasm(FILE_DECLARATION_USAGE_ENUM_NUMBER); 1064 1065 ValidateRecord("declaration-usage-enum-number.Anno", R"( 1066 .language ECMAScript.record declaration-usage-enum-number.Anno { 1067 f64 a 1068 } 1069 )"); 1070 1071 ValidateMethodAnnotation("declaration-usage-enum-number.#~A=#A", "Ldeclaration-usage-enum-number.Anno", R"( 1072 Ldeclaration-usage-enum-number.Anno: 1073 f64 a { 1 } 1074 )"); 1075 1076 ValidateMethodAnnotation("declaration-usage-enum-number.#~A>#foo", "Ldeclaration-usage-enum-number.Anno", R"( 1077 Ldeclaration-usage-enum-number.Anno: 1078 f64 a { -2 } 1079 )"); 1080 } 1081 1082 /** 1083 * @tc.name: test_declaration_usage_enum_string 1084 * @tc.desc: validate annotation usage 1085 * @tc.type: FUNC 1086 * @tc.require: file path and name 1087 */ 1088 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_usage_enum_string, TestSize.Level1) 1089 { 1090 InitDisasm(FILE_DECLARATION_USAGE_ENUM_STRING); 1091 1092 ValidateRecord("declaration-usage-enum-string.Anno", R"( 1093 .language ECMAScript.record declaration-usage-enum-string.Anno { 1094 panda.String a 1095 } 1096 )"); 1097 1098 ValidateRecord("panda.String", R"( 1099 .language ECMAScript.record panda.String <external> 1100 )"); 1101 1102 ValidateMethodAnnotation("declaration-usage-enum-string.#~A=#A", "Ldeclaration-usage-enum-string.Anno", R"( 1103 Ldeclaration-usage-enum-string.Anno: 1104 panda.String a { "Hello" } 1105 )"); 1106 1107 ValidateMethodAnnotation("declaration-usage-enum-string.#~A>#foo", "Ldeclaration-usage-enum-string.Anno", R"( 1108 Ldeclaration-usage-enum-string.Anno: 1109 panda.String a { "world" } 1110 )"); 1111 } 1112 1113 /** 1114 * @tc.name: test_declaration_usage_number 1115 * @tc.desc: validate annotation usage 1116 * @tc.type: FUNC 1117 * @tc.require: file path and name 1118 */ 1119 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_usage_number, TestSize.Level1) 1120 { 1121 InitDisasm(FILE_DECLARATION_USAGE_NUMBER); 1122 1123 ValidateRecord("declaration-usage-number.Anno", R"( 1124 .language ECMAScript.record declaration-usage-number.Anno { 1125 f64 a 1126 } 1127 )"); 1128 1129 ValidateMethodAnnotation("declaration-usage-number.#~A=#A", "Ldeclaration-usage-number.Anno", R"( 1130 Ldeclaration-usage-number.Anno: 1131 f64 a { 42 } 1132 )"); 1133 1134 ValidateMethodAnnotation("declaration-usage-number.#~A>#foo", "Ldeclaration-usage-number.Anno", R"( 1135 Ldeclaration-usage-number.Anno: 1136 f64 a { -314 } 1137 )"); 1138 } 1139 1140 /** 1141 * @tc.name: test_declaration_usage_string 1142 * @tc.desc: validate annotation usage 1143 * @tc.type: FUNC 1144 * @tc.require: file path and name 1145 */ 1146 HWTEST_F(DisassemblerUserAnnotationTest, test_declaration_usage_string, TestSize.Level1) 1147 { 1148 InitDisasm(FILE_DECLARATION_USAGE_STRING); 1149 1150 ValidateRecord("declaration-usage-string.Anno", R"( 1151 .language ECMAScript.record declaration-usage-string.Anno { 1152 panda.String a 1153 } 1154 )"); 1155 1156 ValidateRecord("panda.String", R"( 1157 .language ECMAScript.record panda.String <external> 1158 )"); 1159 1160 ValidateMethodAnnotation("declaration-usage-string.#~A=#A", "Ldeclaration-usage-string.Anno", R"( 1161 Ldeclaration-usage-string.Anno: 1162 panda.String a { "Hello" } 1163 )"); 1164 1165 ValidateMethodAnnotation("declaration-usage-string.#~A>#foo", "Ldeclaration-usage-string.Anno", R"( 1166 Ldeclaration-usage-string.Anno: 1167 panda.String a { "world" } 1168 )"); 1169 } 1170 1171 /** 1172 * @tc.name: test_export 1173 * @tc.desc: validate annotation usage 1174 * @tc.type: FUNC 1175 * @tc.require: file path and name 1176 */ 1177 HWTEST_F(DisassemblerUserAnnotationTest, test_export, TestSize.Level1) 1178 { 1179 InitDisasm(FILE_EXPORT); 1180 1181 ValidateRecord("export.Anno1", R"( 1182 .language ECMAScript.record export.Anno1 { 1183 } 1184 )"); 1185 1186 ValidateRecord("export.Anno2", R"( 1187 .language ECMAScript.record export.Anno2 { 1188 f64 a = 0 1189 } 1190 )"); 1191 1192 ValidateMethodAnnotation("export.#~A=#A", "Lexport.Anno1", R"( 1193 Lexport.Anno1: 1194 )"); 1195 1196 ValidateMethodAnnotation("export.#~B=#B", "Lexport.Anno1", R"( 1197 Lexport.Anno1: 1198 )"); 1199 } 1200 1201 /** 1202 * @tc.name: test_import_qualified 1203 * @tc.desc: validate annotation usage 1204 * @tc.type: FUNC 1205 * @tc.require: file path and name 1206 */ 1207 HWTEST_F(DisassemblerUserAnnotationTest, test_import_qualified, TestSize.Level1) 1208 { 1209 InitDisasm(FILE_IMPORT_QUALIFIED); 1210 1211 ValidateRecord("import-qualified.Namespace1.Anno", R"( 1212 .language ECMAScript.record import-qualified.Namespace1.Anno <external> 1213 )"); 1214 1215 ValidateRecord("import-qualified.Namespace1.Anno1", R"( 1216 .language ECMAScript.record import-qualified.Namespace1.Anno1 <external> 1217 )"); 1218 1219 ValidateRecord("import-qualified.Namespace1.Namespace2.Namespace3.Anno2", R"( 1220 .language ECMAScript.record import-qualified.Namespace1.Namespace2.Namespace3.Anno2 <external> 1221 )"); 1222 1223 ValidateRecord("import-qualified.Namespace1.Namespace2.Namespace3.Anno3", R"( 1224 .language ECMAScript.record import-qualified.Namespace1.Namespace2.Namespace3.Anno3 <external> 1225 )"); 1226 1227 ValidateMethodAnnotation("import-qualified.#~A=#A", "Limport-qualified.Namespace1.Anno", R"( 1228 Limport-qualified.Namespace1.Anno: 1229 )"); 1230 1231 ValidateMethodAnnotation("import-qualified.#~B=#B", "Limport-qualified.Namespace1.Anno", R"( 1232 Limport-qualified.Namespace1.Anno: 1233 )"); 1234 1235 ValidateMethodAnnotation("import-qualified.#~C=#C", "Limport-qualified.Namespace1.Anno1", R"( 1236 Limport-qualified.Namespace1.Anno1: 1237 f64 a { 1 } 1238 panda.String b { "string" } 1239 )"); 1240 1241 ValidateMethodAnnotation("import-qualified.#~D=#D", "Limport-qualified.Namespace1.Namespace2.Namespace3.Anno2", 1242 R"( 1243 Limport-qualified.Namespace1.Namespace2.Namespace3.Anno2: 1244 )"); 1245 1246 ValidateMethodAnnotation("import-qualified.#~E=#E", "Limport-qualified.Namespace1.Namespace2.Namespace3.Anno2", 1247 R"( 1248 Limport-qualified.Namespace1.Namespace2.Namespace3.Anno2: 1249 )"); 1250 } 1251 1252 /** 1253 * @tc.name: test_import_unqualified 1254 * @tc.desc: validate annotation usage 1255 * @tc.type: FUNC 1256 * @tc.require: file path and name 1257 */ 1258 HWTEST_F(DisassemblerUserAnnotationTest, test_import_unqualified, TestSize.Level1) 1259 { 1260 InitDisasm(FILE_IMPORT_UNQUALIFIED); 1261 1262 ValidateRecord("import-unqualified.Anno1", R"( 1263 .language ECMAScript.record import-unqualified.Anno1 <external> 1264 )"); 1265 1266 ValidateRecord("import-unqualified.Anno2", R"( 1267 .language ECMAScript.record import-unqualified.Anno2 <external> 1268 )"); 1269 1270 ValidateMethodAnnotation("import-unqualified.#~A=#A", "Limport-unqualified.Anno1", R"( 1271 Limport-unqualified.Anno1: 1272 )"); 1273 1274 ValidateMethodAnnotation("import-unqualified.#~B=#B", "Limport-unqualified.Anno1", R"( 1275 Limport-unqualified.Anno1: 1276 )"); 1277 1278 ValidateMethodAnnotation("import-unqualified.#~C=#C", "Limport-unqualified.Anno1", R"( 1279 Limport-unqualified.Anno1: 1280 )"); 1281 1282 ValidateMethodAnnotation("import-unqualified.#~D=#D", "Limport-unqualified.Anno2", R"( 1283 Limport-unqualified.Anno2: 1284 f64 a { 1 } 1285 panda.String b { "string" } 1286 )"); 1287 } 1288 1289 /** 1290 * @tc.name: test_multiple_annotations 1291 * @tc.desc: validate annotation usage 1292 * @tc.type: FUNC 1293 * @tc.require: file path and name 1294 */ 1295 HWTEST_F(DisassemblerUserAnnotationTest, test_multiple_annotations, TestSize.Level1) 1296 { 1297 InitDisasm(FILE_MULTIPLE_ANNOTATIONS); 1298 1299 ValidateRecord("multiple-annotations.Anno1", R"( 1300 .language ECMAScript.record multiple-annotations.Anno1 { 1301 f64 a = 1 1302 } 1303 )"); 1304 1305 ValidateRecord("multiple-annotations.Anno2", R"( 1306 .language ECMAScript.record multiple-annotations.Anno2 { 1307 panda.String b = "string" 1308 } 1309 )"); 1310 1311 ValidateRecord("multiple-annotations.Anno3", R"( 1312 .language ECMAScript.record multiple-annotations.Anno3 { 1313 u1[] c = [1, 0] 1314 } 1315 )"); 1316 1317 ValidateMethodAnnotation("multiple-annotations.#~A=#A", "Lmultiple-annotations.Anno1", R"( 1318 Lmultiple-annotations.Anno1: 1319 f64 a { 42 } 1320 )"); 1321 1322 ValidateMethodAnnotation("multiple-annotations.#~A=#A", "Lmultiple-annotations.Anno2", R"( 1323 Lmultiple-annotations.Anno2: 1324 panda.String b { "abc" } 1325 )"); 1326 1327 ValidateMethodAnnotation("multiple-annotations.#~A=#A", "Lmultiple-annotations.Anno3", R"( 1328 Lmultiple-annotations.Anno3: 1329 u1[] c { [0, 1] } 1330 )"); 1331 1332 ValidateMethodAnnotation("multiple-annotations.#~A>#foo", "Lmultiple-annotations.Anno1", R"( 1333 Lmultiple-annotations.Anno1: 1334 f64 a { 42 } 1335 )"); 1336 1337 ValidateMethodAnnotation("multiple-annotations.#~A>#foo", "Lmultiple-annotations.Anno2", R"( 1338 Lmultiple-annotations.Anno2: 1339 panda.String b { "abc" } 1340 )"); 1341 1342 ValidateMethodAnnotation("multiple-annotations.#~A>#foo", "Lmultiple-annotations.Anno3", R"( 1343 Lmultiple-annotations.Anno3: 1344 u1[] c { [0, 1] } 1345 )"); 1346 } 1347 1348 }; 1349