1 /* 2 * Copyright (c) 2023 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 <gtest/gtest.h> 17 #include <string> 18 #include "disassembler.h" 19 20 using namespace testing::ext; 21 22 namespace panda::disasm { 23 class DisassemblerModuleLiteralTest : public testing::Test { 24 public: SetUpTestCase(void)25 static void SetUpTestCase(void) {}; TearDownTestCase(void)26 static void TearDownTestCase(void) {}; SetUp()27 void SetUp() {}; TearDown()28 void TearDown() {}; 29 ValidateModuleLiteral(const std::vector<std::string> & module_literals,const std::vector<std::string> & expected_module_literals)30 bool ValidateModuleLiteral(const std::vector<std::string> &module_literals, 31 const std::vector<std::string> &expected_module_literals) 32 { 33 for (const auto &expected_module_literal : expected_module_literals) { 34 const auto module_iter = std::find(module_literals.begin(), module_literals.end(), expected_module_literal); 35 if (module_iter == module_literals.end()) { 36 return false; 37 } 38 } 39 40 return true; 41 } 42 }; 43 44 /** 45 * @tc.name: disassembler_module_literal_test_001 46 * @tc.desc: get module literal of abc file. 47 * @tc.type: FUNC 48 * @tc.require: file path and name 49 */ 50 HWTEST_F(DisassemblerModuleLiteralTest, disassembler_module_literal_test_001, TestSize.Level1) 51 { 52 const std::string file_name = GRAPH_TEST_ABC_DIR "module-regular-import.abc"; 53 std::vector<std::string> expected_module_literals = { 54 "ModuleTag: REGULAR_IMPORT, local_name: a, import_name: a, module_request: ./module-export-file.js" 55 }; 56 panda::disasm::Disassembler disasm {}; 57 disasm.Disassemble(file_name, false, false); 58 std::vector<std::string> module_literals = disasm.GetModuleLiterals(); 59 bool has_module_literal = ValidateModuleLiteral(module_literals, expected_module_literals); 60 EXPECT_TRUE(has_module_literal); 61 } 62 63 /** 64 * @tc.name: disassembler_module_literal_test_002 65 * @tc.desc: get module literal of abc file. 66 * @tc.type: FUNC 67 * @tc.require: file path and name 68 */ 69 HWTEST_F(DisassemblerModuleLiteralTest, disassembler_module_literal_test_002, TestSize.Level1) 70 { 71 const std::string file_name = GRAPH_TEST_ABC_DIR "module-namespace-import.abc"; 72 std::vector<std::string> expected_module_literals = { 73 "ModuleTag: NAMESPACE_IMPORT, local_name: ns, module_request: ./module-export-file.js" 74 }; 75 panda::disasm::Disassembler disasm {}; 76 disasm.Disassemble(file_name, false, false); 77 std::vector<std::string> module_literals = disasm.GetModuleLiterals(); 78 bool has_module_literal = ValidateModuleLiteral(module_literals, expected_module_literals); 79 EXPECT_TRUE(has_module_literal); 80 } 81 82 /** 83 * @tc.name: disassembler_module_literal_test_003 84 * @tc.desc: get module literal of abc file. 85 * @tc.type: FUNC 86 * @tc.require: file path and name 87 */ 88 HWTEST_F(DisassemblerModuleLiteralTest, disassembler_module_literal_test_003, TestSize.Level1) 89 { 90 const std::string file_name = GRAPH_TEST_ABC_DIR "module-local-export.abc"; 91 std::vector<std::string> expected_module_literals = { 92 "ModuleTag: LOCAL_EXPORT, local_name: c, export_name: c" 93 }; 94 panda::disasm::Disassembler disasm {}; 95 disasm.Disassemble(file_name, false, false); 96 std::vector<std::string> module_literals = disasm.GetModuleLiterals(); 97 bool has_module_literal = ValidateModuleLiteral(module_literals, expected_module_literals); 98 EXPECT_TRUE(has_module_literal); 99 } 100 101 /** 102 * @tc.name: disassembler_module_literal_test_004 103 * @tc.desc: get module literal of abc file. 104 * @tc.type: FUNC 105 * @tc.require: file path and name 106 */ 107 HWTEST_F(DisassemblerModuleLiteralTest, disassembler_module_literal_test_004, TestSize.Level1) 108 { 109 const std::string file_name = GRAPH_TEST_ABC_DIR "module-indirect-export.abc"; 110 std::vector<std::string> expected_module_literals = { 111 "ModuleTag: INDIRECT_EXPORT, export_name: a, import_name: a, module_request: ./module-import-file.js" 112 }; 113 panda::disasm::Disassembler disasm {}; 114 disasm.Disassemble(file_name, false, false); 115 std::vector<std::string> module_literals = disasm.GetModuleLiterals(); 116 bool has_module_literal = ValidateModuleLiteral(module_literals, expected_module_literals); 117 EXPECT_TRUE(has_module_literal); 118 } 119 120 /** 121 * @tc.name: disassembler_module_literal_test_005 122 * @tc.desc: get module literal of abc file. 123 * @tc.type: FUNC 124 * @tc.require: file path and name 125 */ 126 HWTEST_F(DisassemblerModuleLiteralTest, disassembler_module_literal_test_005, TestSize.Level1) 127 { 128 const std::string file_name = GRAPH_TEST_ABC_DIR "module-start-export.abc"; 129 std::vector<std::string> expected_module_literals = { 130 "ModuleTag: STAR_EXPORT, module_request: ./module-import-file.js" 131 }; 132 panda::disasm::Disassembler disasm {}; 133 disasm.Disassemble(file_name, false, false); 134 std::vector<std::string> module_literals = disasm.GetModuleLiterals(); 135 bool has_module_literal = ValidateModuleLiteral(module_literals, expected_module_literals); 136 EXPECT_TRUE(has_module_literal); 137 } 138 } 139