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 #include "file.h" 20 #include "utils.h" 21 22 using namespace testing::ext; 23 24 namespace panda::disasm { 25 class DisassemblerModuleLiteralTest : public testing::Test { 26 public: SetUpTestCase(void)27 static void SetUpTestCase(void) {}; TearDownTestCase(void)28 static void TearDownTestCase(void) {}; SetUp()29 void SetUp() {}; TearDown()30 void TearDown() {}; 31 ValidateModuleLiteral(const std::vector<std::string> & module_literals,const std::vector<std::string> & expected_module_literals)32 bool ValidateModuleLiteral(const std::vector<std::string> &module_literals, 33 const std::vector<std::string> &expected_module_literals) 34 { 35 for (const auto &expected_module_literal : expected_module_literals) { 36 const auto module_iter = std::find(module_literals.begin(), module_literals.end(), expected_module_literal); 37 if (module_iter == module_literals.end()) { 38 return false; 39 } 40 } 41 42 return true; 43 } 44 }; 45 46 /** 47 * @tc.name: disassembler_module_literal_test_001 48 * @tc.desc: get module literal of abc file. 49 * @tc.type: FUNC 50 * @tc.require: file path and name 51 */ 52 HWTEST_F(DisassemblerModuleLiteralTest, disassembler_module_literal_test_001, TestSize.Level1) 53 { 54 const std::string file_name = GRAPH_TEST_ABC_DIR "module-regular-import.abc"; 55 std::vector<std::string> expected_module_literals = { 56 "\tMODULE_REQUEST_ARRAY: {\n\t\t0 : ./module-export-file.js,\n\t}", 57 "\tModuleTag: REGULAR_IMPORT, local_name: a, import_name: a, module_request: ./module-export-file.js" 58 }; 59 panda::disasm::Disassembler disasm {}; 60 disasm.Disassemble(file_name, false, false); 61 std::vector<std::string> module_literals = disasm.GetModuleLiterals(); 62 bool has_module_literal = ValidateModuleLiteral(module_literals, expected_module_literals); 63 EXPECT_TRUE(has_module_literal); 64 } 65 66 /** 67 * @tc.name: disassembler_module_literal_test_002 68 * @tc.desc: get module literal of abc file. 69 * @tc.type: FUNC 70 * @tc.require: file path and name 71 */ 72 HWTEST_F(DisassemblerModuleLiteralTest, disassembler_module_literal_test_002, TestSize.Level1) 73 { 74 const std::string file_name = GRAPH_TEST_ABC_DIR "module-namespace-import.abc"; 75 std::vector<std::string> expected_module_literals = { 76 "\tMODULE_REQUEST_ARRAY: {\n\t\t0 : ./module-export-file.js,\n\t}", 77 "\tModuleTag: NAMESPACE_IMPORT, local_name: ns, module_request: ./module-export-file.js" 78 }; 79 panda::disasm::Disassembler disasm {}; 80 disasm.Disassemble(file_name, false, false); 81 std::vector<std::string> module_literals = disasm.GetModuleLiterals(); 82 bool has_module_literal = ValidateModuleLiteral(module_literals, expected_module_literals); 83 EXPECT_TRUE(has_module_literal); 84 } 85 86 /** 87 * @tc.name: disassembler_module_literal_test_003 88 * @tc.desc: get module literal of abc file. 89 * @tc.type: FUNC 90 * @tc.require: file path and name 91 */ 92 HWTEST_F(DisassemblerModuleLiteralTest, disassembler_module_literal_test_003, TestSize.Level1) 93 { 94 const std::string file_name = GRAPH_TEST_ABC_DIR "module-local-export.abc"; 95 std::vector<std::string> expected_module_literals = { 96 "\tMODULE_REQUEST_ARRAY: {\n\t}", 97 "\tModuleTag: LOCAL_EXPORT, local_name: c, export_name: c" 98 }; 99 panda::disasm::Disassembler disasm {}; 100 disasm.Disassemble(file_name, false, false); 101 std::vector<std::string> module_literals = disasm.GetModuleLiterals(); 102 bool has_module_literal = ValidateModuleLiteral(module_literals, expected_module_literals); 103 EXPECT_TRUE(has_module_literal); 104 } 105 106 /** 107 * @tc.name: disassembler_module_literal_test_004 108 * @tc.desc: get module literal of abc file. 109 * @tc.type: FUNC 110 * @tc.require: file path and name 111 */ 112 HWTEST_F(DisassemblerModuleLiteralTest, disassembler_module_literal_test_004, TestSize.Level1) 113 { 114 const std::string file_name = GRAPH_TEST_ABC_DIR "module-indirect-export.abc"; 115 std::vector<std::string> expected_module_literals = { 116 "\tMODULE_REQUEST_ARRAY: {\n\t\t0 : ./module-import-file.js,\n\t}", 117 "\tModuleTag: INDIRECT_EXPORT, export_name: a, import_name: a, module_request: ./module-import-file.js" 118 }; 119 panda::disasm::Disassembler disasm {}; 120 disasm.Disassemble(file_name, false, false); 121 std::vector<std::string> module_literals = disasm.GetModuleLiterals(); 122 bool has_module_literal = ValidateModuleLiteral(module_literals, expected_module_literals); 123 EXPECT_TRUE(has_module_literal); 124 } 125 126 /** 127 * @tc.name: disassembler_module_literal_test_005 128 * @tc.desc: get module literal of abc file. 129 * @tc.type: FUNC 130 * @tc.require: file path and name 131 */ 132 HWTEST_F(DisassemblerModuleLiteralTest, disassembler_module_literal_test_005, TestSize.Level1) 133 { 134 const std::string file_name = GRAPH_TEST_ABC_DIR "module-start-export.abc"; 135 std::vector<std::string> expected_module_literals = { 136 "\tMODULE_REQUEST_ARRAY: {\n\t\t0 : ./module-import-file.js,\n\t}", 137 "\tModuleTag: STAR_EXPORT, module_request: ./module-import-file.js" 138 }; 139 panda::disasm::Disassembler disasm {}; 140 disasm.Disassemble(file_name, false, false); 141 std::vector<std::string> module_literals = disasm.GetModuleLiterals(); 142 bool has_module_literal = ValidateModuleLiteral(module_literals, expected_module_literals); 143 EXPECT_TRUE(has_module_literal); 144 } 145 146 /** 147 * @tc.name: disassembler_module_literal_test_005 148 * @tc.desc: get module literal of abc file. 149 * @tc.type: FUNC 150 * @tc.require: file path and name 151 */ 152 HWTEST_F(DisassemblerModuleLiteralTest, disassembler_module_literal_test_006, TestSize.Level1) 153 { 154 const std::string file_name = GRAPH_TEST_ABC_DIR "module-regular-import-local-export.abc"; 155 std::vector<std::string> expected_module_literals = { 156 "\tMODULE_REQUEST_ARRAY: {\n\t\t0 : ./module-indirect-export.js,\n\t}", 157 "\tModuleTag: REGULAR_IMPORT, local_name: a, import_name: a, module_request: ./module-indirect-export.js", 158 "\tModuleTag: LOCAL_EXPORT, local_name: b, export_name: b" 159 }; 160 panda::disasm::Disassembler disasm {}; 161 disasm.Disassemble(file_name, false, false); 162 std::vector<std::string> module_literals = disasm.GetModuleLiterals(); 163 bool has_module_literal = ValidateModuleLiteral(module_literals, expected_module_literals); 164 EXPECT_TRUE(has_module_literal); 165 } 166 167 /** 168 * @tc.name: disassembler_module_literal_test_007 169 * @tc.desc: test module reuqire index. 170 * @tc.type: FUNC 171 * @tc.require: file path 172 */ 173 HWTEST_F(DisassemblerModuleLiteralTest, disassembler_module_literal_test_007, TestSize.Level1) 174 { 175 std::vector<std::string> expected_module_literals = { 176 "\tMODULE_REQUEST_ARRAY: {\n\t\t0 : ./module-export-file.js,\n\t}", 177 "\tModuleTag: REGULAR_IMPORT, local_name: a, import_name: a, module_request: ./module-export-file.js"}; 178 179 const std::string file_name = GRAPH_TEST_ABC_DIR "module-regular-import.abc"; 180 std::ifstream baseFile(file_name, std::ios::binary); 181 EXPECT_TRUE(baseFile.is_open()); 182 183 std::vector<unsigned char> buffer(std::istreambuf_iterator<char>(baseFile), {}); 184 // change module request idx 185 buffer[680] = 0xff; 186 buffer[681] = 0xff; 187 188 const std::string targetFileName = GRAPH_TEST_ABC_DIR "module-regular-import-001.abc"; 189 GenerateModifiedAbc(buffer, targetFileName); 190 baseFile.close(); 191 192 panda::disasm::Disassembler disasm {}; 193 disasm.Disassemble(targetFileName, false, false); 194 std::vector<std::string> module_literals = disasm.GetModuleLiterals(); 195 bool has_module_literal = ValidateModuleLiteral(module_literals, expected_module_literals); 196 EXPECT_FALSE(has_module_literal); 197 } 198 } 199