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 19 #include "assembly-parser.h" 20 #include "operand_types_print.h" 21 #include "mangling.h" 22 23 using namespace testing::ext; 24 25 namespace panda::pandasm { 26 27 using namespace panda::pandasm; 28 29 class ParserTest : public testing::Test { 30 }; 31 32 /** 33 * @tc.name: parser_test_001 34 * @tc.desc: Verify the ShowError function. 35 * @tc.type: FUNC 36 * @tc.require: issueNumber 37 */ 38 HWTEST_F(ParserTest, parser_test_001, TestSize.Level1) 39 { 40 std::vector<std::vector<panda::pandasm::Token>> v; 41 Lexer l; 42 Parser p; 43 v.push_back(l.TokenizeString(".function u8 main(){").first); 44 v.push_back(l.TokenizeString("mov v1, v2}").first); 45 auto item = p.Parse(v); 46 47 const auto sig_main = GetFunctionSignatureFromName("main", {}); 48 49 EXPECT_EQ(item.Value().function_table.at(sig_main).ins[0].regs[0], 1) << "1 expected"; 50 EXPECT_EQ(item.Value().function_table.at(sig_main).ins[0].regs[1], 2) << "2 expected"; 51 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_NONE) << "ERR_NONE expected"; 52 } 53 54 /** 55 * @tc.name: parser_test_002 56 * @tc.desc: Verify the ShowError function. 57 * @tc.type: FUNC 58 * @tc.require: issueNumber 59 */ 60 HWTEST_F(ParserTest, parser_test_002, TestSize.Level1) 61 { 62 std::vector<std::vector<panda::pandasm::Token>> v; 63 Lexer l; 64 Parser p; 65 v.push_back(l.TokenizeString(".function u8 main(){").first); 66 v.push_back(l.TokenizeString("label:}").first); 67 auto item = p.Parse(v); 68 69 const auto sig_main = GetFunctionSignatureFromName("main", {}); 70 71 EXPECT_EQ(item.Value().function_table.at(sig_main).ins[0].label, "label") << "label expected"; 72 EXPECT_EQ(item.Value().function_table.at(sig_main).ins[0].set_label, true) << "true expected"; 73 EXPECT_EQ(item.Value().function_table.at(sig_main).ins[0].opcode, Opcode::INVALID) << "NONE expected"; 74 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_NONE) << "ERR_NONE expected"; 75 } 76 77 /** 78 * @tc.name: parser_test_003 79 * @tc.desc: Verify the ShowError function. 80 * @tc.type: FUNC 81 * @tc.require: issueNumber 82 */ 83 HWTEST_F(ParserTest, parser_test_003, TestSize.Level1) 84 { 85 std::vector<std::vector<panda::pandasm::Token>> v; 86 Lexer l; 87 Parser p; 88 v.push_back(l.TokenizeString(".function u8 main(){").first); 89 v.push_back(l.TokenizeString("jlt v10, lab123}").first); 90 auto item = p.Parse(v); 91 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_OPERATION_NAME) << "ERR_BAD_LABEL_EXT expected"; 92 } 93 94 /** 95 * @tc.name: parser_test_004 96 * @tc.desc: Verify the ShowError function. 97 * @tc.type: FUNC 98 * @tc.require: issueNumber 99 */ 100 HWTEST_F(ParserTest, parser_test_004, TestSize.Level1) 101 { 102 std::vector<std::vector<panda::pandasm::Token>> v; 103 Lexer l; 104 Parser p; 105 v.push_back(l.TokenizeString(".function u8 main(){").first); 106 v.push_back(l.TokenizeString("11111111}").first); 107 auto item = p.Parse(v); 108 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_OPERATION_NAME) << "ERR_BAD_OPERATION_NAME expected"; 109 } 110 111 /** 112 * @tc.name: parser_test_005 113 * @tc.desc: Verify the ShowError function. 114 * @tc.type: FUNC 115 * @tc.require: issueNumber 116 */ 117 HWTEST_F(ParserTest, parser_test_005, TestSize.Level1) 118 { 119 std::vector<std::vector<panda::pandasm::Token>> v; 120 Lexer l; 121 Parser p; 122 v.push_back(l.TokenizeString(".function u8 main(){").first); 123 v.push_back(l.TokenizeString("addi 1}").first); 124 auto item = p.Parse(v); 125 126 const auto sig_main = GetFunctionSignatureFromName("main", {}); 127 128 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_OPERATION_NAME) << "ERR_NONE expected"; 129 } 130 131 /** 132 * @tc.name: parser_test_006 133 * @tc.desc: Verify the ShowError function. 134 * @tc.type: FUNC 135 * @tc.require: issueNumber 136 */ 137 HWTEST_F(ParserTest, parser_test_006, TestSize.Level1) 138 { 139 std::vector<std::vector<panda::pandasm::Token>> v; 140 Lexer l; 141 Parser p; 142 v.push_back(l.TokenizeString(".function u8 main(){").first); 143 v.push_back(l.TokenizeString("addi 12345}").first); 144 auto item = p.Parse(v); 145 146 const auto sig_main = GetFunctionSignatureFromName("main", {}); 147 148 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_OPERATION_NAME) << "ERR_NONE expected"; 149 } 150 151 /** 152 * @tc.name: parser_test_007 153 * @tc.desc: Verify the ShowError function. 154 * @tc.type: FUNC 155 * @tc.require: issueNumber 156 */ 157 HWTEST_F(ParserTest, parser_test_007, TestSize.Level1) 158 { 159 std::vector<std::vector<panda::pandasm::Token>> v; 160 Lexer l; 161 Parser p; 162 v.push_back(l.TokenizeString(".function u8 main(){").first); 163 v.push_back(l.TokenizeString("addi 11.3}").first); 164 auto item = p.Parse(v); 165 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_OPERATION_NAME) << "ERR_NONE expected"; 166 } 167 168 /** 169 * @tc.name: parser_test_008 170 * @tc.desc: Verify the ShowError function. 171 * @tc.type: FUNC 172 * @tc.require: issueNumber 173 */ 174 HWTEST_F(ParserTest, parser_test_008, TestSize.Level1) 175 { 176 std::vector<std::vector<panda::pandasm::Token>> v; 177 Lexer l; 178 Parser p; 179 v.push_back(l.TokenizeString(".function u8 main(){").first); 180 v.push_back(l.TokenizeString("ashdjbf iashudbfiun as}").first); 181 auto item = p.Parse(v); 182 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_OPERATION_NAME) << "ERR_BAD_OPERATION expected"; 183 } 184 185 /** 186 * @tc.name: parser_test_009 187 * @tc.desc: Verify the ShowError function. 188 * @tc.type: FUNC 189 * @tc.require: issueNumber 190 */ 191 HWTEST_F(ParserTest, parser_test_009, TestSize.Level1) 192 { 193 const auto source = R"( 194 .function any foo(any a0, any a1, any a2) { 195 mov v0, a0 196 mov v1, a1 197 mov v2, a2 198 sta v4 199 lda v4 200 callarg0 0x1 201 return 202 } 203 )"; 204 panda::pandasm::Parser p; 205 auto res = p.Parse(source, "source"); 206 auto &program = res.Value(); 207 const std::string fun_name = "foo:(any,any,any)"; 208 auto it = program.function_table.find(fun_name); 209 EXPECT_NE(it, program.function_table.end()); 210 auto &func = it->second; 211 EXPECT_NE(func.ins[0].opcode, Opcode::NOP); 212 EXPECT_EQ(func.ins[3].regs[0], 4U); 213 EXPECT_EQ(func.ins[1].regs[0], 1U); 214 EXPECT_EQ(func.ins[5].imms[0], Ins::IType(int64_t(0x1))); 215 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_NONE) << "ERR_NONE expected"; 216 } 217 218 /** 219 * @tc.name: parser_test_010 220 * @tc.desc: Verify the ShowError function. 221 * @tc.type: FUNC 222 * @tc.require: issueNumber 223 */ 224 HWTEST_F(ParserTest, parser_test_010, TestSize.Level1) 225 { 226 Parser p; 227 const auto source = R"( 228 .function any func(any a0, any a1, any a2) <static> { 229 mov v0, a0 230 mov v1, a1 231 mov v2, a2 232 ldglobalvar 0x0, "foo" 233 sta v4 234 lda v4 235 callarg0 0x1 236 return 237 } 238 239 .function any foo(any a0, any a1, any a2) <static> { 240 mov v0, a0 241 mov v1, a1 242 mov v2, a2 243 ldai 0x1 244 sta v3 245 ldundefined 246 returnundefined 247 } 248 )"; 249 auto item = p.Parse(source); 250 GetFunctionSignatureFromName("func", {}); 251 const std::string func_name = "func:(any,any,any)"; 252 auto it = item.Value().function_table.find(func_name); 253 EXPECT_NE(it, item.Value().function_table.end()); 254 EXPECT_EQ(item.Value().function_table.at(func_name).ins[3].ids[0], "foo") << "nain expected"; 255 EXPECT_EQ(item.Value().function_table.at(func_name).ins[0].regs[0], 0) << "1 expected"; 256 EXPECT_EQ(item.Value().function_table.at(func_name).ins[0].regs[1], 5) << "2 expected"; 257 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_NONE) << "ERR_NONE expected"; 258 } 259 260 /** 261 * @tc.name: parser_test_011 262 * @tc.desc: Verify the ShowError function. 263 * @tc.type: FUNC 264 * @tc.require: issueNumber 265 */ 266 HWTEST_F(ParserTest, parser_test_011, TestSize.Level1) 267 { 268 std::vector<std::vector<panda::pandasm::Token>> v; 269 Lexer l; 270 Parser p; 271 v.push_back(l.TokenizeString(".function u8 main(){").first); 272 v.push_back(l.TokenizeString("i64tof64}").first); 273 auto item = p.Parse(v); 274 275 const auto sig_main = GetFunctionSignatureFromName("main", {}); 276 277 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_OPERATION_NAME); 278 } 279 280 /** 281 * @tc.name: parser_test_012 282 * @tc.desc: Verify the ShowError function. 283 * @tc.type: FUNC 284 * @tc.require: issueNumber 285 */ 286 HWTEST_F(ParserTest, parser_test_012, TestSize.Level1) 287 { 288 std::vector<std::vector<panda::pandasm::Token>> v; 289 Lexer l; 290 Parser p; 291 v.push_back(l.TokenizeString(".function u8 main(){").first); 292 v.push_back(l.TokenizeString("jmp l123}").first); 293 auto item = p.Parse(v); 294 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_LABEL_EXT) << "ERR_BAD_LABEL_EXT expected"; 295 } 296 297 /** 298 * @tc.name: parser_test_013 299 * @tc.desc: Verify the ShowError function. 300 * @tc.type: FUNC 301 * @tc.require: issueNumber 302 */ 303 HWTEST_F(ParserTest, parser_test_013, TestSize.Level1) 304 { 305 std::vector<std::vector<panda::pandasm::Token>> v; 306 Lexer l; 307 Parser p; 308 v.push_back(l.TokenizeString(".function u8 main(){").first); 309 v.push_back(l.TokenizeString("l123: jmp l123}").first); 310 auto item = p.Parse(v); 311 312 const auto sig_main = GetFunctionSignatureFromName("main", {}); 313 314 EXPECT_EQ(item.Value().function_table.at(sig_main).ins[0].opcode, Opcode::JMP) << "ID expected"; 315 EXPECT_EQ(item.Value().function_table.at(sig_main).ins[0].ids[0], "l123") << "l123 expected"; 316 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_NONE) << "ERR_NONE"; 317 } 318 319 /** 320 * @tc.name: parser_test_014 321 * @tc.desc: Verify the ShowError function. 322 * @tc.type: FUNC 323 * @tc.require: issueNumber 324 */ 325 HWTEST_F(ParserTest, parser_test_014, TestSize.Level1) 326 { 327 std::vector<std::vector<panda::pandasm::Token>> v; 328 Lexer l; 329 Parser p; 330 v.push_back(l.TokenizeString(".function u8 main(){").first); 331 v.push_back(l.TokenizeString("jmp 123}").first); 332 auto item = p.Parse(v); 333 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_NAME_ID) << "ERR_BAD_NAME_ID expected"; 334 } 335 336 /** 337 * @tc.name: parser_test_015 338 * @tc.desc: Verify the ShowError function. 339 * @tc.type: FUNC 340 * @tc.require: issueNumber 341 */ 342 HWTEST_F(ParserTest, parser_test_015, TestSize.Level1) 343 { 344 std::vector<std::vector<panda::pandasm::Token>> v; 345 Lexer l; 346 Parser p; 347 v.push_back(l.TokenizeString(".function u8 main(){").first); 348 v.push_back(l.TokenizeString("shli 12 asd}").first); 349 auto item = p.Parse(v); 350 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_OPERATION_NAME); 351 } 352 353 /** 354 * @tc.name: parser_test_016 355 * @tc.desc: Verify the ShowError function. 356 * @tc.type: FUNC 357 * @tc.require: issueNumber 358 */ 359 HWTEST_F(ParserTest, parser_test_016, TestSize.Level1) 360 { 361 std::vector<std::vector<panda::pandasm::Token>> v; 362 Lexer l; 363 Parser p; 364 v.push_back(l.TokenizeString(".function u8 main(){").first); 365 v.push_back(l.TokenizeString("l123: jmp l123}").first); 366 367 auto item = p.Parse(v); 368 369 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_NONE) << "ERR_NONE expected"; 370 } 371 372 /** 373 * @tc.name: parser_test_017 374 * @tc.desc: Verify the ShowError function. 375 * @tc.type: FUNC 376 * @tc.require: issueNumber 377 */ 378 HWTEST_F(ParserTest, parser_test_017, TestSize.Level1) 379 { 380 std::vector<std::vector<panda::pandasm::Token>> v; 381 Lexer l; 382 Parser p; 383 v.push_back(l.TokenizeString(".function u8 main(){").first); 384 v.push_back(l.TokenizeString("return}").first); 385 auto item = p.Parse(v); 386 387 const auto sig_main = GetFunctionSignatureFromName("main", {}); 388 389 EXPECT_EQ(item.Value().function_table.at(sig_main).ins[0].opcode, Opcode::RETURN) << "NONE expected"; 390 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_NONE) << "ERR_NONE expected"; 391 } 392 393 /** 394 * @tc.name: parser_test_018 395 * @tc.desc: Verify the ShowError function. 396 * @tc.type: FUNC 397 * @tc.require: issueNumber 398 */ 399 HWTEST_F(ParserTest, parser_test_018, TestSize.Level1) 400 { 401 std::vector<std::vector<panda::pandasm::Token>> v; 402 Lexer l; 403 Parser p; 404 v.push_back(l.TokenizeString(".function u8 main(){").first); 405 v.push_back(l.TokenizeString("return1}").first); 406 auto item = p.Parse(v); 407 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_OPERATION_NAME) << "ERR_BAD_OPERATION expected"; 408 } 409 410 /** 411 * @tc.name: parser_test_019 412 * @tc.desc: Verify the ShowError function. 413 * @tc.type: FUNC 414 * @tc.require: issueNumber 415 */ 416 HWTEST_F(ParserTest, parser_test_019, TestSize.Level1) 417 { 418 std::vector<std::vector<panda::pandasm::Token>> v; 419 Lexer l; 420 Parser p; 421 v.push_back(l.TokenizeString(".function u8 main(){").first); 422 v.push_back(l.TokenizeString("return 1}").first); 423 auto item = p.Parse(v); 424 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_NUMBER_OPERANDS) << "ERR_BAD_NUMBER_OPERANDS expected"; 425 } 426 427 /** 428 * @tc.name: parser_test_020 429 * @tc.desc: Verify the ShowError function. 430 * @tc.type: FUNC 431 * @tc.require: issueNumber 432 */ 433 HWTEST_F(ParserTest, parser_test_020, TestSize.Level1) 434 { 435 std::vector<std::vector<panda::pandasm::Token>> v; 436 Lexer l; 437 Parser p; 438 v.push_back(l.TokenizeString(".function u8 main(){").first); 439 v.push_back(l.TokenizeString("ashr2.12 1234}").first); 440 auto item = p.Parse(v); 441 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_OPERATION_NAME) << "ERR_BAD_NAME_REG expected"; 442 } 443 444 /** 445 * @tc.name: parser_test_021 446 * @tc.desc: Verify the ERR_BAD_ARRAY_SIZE function. 447 * @tc.type: FUNC 448 * @tc.require: issueNumber 449 */ 450 HWTEST_F(ParserTest, parser_test_021, TestSize.Level1) 451 { 452 { 453 std::vector<std::vector<panda::pandasm::Token>> v; 454 Lexer l; 455 Parser p; 456 v.push_back(l.TokenizeString(".record Asm }{").first); 457 v.push_back(l.TokenizeString("i64 asm1").first); 458 v.push_back(l.TokenizeString("}").first); 459 460 auto item = p.Parse(v); 461 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_DEFINITION_METADATA); 462 } 463 { 464 std::vector<std::vector<panda::pandasm::Token>> v; 465 Lexer l; 466 Parser p; 467 468 v.push_back(l.TokenizeString(".record asm1 { i64 asm1{}").first); 469 v.push_back(l.TokenizeString("}").first); 470 471 auto item = p.Parse(v); 472 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_KEYWORD); 473 } 474 475 { 476 std::vector<std::vector<panda::pandasm::Token>> v; 477 Lexer l; 478 Parser p; 479 480 v.push_back(l.TokenizeString(".record asm1 { i64 asm1}").first); 481 v.push_back(l.TokenizeString("}").first); 482 483 auto item = p.Parse(v); 484 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_BOUND); 485 } 486 487 { 488 std::vector<std::vector<panda::pandasm::Token>> v; 489 Lexer l; 490 Parser p; 491 492 v.push_back(l.TokenizeString(".array array u8 3 { 1 2 }").first); 493 v.push_back(l.TokenizeString("}").first); 494 495 auto item = p.Parse(v); 496 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_ARRAY_SIZE); 497 } 498 499 { 500 std::vector<std::vector<panda::pandasm::Token>> v; 501 Lexer l; 502 Parser p; 503 504 v.push_back(l.TokenizeString(".array array u8 3 { 1 2 3 4").first); 505 v.push_back(l.TokenizeString("").first); 506 507 auto item = p.Parse(v); 508 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_END); 509 } 510 511 { 512 std::vector<std::vector<panda::pandasm::Token>> v; 513 Lexer l; 514 Parser p; 515 516 v.push_back(l.TokenizeString(".array array u8 3 { i32:0").first); 517 v.push_back(l.TokenizeString("}").first); 518 519 auto item = p.Parse(v); 520 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_ARRAY_ELEMENT_VALUE_INTEGER); 521 } 522 } 523 524 /** 525 * @tc.name: parser_test_022 526 * @tc.desc: Verify the ShowError function. 527 * @tc.type: FUNC 528 * @tc.require: issueNumber 529 */ 530 HWTEST_F(ParserTest, parser_test_022, TestSize.Level1) 531 { 532 Parser p; 533 const auto source = R"( 534 .function i32 main() { 535 ldai -1 536 sta v0 537 jeq v0, label 538 ldai 1 539 return 540 label: 541 ldai 0 542 return 543 } 544 .function f64 m123(u1 a0, f32 a1){ 545 la1: 546 jeq v0, la1 547 ldai 0 548 return 549 } 550 )"; 551 auto item = p.Parse(source); 552 553 std::vector<Function::Parameter> params1; 554 panda::panda_file::SourceLang language {panda::panda_file::SourceLang::PANDA_ASSEMBLY}; 555 params1.emplace_back(Type {"u1", 0}, language); 556 params1.emplace_back(Type {"f32", 0}, language); 557 const auto sig_m123 = GetFunctionSignatureFromName("m123", params1); 558 const std::string sig_main = "main:()"; 559 auto it = item.Value().function_table.find(sig_main); 560 size_t num_size = 2U; 561 562 auto func_m123_at = item.Value().function_table.at(sig_m123).ins; 563 auto func_main_at = item.Value().function_table.at(sig_main).ins; 564 565 EXPECT_NE(it, item.Value().function_table.end()); 566 EXPECT_EQ(item.Value().function_table.at(sig_main).name, sig_main); 567 EXPECT_EQ(item.Value().function_table.at(sig_m123).name, sig_m123); 568 EXPECT_EQ(item.Value().function_table.at(sig_main).GetParamsNum(), 0U); 569 EXPECT_EQ(item.Value().function_table.at(sig_m123).GetParamsNum(), num_size); 570 EXPECT_EQ(item.Value().function_table.at(sig_m123).params[0].type.GetId(), panda::panda_file::Type::TypeId::U1); 571 EXPECT_EQ(item.Value().function_table.at(sig_m123).params[1].type.GetId(), panda::panda_file::Type::TypeId::F32); 572 EXPECT_EQ(item.Value().function_table.at(sig_main).return_type.GetId(), panda::panda_file::Type::TypeId::I32); 573 EXPECT_EQ(item.Value().function_table.at(sig_m123).return_type.GetId(), panda::panda_file::Type::TypeId::F64); 574 575 auto func_m123_table = item.Value().function_table.at(sig_m123).label_table.at("la1").file_location; 576 auto func_main_table = item.Value().function_table.at(sig_main).label_table.at("label").file_location; 577 578 EXPECT_EQ(func_main_table->line_number, 5U); 579 EXPECT_EQ(func_main_table->is_defined, true); 580 EXPECT_EQ(func_m123_table->line_number, 13U); 581 EXPECT_EQ(func_m123_table->is_defined, true); 582 EXPECT_EQ(func_main_at[5].opcode, Opcode::INVALID); 583 EXPECT_EQ(func_main_at[5].label, "label"); 584 EXPECT_EQ(func_main_at[1].regs[0], 0U); 585 EXPECT_EQ(func_main_at[2].regs[0], 0U); 586 EXPECT_EQ(func_main_at[3].set_label, false); 587 EXPECT_EQ(func_m123_at[2].opcode, Opcode::LDAI); 588 EXPECT_EQ(func_m123_at[0].opcode, Opcode::INVALID); 589 EXPECT_EQ(func_m123_at[0].label, "la1"); 590 EXPECT_EQ(func_m123_at[1].set_label, false); 591 EXPECT_EQ(func_m123_at[1].ids[0], "la1"); 592 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_NONE) << "ERR_NONE expected"; 593 } 594 595 /** 596 * @tc.name: parser_test_023 597 * @tc.desc: Verify the ShowError function. 598 * @tc.type: FUNC 599 * @tc.require: issueNumber 600 */ 601 HWTEST_F(ParserTest, parser_test_023, TestSize.Level1) 602 { 603 const auto source = R"( 604 .function i32 main() { 605 begin: 606 ldai 2 607 return 608 end: 609 catch: 610 ldai 0 611 return 612 catch_all: 613 ldai 1 614 return 615 .catch panda.ExceptionInInitializerError, begin, end, catch 616 .catchall begin, end, catch_all 617 } 618 )"; 619 Parser p; 620 auto item = p.Parse(source); 621 const std::string sig_main = "main:()"; 622 auto it = item.Value().function_table.find(sig_main); 623 EXPECT_NE(it, item.Value().function_table.end()); 624 EXPECT_EQ(item.Value().function_table.at(sig_main).name, sig_main); 625 EXPECT_EQ(item.Value().function_table.at(sig_main).GetParamsNum(), 0U); 626 EXPECT_EQ(item.Value().function_table.at(sig_main).return_type.GetId(), panda::panda_file::Type::TypeId::I32); 627 EXPECT_EQ(item.Value().function_table.at(sig_main).ins[1].opcode, Opcode::LDAI); 628 EXPECT_EQ(item.Value().function_table.at(sig_main).ins[3].set_label, true); 629 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_NONE) << "ERR_NONE expected"; 630 } 631 632 /** 633 * @tc.name: parser_test_024 634 * @tc.desc: Verify the TokenizeString function. 635 * @tc.type: FUNC 636 * @tc.require: issueNumber 637 */ 638 HWTEST_F(ParserTest, parser_test_024, TestSize.Level1) 639 { 640 std::vector<std::vector<panda::pandasm::Token>> v; 641 Lexer l; 642 Parser p; 643 644 v.push_back(l.TokenizeString(".record Asm1 {").first); 645 v.push_back(l.TokenizeString("i64 asm1").first); 646 v.push_back(l.TokenizeString("void asm2").first); 647 v.push_back(l.TokenizeString("i32 asm3").first); 648 v.push_back(l.TokenizeString("}").first); 649 v.push_back(l.TokenizeString(".record Asm2 {").first); 650 v.push_back(l.TokenizeString("i64 asm1").first); 651 v.push_back(l.TokenizeString("void asm2").first); 652 v.push_back(l.TokenizeString("i32 asm3 }").first); 653 v.push_back(l.TokenizeString(".record Asm3").first); 654 v.push_back(l.TokenizeString("{").first); 655 v.push_back(l.TokenizeString("i64 asm1").first); 656 v.push_back(l.TokenizeString("void asm2").first); 657 v.push_back(l.TokenizeString("i32 asm3").first); 658 v.push_back(l.TokenizeString("}").first); 659 v.push_back(l.TokenizeString(".record Asm4 { i32 asm1 }").first); 660 v.push_back(l.TokenizeString(".record Asm5 { i32 asm1").first); 661 v.push_back(l.TokenizeString("}").first); 662 663 auto item = p.Parse(v); 664 665 EXPECT_EQ(item.Value().record_table.at("Asm1").name, "Asm1"); 666 EXPECT_EQ(item.Value().record_table.at("Asm1").field_list[0].name, "asm1"); 667 EXPECT_EQ(item.Value().record_table.at("Asm1").field_list[0].type.GetId(), panda::panda_file::Type::TypeId::I64); 668 EXPECT_EQ(item.Value().record_table.at("Asm1").field_list[1].name, "asm2"); 669 EXPECT_EQ(item.Value().record_table.at("Asm1").field_list[1].type.GetId(), panda::panda_file::Type::TypeId::VOID); 670 EXPECT_EQ(item.Value().record_table.at("Asm1").field_list[2].name, "asm3"); 671 EXPECT_EQ(item.Value().record_table.at("Asm1").field_list[2].type.GetId(), panda::panda_file::Type::TypeId::I32); 672 EXPECT_EQ(item.Value().record_table.at("Asm2").name, "Asm2"); 673 EXPECT_EQ(item.Value().record_table.at("Asm2").field_list[0].name, "asm1"); 674 EXPECT_EQ(item.Value().record_table.at("Asm2").field_list[0].type.GetId(), panda::panda_file::Type::TypeId::I64); 675 EXPECT_EQ(item.Value().record_table.at("Asm2").field_list[1].name, "asm2"); 676 EXPECT_EQ(item.Value().record_table.at("Asm2").field_list[1].type.GetId(), panda::panda_file::Type::TypeId::VOID); 677 EXPECT_EQ(item.Value().record_table.at("Asm2").field_list[2].name, "asm3"); 678 EXPECT_EQ(item.Value().record_table.at("Asm2").field_list[2].type.GetId(), panda::panda_file::Type::TypeId::I32); 679 EXPECT_EQ(item.Value().record_table.at("Asm3").name, "Asm3"); 680 EXPECT_EQ(item.Value().record_table.at("Asm3").field_list[0].name, "asm1"); 681 EXPECT_EQ(item.Value().record_table.at("Asm3").field_list[0].type.GetId(), panda::panda_file::Type::TypeId::I64); 682 EXPECT_EQ(item.Value().record_table.at("Asm3").field_list[1].name, "asm2"); 683 EXPECT_EQ(item.Value().record_table.at("Asm3").field_list[1].type.GetId(), panda::panda_file::Type::TypeId::VOID); 684 EXPECT_EQ(item.Value().record_table.at("Asm3").field_list[2].name, "asm3"); 685 EXPECT_EQ(item.Value().record_table.at("Asm3").field_list[2].type.GetId(), panda::panda_file::Type::TypeId::I32); 686 EXPECT_EQ(item.Value().record_table.at("Asm4").field_list[0].name, "asm1"); 687 EXPECT_EQ(item.Value().record_table.at("Asm4").field_list[0].type.GetId(), panda::panda_file::Type::TypeId::I32); 688 EXPECT_EQ(item.Value().record_table.at("Asm5").field_list[0].name, "asm1"); 689 EXPECT_EQ(item.Value().record_table.at("Asm5").field_list[0].type.GetId(), panda::panda_file::Type::TypeId::I32); 690 } 691 692 /** 693 * @tc.name: parser_test_026 694 * @tc.desc: Verify the TokenizeString function. 695 * @tc.type: FUNC 696 * @tc.require: issueNumber 697 */ 698 HWTEST_F(ParserTest, parser_test_026, TestSize.Level1) 699 { 700 std::vector<std::vector<panda::pandasm::Token>> v; 701 Lexer l; 702 Parser p; 703 704 v.push_back(l.TokenizeString(".record Asm1 {").first); 705 v.push_back(l.TokenizeString("i64 asm1").first); 706 v.push_back(l.TokenizeString("void asm2").first); 707 v.push_back(l.TokenizeString("i32 asm3").first); 708 v.push_back(l.TokenizeString("}").first); 709 v.push_back(l.TokenizeString(".function u8 niam(){").first); 710 v.push_back(l.TokenizeString("ldai -1").first); 711 v.push_back(l.TokenizeString("}").first); 712 713 auto item = p.Parse(v); 714 715 const auto sig_niam = GetFunctionSignatureFromName("niam", {}); 716 EXPECT_EQ(item.Value().function_table.at(sig_niam).ins[0].imms[0], Ins::IType(int64_t(-1))) << "-1 expected"; 717 } 718 719 /** 720 * @tc.name: parser_test_027 721 * @tc.desc: Verify the TokenizeString function. 722 * @tc.type: FUNC 723 * @tc.require: issueNumber 724 */ 725 HWTEST_F(ParserTest, parser_test_027, TestSize.Level1) 726 { 727 std::vector<std::vector<panda::pandasm::Token>> v; 728 Lexer l; 729 Parser p; 730 731 v.push_back(l.TokenizeString(".function u8 niam1(){").first); 732 v.push_back(l.TokenizeString("ldai -1").first); 733 v.push_back(l.TokenizeString("}").first); 734 735 v.push_back(l.TokenizeString(".function u8 niam2(){").first); 736 v.push_back(l.TokenizeString("ldai -1").first); 737 v.push_back(l.TokenizeString("}").first); 738 739 v.push_back(l.TokenizeString(".function u8 niam3()").first); 740 v.push_back(l.TokenizeString("{").first); 741 v.push_back(l.TokenizeString("ldai -1").first); 742 v.push_back(l.TokenizeString("}").first); 743 744 v.push_back(l.TokenizeString(".function u8 niam4(){ldai -1}").first); 745 746 v.push_back(l.TokenizeString(".function u8 niam5(){ldai -1").first); 747 v.push_back(l.TokenizeString("}").first); 748 749 auto item = p.Parse(v); 750 751 const auto sig_niam1 = GetFunctionSignatureFromName("niam1", {}); 752 const auto sig_niam2 = GetFunctionSignatureFromName("niam2", {}); 753 const auto sig_niam3 = GetFunctionSignatureFromName("niam3", {}); 754 const auto sig_niam4 = GetFunctionSignatureFromName("niam4", {}); 755 const auto sig_niam5 = GetFunctionSignatureFromName("niam5", {}); 756 757 EXPECT_EQ(item.Value().function_table.at(sig_niam1).ins[0].ins_debug.line_number, 2U) << "2 expected"; 758 EXPECT_EQ(item.Value().function_table.at(sig_niam2).ins[0].ins_debug.line_number, 5U) << "5 expected"; 759 EXPECT_EQ(item.Value().function_table.at(sig_niam3).ins[0].ins_debug.line_number, 9U) << "9 expected"; 760 EXPECT_EQ(item.Value().function_table.at(sig_niam4).ins[0].ins_debug.line_number, 11U) << "11 expected"; 761 EXPECT_EQ(item.Value().function_table.at(sig_niam5).ins[0].ins_debug.line_number, 12U) << "12 expected"; 762 } 763 764 /** 765 * @tc.name: parser_test_028 766 * @tc.desc: Verify the record line_of_def function. 767 * @tc.type: FUNC 768 * @tc.require: issueNumber 769 */ 770 HWTEST_F(ParserTest, parser_test_028, TestSize.Level1) 771 { 772 std::vector<std::vector<panda::pandasm::Token>> v; 773 Lexer l; 774 Parser p; 775 776 v.push_back(l.TokenizeString(".record Asm1 {").first); 777 v.push_back(l.TokenizeString("i64 asm1").first); 778 v.push_back(l.TokenizeString("void asm2").first); 779 v.push_back(l.TokenizeString("i32 asm3").first); 780 v.push_back(l.TokenizeString("}").first); 781 782 v.push_back(l.TokenizeString(".record Asm2 {").first); 783 v.push_back(l.TokenizeString("i64 asm1").first); 784 v.push_back(l.TokenizeString("void asm2").first); 785 v.push_back(l.TokenizeString("i32 asm3 }").first); 786 787 v.push_back(l.TokenizeString(".record Asm3").first); 788 v.push_back(l.TokenizeString("{").first); 789 v.push_back(l.TokenizeString("i64 asm1").first); 790 v.push_back(l.TokenizeString("void asm2").first); 791 v.push_back(l.TokenizeString("i32 asm3").first); 792 v.push_back(l.TokenizeString("}").first); 793 794 v.push_back(l.TokenizeString(".record Asm4 { i32 asm1 }").first); 795 796 v.push_back(l.TokenizeString(".record Asm5 { i32 asm1").first); 797 v.push_back(l.TokenizeString("}").first); 798 799 auto item = p.Parse(v); 800 801 EXPECT_EQ(item.Value().record_table.at("Asm1").field_list[0].line_of_def, 2U); 802 EXPECT_EQ(item.Value().record_table.at("Asm1").field_list[1].line_of_def, 3U); 803 EXPECT_EQ(item.Value().record_table.at("Asm1").field_list[2].line_of_def, 4U); 804 805 EXPECT_EQ(item.Value().record_table.at("Asm2").field_list[0].line_of_def, 7U); 806 EXPECT_EQ(item.Value().record_table.at("Asm2").field_list[1].line_of_def, 8U); 807 EXPECT_EQ(item.Value().record_table.at("Asm2").field_list[2].line_of_def, 9U); 808 809 EXPECT_EQ(item.Value().record_table.at("Asm3").field_list[0].line_of_def, 12U); 810 EXPECT_EQ(item.Value().record_table.at("Asm3").field_list[1].line_of_def, 13U); 811 EXPECT_EQ(item.Value().record_table.at("Asm3").field_list[2].line_of_def, 14U); 812 813 EXPECT_EQ(item.Value().record_table.at("Asm4").field_list[0].line_of_def, 16U); 814 815 EXPECT_EQ(item.Value().record_table.at("Asm5").field_list[0].line_of_def, 17U); 816 } 817 818 /** 819 * @tc.name: parser_test_029 820 * @tc.desc: Verify the record GetName function. 821 * @tc.type: FUNC 822 * @tc.require: issueNumber 823 */ 824 HWTEST_F(ParserTest, parser_test_029, TestSize.Level1) 825 { 826 std::vector<std::vector<panda::pandasm::Token>> v; 827 Lexer l; 828 Parser p; 829 830 v.push_back(l.TokenizeString(".record Asm {").first); 831 v.push_back(l.TokenizeString("i64 asm1").first); 832 v.push_back(l.TokenizeString("void asm2").first); 833 v.push_back(l.TokenizeString("i32 asm3").first); 834 v.push_back(l.TokenizeString("}").first); 835 836 v.push_back(l.TokenizeString(".record Asm1 {").first); 837 v.push_back(l.TokenizeString("Asm asm1").first); 838 v.push_back(l.TokenizeString("void asm2").first); 839 v.push_back(l.TokenizeString("i32 asm3 }").first); 840 841 v.push_back(l.TokenizeString(".record Asm2 { Asm1 asm1 }").first); 842 843 v.push_back(l.TokenizeString(".record Asm3 { Asm2 asm1").first); 844 v.push_back(l.TokenizeString("}").first); 845 846 auto item = p.Parse(v); 847 848 EXPECT_EQ(item.Value().record_table.at("Asm1").field_list[0].type.GetName(), "Asm"); 849 EXPECT_EQ(item.Value().record_table.at("Asm1").field_list[1].type.GetId(), panda::panda_file::Type::TypeId::VOID); 850 EXPECT_EQ(item.Value().record_table.at("Asm1").field_list[2].type.GetId(), panda::panda_file::Type::TypeId::I32); 851 852 EXPECT_EQ(item.Value().record_table.at("Asm2").field_list[0].type.GetName(), "Asm1"); 853 854 EXPECT_EQ(item.Value().record_table.at("Asm3").field_list[0].type.GetName(), "Asm2"); 855 } 856 857 /** 858 * @tc.name: parser_test_030 859 * @tc.desc: Verify the GetItemName function. 860 * @tc.type: FUNC 861 * @tc.require: issueNumber 862 */ 863 HWTEST_F(ParserTest, parser_test_030, TestSize.Level1) 864 { 865 EXPECT_EQ(GetOwnerName("Asm.main"), "Asm"); 866 867 EXPECT_EQ(GetOwnerName("main"), ""); 868 869 EXPECT_EQ(GetItemName("Asm.main"), "main"); 870 871 EXPECT_EQ(GetItemName("main"), "main"); 872 } 873 874 /** 875 * @tc.name: parser_test_031 876 * @tc.desc: Verify the GetParamsNum function. 877 * @tc.type: FUNC 878 * @tc.require: issueNumber 879 */ 880 HWTEST_F(ParserTest, parser_test_031, TestSize.Level1) 881 { 882 std::vector<std::vector<panda::pandasm::Token>> v; 883 Lexer l; 884 Parser p; 885 886 v.push_back(l.TokenizeString(".function u8 niam1(){").first); 887 v.push_back(l.TokenizeString("ldai -1").first); 888 v.push_back(l.TokenizeString("}").first); 889 890 v.push_back(l.TokenizeString(".function u8 niam2(u1 a0, i64 a1, i32 a2){").first); 891 v.push_back(l.TokenizeString("mov v0, v3").first); 892 v.push_back(l.TokenizeString("}").first); 893 894 auto item = p.Parse(v); 895 896 const auto sig_niam1 = GetFunctionSignatureFromName("niam1", {}); 897 int64_t value_param = 4; 898 std::vector<Function::Parameter> params; 899 panda::panda_file::SourceLang language {panda::panda_file::SourceLang::PANDA_ASSEMBLY}; 900 params.emplace_back(Type {"u1", 0}, language); 901 params.emplace_back(Type {"i64", 0}, language); 902 params.emplace_back(Type {"i32", 0}, language); 903 const auto sig_niam2 = GetFunctionSignatureFromName("niam2", params); 904 905 EXPECT_EQ(item.Value().function_table.at(sig_niam1).GetParamsNum(), 0U); 906 EXPECT_EQ(item.Value().function_table.at(sig_niam1).value_of_first_param + 1, 0); 907 908 EXPECT_EQ(item.Value().function_table.at(sig_niam2).GetParamsNum(), 3U); 909 EXPECT_EQ(item.Value().function_table.at(sig_niam2).value_of_first_param + 1, value_param); 910 } 911 912 /** 913 * @tc.name: parser_test_032 914 * @tc.desc: Verify the Opcode function. 915 * @tc.type: FUNC 916 * @tc.require: issueNumber 917 */ 918 HWTEST_F(ParserTest, parser_test_032, TestSize.Level1) 919 { 920 std::vector<std::vector<panda::pandasm::Token>> v; 921 Lexer l; 922 Parser p; 923 v.push_back(l.TokenizeString(".function u1 nain1(i64 a0) <> {").first); 924 v.push_back(l.TokenizeString("mov v0, a0").first); 925 v.push_back(l.TokenizeString("}").first); 926 927 v.push_back(l.TokenizeString(".function u1 nain2(i64 a0) <> { mov v0, a0}").first); 928 v.push_back(l.TokenizeString(".function u1 nain3(i64 a0) <> { mov v0, a0").first); 929 v.push_back(l.TokenizeString("}").first); 930 931 v.push_back(l.TokenizeString(".function u1 nain4(i64 a0) ").first); 932 v.push_back(l.TokenizeString("{").first); 933 v.push_back(l.TokenizeString("mov v0, a0").first); 934 v.push_back(l.TokenizeString("}").first); 935 936 v.push_back(l.TokenizeString(".function u1 nain5(i64 a0) <>{").first); 937 v.push_back(l.TokenizeString("mov v0, a0}").first); 938 939 v.push_back(l.TokenizeString(".function u1 nain6(i64 a0) <>").first); 940 v.push_back(l.TokenizeString("{").first); 941 v.push_back(l.TokenizeString("mov v0, a0}").first); 942 943 v.push_back(l.TokenizeString(".function u1 nain7(i64 a0) <> {").first); 944 v.push_back(l.TokenizeString("mov v0, a0").first); 945 v.push_back(l.TokenizeString("}").first); 946 947 v.push_back(l.TokenizeString(".function u1 nain8(i64 a0) { mov v0, a0}").first); 948 v.push_back(l.TokenizeString(".function u1 nain9(i64 a0) { mov v0, a0").first); 949 v.push_back(l.TokenizeString("}").first); 950 951 v.push_back(l.TokenizeString(".function u1 nain10(i64 a0) <>").first); 952 v.push_back(l.TokenizeString("{").first); 953 v.push_back(l.TokenizeString("mov v0, a0").first); 954 v.push_back(l.TokenizeString("}").first); 955 956 v.push_back(l.TokenizeString(".function u1 nain11(i64 a0) {").first); 957 v.push_back(l.TokenizeString("mov v0, a0}").first); 958 959 v.push_back(l.TokenizeString(".function u1 nain12(i64 a0)").first); 960 v.push_back(l.TokenizeString("{").first); 961 v.push_back(l.TokenizeString("mov v0, a0}").first); 962 963 auto item = p.Parse(v); 964 965 std::vector<Function::Parameter> params; 966 panda::panda_file::SourceLang language {panda::panda_file::SourceLang::PANDA_ASSEMBLY}; 967 params.emplace_back(Type {"i64", 0}, language); 968 const auto sig_nain1 = GetFunctionSignatureFromName("nain1", params); 969 const auto sig_nain2 = GetFunctionSignatureFromName("nain2", params); 970 const auto sig_nain3 = GetFunctionSignatureFromName("nain3", params); 971 const auto sig_nain4 = GetFunctionSignatureFromName("nain4", params); 972 const auto sig_nain5 = GetFunctionSignatureFromName("nain5", params); 973 const auto sig_nain6 = GetFunctionSignatureFromName("nain6", params); 974 const auto sig_nain7 = GetFunctionSignatureFromName("nain7", params); 975 const auto sig_nain8 = GetFunctionSignatureFromName("nain8", params); 976 const auto sig_nain9 = GetFunctionSignatureFromName("nain9", params); 977 const auto sig_nain10 = GetFunctionSignatureFromName("nain10", params); 978 const auto sig_nain11 = GetFunctionSignatureFromName("nain11", params); 979 const auto sig_nain12 = GetFunctionSignatureFromName("nain12", params); 980 981 EXPECT_EQ(item.Value().function_table.at(sig_nain1).name, sig_nain1); 982 EXPECT_EQ(item.Value().function_table.at(sig_nain12).name, sig_nain12); 983 EXPECT_EQ(item.Value().function_table.at(sig_nain3).name, sig_nain3); 984 EXPECT_EQ(item.Value().function_table.at(sig_nain2).name, sig_nain2); 985 EXPECT_EQ(item.Value().function_table.at(sig_nain4).name, sig_nain4); 986 EXPECT_EQ(item.Value().function_table.at(sig_nain5).name, sig_nain5); 987 EXPECT_EQ(item.Value().function_table.at(sig_nain6).name, sig_nain6); 988 EXPECT_EQ(item.Value().function_table.at(sig_nain7).name, sig_nain7); 989 EXPECT_EQ(item.Value().function_table.at(sig_nain8).name, sig_nain8); 990 EXPECT_EQ(item.Value().function_table.at(sig_nain9).name, sig_nain9); 991 EXPECT_EQ(item.Value().function_table.at(sig_nain10).name, sig_nain10); 992 EXPECT_EQ(item.Value().function_table.at(sig_nain11).name, sig_nain11); 993 994 EXPECT_EQ(item.Value().function_table.at(sig_nain1).ins[0].opcode, Opcode::MOV); 995 EXPECT_EQ(item.Value().function_table.at(sig_nain2).ins[0].opcode, Opcode::MOV); 996 EXPECT_EQ(item.Value().function_table.at(sig_nain3).ins[0].opcode, Opcode::MOV); 997 EXPECT_EQ(item.Value().function_table.at(sig_nain4).ins[0].opcode, Opcode::MOV); 998 EXPECT_EQ(item.Value().function_table.at(sig_nain5).ins[0].opcode, Opcode::MOV); 999 EXPECT_EQ(item.Value().function_table.at(sig_nain6).ins[0].opcode, Opcode::MOV); 1000 EXPECT_EQ(item.Value().function_table.at(sig_nain7).ins[0].opcode, Opcode::MOV); 1001 EXPECT_EQ(item.Value().function_table.at(sig_nain8).ins[0].opcode, Opcode::MOV); 1002 EXPECT_EQ(item.Value().function_table.at(sig_nain9).ins[0].opcode, Opcode::MOV); 1003 EXPECT_EQ(item.Value().function_table.at(sig_nain10).ins[0].opcode, Opcode::MOV); 1004 EXPECT_EQ(item.Value().function_table.at(sig_nain11).ins[0].opcode, Opcode::MOV); 1005 EXPECT_EQ(item.Value().function_table.at(sig_nain12).ins[0].opcode, Opcode::MOV); 1006 } 1007 1008 /** 1009 * @tc.name: parser_test_033 1010 * @tc.desc: Verify the GetId function. 1011 * @tc.type: FUNC 1012 * @tc.require: issueNumber 1013 */ 1014 HWTEST_F(ParserTest, parser_test_033, TestSize.Level1) 1015 { 1016 std::vector<std::vector<panda::pandasm::Token>> v; 1017 Lexer l; 1018 Parser p; 1019 v.push_back(l.TokenizeString(".record rec1 <> {").first); 1020 v.push_back(l.TokenizeString("i64 asm1 <>").first); 1021 v.push_back(l.TokenizeString("}").first); 1022 1023 v.push_back(l.TokenizeString(".record rec2 <> { i64 asm1}").first); 1024 v.push_back(l.TokenizeString(".record rec3 <> { i64 asm1").first); 1025 v.push_back(l.TokenizeString("}").first); 1026 1027 v.push_back(l.TokenizeString(".record rec4").first); 1028 v.push_back(l.TokenizeString("{").first); 1029 v.push_back(l.TokenizeString("i64 asm1").first); 1030 v.push_back(l.TokenizeString("}").first); 1031 1032 v.push_back(l.TokenizeString(".record rec5{").first); 1033 v.push_back(l.TokenizeString("i64 asm1}").first); 1034 1035 v.push_back(l.TokenizeString(".record rec6").first); 1036 v.push_back(l.TokenizeString("{").first); 1037 v.push_back(l.TokenizeString("i64 asm1}").first); 1038 1039 v.push_back(l.TokenizeString(".record rec7{").first); 1040 v.push_back(l.TokenizeString("i64 asm1").first); 1041 v.push_back(l.TokenizeString("}").first); 1042 1043 auto item = p.Parse(v); 1044 1045 EXPECT_EQ(item.Value().record_table.at("rec1").field_list[0].type.GetId(), panda::panda_file::Type::TypeId::I64); 1046 EXPECT_EQ(item.Value().record_table.at("rec2").field_list[0].type.GetId(), panda::panda_file::Type::TypeId::I64); 1047 EXPECT_EQ(item.Value().record_table.at("rec3").field_list[0].type.GetId(), panda::panda_file::Type::TypeId::I64); 1048 EXPECT_EQ(item.Value().record_table.at("rec4").field_list[0].type.GetId(), panda::panda_file::Type::TypeId::I64); 1049 EXPECT_EQ(item.Value().record_table.at("rec5").field_list[0].type.GetId(), panda::panda_file::Type::TypeId::I64); 1050 EXPECT_EQ(item.Value().record_table.at("rec6").field_list[0].type.GetId(), panda::panda_file::Type::TypeId::I64); 1051 EXPECT_EQ(item.Value().record_table.at("rec7").field_list[0].type.GetId(), panda::panda_file::Type::TypeId::I64); 1052 } 1053 1054 /** 1055 * @tc.name: parser_test_034 1056 * @tc.desc: Verify the ins.opcode function. 1057 * @tc.type: FUNC 1058 * @tc.require: issueNumber 1059 */ 1060 HWTEST_F(ParserTest, parser_test_034, TestSize.Level1) 1061 { 1062 std::vector<std::vector<panda::pandasm::Token>> v; 1063 Lexer l; 1064 Parser p; 1065 v.push_back(l.TokenizeString(".function u1 nain1(i64 a0) <> {").first); 1066 v.push_back(l.TokenizeString("sta a0").first); 1067 v.push_back(l.TokenizeString("L: mov v0, a0").first); 1068 v.push_back(l.TokenizeString("sta v4").first); 1069 v.push_back(l.TokenizeString("jmp L").first); 1070 v.push_back(l.TokenizeString("}").first); 1071 1072 auto item = p.Parse(v); 1073 1074 std::vector<Function::Parameter> params; 1075 panda::panda_file::SourceLang language {panda::panda_file::SourceLang::PANDA_ASSEMBLY}; 1076 params.emplace_back(Type {"i64", 0}, language); 1077 const auto sig_nain1 = GetFunctionSignatureFromName("nain1", params); 1078 auto it = item.Value().function_table.find(sig_nain1); 1079 EXPECT_NE(it, item.Value().function_table.end()); 1080 auto func_table = item.Value().function_table.at(sig_nain1).ins; 1081 EXPECT_EQ(OperandTypePrint(func_table[0].opcode), "reg"); 1082 EXPECT_EQ(OperandTypePrint(func_table[1].opcode), "reg_reg"); 1083 EXPECT_EQ(OperandTypePrint(func_table[2].opcode), "reg"); 1084 EXPECT_EQ(OperandTypePrint(func_table[3].opcode), "label"); 1085 } 1086 1087 /** 1088 * @tc.name: parser_test_035 1089 * @tc.desc: Verify the ShowError function. 1090 * @tc.type: FUNC 1091 * @tc.require: issueNumber 1092 */ 1093 HWTEST_F(ParserTest, parser_test_035, TestSize.Level1) 1094 { 1095 { 1096 std::vector<std::vector<panda::pandasm::Token>> v; 1097 Lexer l; 1098 Parser p; 1099 1100 std::string f = "T"; 1101 1102 v.push_back(l.TokenizeString(".record Rec {").first); 1103 v.push_back(l.TokenizeString(f).first); 1104 v.push_back(l.TokenizeString("}").first); 1105 1106 p.Parse(v); 1107 1108 Error e = p.ShowError(); 1109 1110 EXPECT_EQ(e.err, Error::ErrorType::ERR_BAD_FIELD_MISSING_NAME); 1111 EXPECT_EQ(e.line_number, 2U); 1112 EXPECT_EQ(static_cast<uint32_t>(e.pos), f.length()); 1113 EXPECT_EQ(e.message, "Expected field name."); 1114 } 1115 1116 { 1117 std::vector<std::vector<panda::pandasm::Token>> v; 1118 Lexer l; 1119 Parser p; 1120 1121 std::string f = "T f <"; 1122 1123 v.push_back(l.TokenizeString(".record Rec {").first); 1124 v.push_back(l.TokenizeString(f).first); 1125 v.push_back(l.TokenizeString("}").first); 1126 1127 p.Parse(v); 1128 1129 Error e = p.ShowError(); 1130 1131 EXPECT_EQ(e.err, Error::ErrorType::ERR_BAD_METADATA_BOUND); 1132 EXPECT_EQ(e.line_number, 2U); 1133 EXPECT_EQ(static_cast<uint32_t>(e.pos), f.length()); 1134 EXPECT_EQ(e.message, "Expected '>'."); 1135 } 1136 } 1137 1138 /** 1139 * @tc.name: parser_test_036 1140 * @tc.desc: Verify the ShowError function. 1141 * @tc.type: FUNC 1142 * @tc.require: issueNumber 1143 */ 1144 HWTEST_F(ParserTest, parser_test_036, TestSize.Level1) 1145 { 1146 { 1147 std::vector<std::vector<panda::pandasm::Token>> v; 1148 Lexer l; 1149 Parser p; 1150 1151 std::string op = "lda.str \"123\\z\""; 1152 1153 v.push_back(l.TokenizeString(".function void f() {").first); 1154 v.push_back(l.TokenizeString(op).first); 1155 v.push_back(l.TokenizeString("}").first); 1156 1157 p.Parse(v); 1158 1159 Error e = p.ShowError(); 1160 1161 EXPECT_EQ(e.err, Error::ErrorType::ERR_BAD_STRING_UNKNOWN_ESCAPE_SEQUENCE); 1162 EXPECT_EQ(e.line_number, 2U); 1163 EXPECT_EQ(e.message, "Unknown escape sequence"); 1164 } 1165 1166 { 1167 std::vector<std::vector<panda::pandasm::Token>> v; 1168 Lexer l; 1169 Parser p; 1170 1171 std::string op = "lda.str \" \\\" \\' \\\\ \\a \\b \\f \\n \\r \\t \\v \""; 1172 1173 v.push_back(l.TokenizeString(".function void f() {").first); 1174 v.push_back(l.TokenizeString(op).first); 1175 v.push_back(l.TokenizeString("}").first); 1176 1177 Error e = p.ShowError(); 1178 1179 auto item = p.Parse(v); 1180 1181 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_NONE); 1182 EXPECT_TRUE(item.HasValue()); 1183 } 1184 } 1185 1186 /** 1187 * @tc.name: parser_test_037 1188 * @tc.desc: Verify the ShowError function. 1189 * @tc.type: FUNC 1190 * @tc.require: issueNumber 1191 */ 1192 HWTEST_F(ParserTest, parser_test_037, TestSize.Level1) 1193 { 1194 { 1195 std::vector<std::vector<panda::pandasm::Token>> v; 1196 Lexer l; 1197 Parser p; 1198 1199 std::string op = "lda.str 123"; 1200 1201 v.push_back(l.TokenizeString(".function void f() {").first); 1202 v.push_back(l.TokenizeString(op).first); 1203 v.push_back(l.TokenizeString("}").first); 1204 1205 p.Parse(v); 1206 1207 Error e = p.ShowError(); 1208 1209 EXPECT_EQ(e.err, Error::ErrorType::ERR_BAD_OPERAND); 1210 EXPECT_EQ(e.line_number, 2U); 1211 EXPECT_EQ(e.message, "Expected string literal"); 1212 } 1213 1214 { 1215 std::vector<std::vector<panda::pandasm::Token>> v; 1216 Lexer l; 1217 Parser p; 1218 1219 std::string op = "lda.str a\"bcd"; 1220 1221 v.push_back(l.TokenizeString(".function void f() {").first); 1222 v.push_back(l.TokenizeString(op).first); 1223 v.push_back(l.TokenizeString("}").first); 1224 1225 p.Parse(v); 1226 1227 Error e = p.ShowError(); 1228 1229 EXPECT_EQ(e.err, Error::ErrorType::ERR_BAD_OPERAND); 1230 EXPECT_EQ(e.line_number, 2U); 1231 EXPECT_EQ(e.message, "Expected string literal"); 1232 } 1233 1234 { 1235 std::vector<std::vector<panda::pandasm::Token>> v; 1236 Lexer l; 1237 Parser p; 1238 1239 v.push_back(l.TokenizeString(".function void f() {").first); 1240 v.push_back(l.TokenizeString("lda.str \" abc123 \"").first); 1241 v.push_back(l.TokenizeString("lda.str \"zxcvb\"").first); 1242 v.push_back(l.TokenizeString("}").first); 1243 1244 auto item = p.Parse(v); 1245 1246 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_NONE); 1247 EXPECT_TRUE(item.HasValue()); 1248 1249 auto str1 = item.Value().strings.find(" abc123 "); 1250 auto str2 = item.Value().strings.find("zxcvb"); 1251 EXPECT_NE(str1, item.Value().strings.end()); 1252 EXPECT_NE(str2, item.Value().strings.end()); 1253 } 1254 } 1255 1256 /** 1257 * @tc.name: parser_test_038 1258 * @tc.desc: Verify the ShowError function. 1259 * @tc.type: FUNC 1260 * @tc.require: issueNumber 1261 */ 1262 HWTEST_F(ParserTest, parser_test_038, TestSize.Level1) 1263 { 1264 { 1265 std::vector<std::vector<panda::pandasm::Token>> v; 1266 Lexer l; 1267 Parser p; 1268 1269 std::string op = "lda.str \"123\\x\""; 1270 1271 v.push_back(l.TokenizeString(".function void f() {").first); 1272 v.push_back(l.TokenizeString(op).first); 1273 v.push_back(l.TokenizeString("}").first); 1274 1275 p.Parse(v); 1276 1277 Error e = p.ShowError(); 1278 size_t line_nubmer = 2U; 1279 EXPECT_EQ(e.err, Error::ErrorType::ERR_BAD_STRING_INVALID_HEX_ESCAPE_SEQUENCE); 1280 EXPECT_EQ(e.line_number, line_nubmer); 1281 size_t ret = op.find('\\'); 1282 EXPECT_EQ(e.pos, ret); 1283 EXPECT_EQ(e.message, "Invalid \\x escape sequence"); 1284 } 1285 1286 { 1287 std::vector<std::vector<panda::pandasm::Token>> v; 1288 Lexer l; 1289 Parser p; 1290 1291 std::string op = "lda.str \"123\\xaa\\x65\""; 1292 1293 v.push_back(l.TokenizeString(".function void f() {").first); 1294 v.push_back(l.TokenizeString(op).first); 1295 v.push_back(l.TokenizeString("}").first); 1296 1297 auto item = p.Parse(v); 1298 1299 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_NONE); 1300 EXPECT_TRUE(item.HasValue()); 1301 } 1302 } 1303 1304 /** 1305 * @tc.name: parser_test_039 1306 * @tc.desc: Verify the ShowError function. 1307 * @tc.type: FUNC 1308 * @tc.require: issueNumber 1309 */ 1310 HWTEST_F(ParserTest, parser_test_039, TestSize.Level1) 1311 { 1312 { 1313 std::vector<std::vector<panda::pandasm::Token>> v; 1314 Lexer l; 1315 Parser p; 1316 v.push_back(l.TokenizeString(".function void f() {}").first); 1317 v.push_back(l.TokenizeString(".function void main() {").first); 1318 v.push_back(l.TokenizeString("ldglobalvar 0x0, \"f\"").first); 1319 v.push_back(l.TokenizeString("callarg0 0x1").first); 1320 v.push_back(l.TokenizeString("}").first); 1321 1322 auto item = p.Parse(v); 1323 1324 const auto sig_f = GetFunctionSignatureFromName("main", {}); 1325 1326 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_NONE); 1327 EXPECT_TRUE(item.HasValue()); 1328 std::vector<uint16_t> regs {}; 1329 EXPECT_EQ(item.Value().function_table.at(sig_f).ins[0].regs, regs); 1330 EXPECT_EQ(item.Value().function_table.at(sig_f).ins[1].regs, regs); 1331 } 1332 1333 { 1334 std::vector<std::vector<panda::pandasm::Token>> v; 1335 Lexer l; 1336 Parser p; 1337 v.push_back(l.TokenizeString(".function void f() {").first); 1338 v.push_back(l.TokenizeString("callarg1 0x1, v0").first); 1339 v.push_back(l.TokenizeString("callarg1 0x1, v0").first); 1340 v.push_back(l.TokenizeString("}").first); 1341 1342 auto item = p.Parse(v); 1343 1344 const auto sig_f = GetFunctionSignatureFromName("f", {}); 1345 1346 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_NONE); 1347 EXPECT_TRUE(item.HasValue()); 1348 std::vector<uint16_t> regs {0}; 1349 EXPECT_EQ(item.Value().function_table.at(sig_f).ins[0].regs, regs); 1350 EXPECT_EQ(item.Value().function_table.at(sig_f).ins[1].regs, regs); 1351 } 1352 1353 { 1354 std::vector<std::vector<panda::pandasm::Token>> v; 1355 Lexer l; 1356 Parser p; 1357 v.push_back(l.TokenizeString(".function void f() {").first); 1358 v.push_back(l.TokenizeString("callargs2 0x1, v0, v1").first); 1359 v.push_back(l.TokenizeString("callargs2 0x1, v0, v1").first); 1360 v.push_back(l.TokenizeString("}").first); 1361 1362 auto item = p.Parse(v); 1363 1364 const auto sig_f = GetFunctionSignatureFromName("f", {}); 1365 1366 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_NONE); 1367 EXPECT_TRUE(item.HasValue()); 1368 std::vector<uint16_t> regs {0, 1}; 1369 EXPECT_EQ(item.Value().function_table.at(sig_f).ins[0].regs, regs); 1370 EXPECT_EQ(item.Value().function_table.at(sig_f).ins[1].regs, regs); 1371 } 1372 1373 { 1374 std::vector<std::vector<panda::pandasm::Token>> v; 1375 Lexer l; 1376 Parser p; 1377 v.push_back(l.TokenizeString(".function void f() {").first); 1378 v.push_back(l.TokenizeString("callargs3 0x1, v0; v1, v2").first); 1379 v.push_back(l.TokenizeString("}").first); 1380 1381 p.Parse(v); 1382 1383 Error e = p.ShowError(); 1384 1385 EXPECT_EQ(e.err, Error::ErrorType::ERR_BAD_NAME_REG); 1386 } 1387 } 1388 1389 /** 1390 * @tc.name: parser_test_040 1391 * @tc.desc: Verify the ERR_BAD_NUMBER_OPERANDS function. 1392 * @tc.type: FUNC 1393 * @tc.require: issueNumber 1394 */ 1395 HWTEST_F(ParserTest, parser_test_040, TestSize.Level1) 1396 { 1397 { 1398 std::vector<std::vector<panda::pandasm::Token>> v; 1399 Lexer l; 1400 Parser p; 1401 v.push_back(l.TokenizeString(".function u8 main(){").first); 1402 v.push_back(l.TokenizeString("stobjbyname 0xd, \"nain\", v0, v1").first); 1403 v.push_back(l.TokenizeString("}").first); 1404 v.push_back(l.TokenizeString(".function u8 nain(i32 a0, i32 a1){").first); 1405 v.push_back(l.TokenizeString("}").first); 1406 auto item = p.Parse(v); 1407 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_NUMBER_OPERANDS); 1408 } 1409 } 1410 1411 /** 1412 * @tc.name: parser_test_041 1413 * @tc.desc: Verify the ShowError function. 1414 * @tc.type: FUNC 1415 * @tc.require: issueNumber 1416 */ 1417 HWTEST_F(ParserTest, parser_test_041, TestSize.Level1) 1418 { 1419 std::vector<std::vector<panda::pandasm::Token>> v; 1420 Lexer l; 1421 Parser p; 1422 v.push_back(l.TokenizeString(".function u8 main(){").first); 1423 v.push_back(l.TokenizeString("stobjbyname 0x43, \"nain\", v0").first); 1424 v.push_back(l.TokenizeString("}").first); 1425 v.push_back(l.TokenizeString(".function u8 nain(i32 a0, i32 a1){").first); 1426 v.push_back(l.TokenizeString("}").first); 1427 auto item = p.Parse(v); 1428 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_NONE); 1429 } 1430 1431 /** 1432 * @tc.name: parser_test_042 1433 * @tc.desc: Verify the ERR_BAD_OPERAND function. 1434 * @tc.type: FUNC 1435 * @tc.require: issueNumber 1436 */ 1437 HWTEST_F(ParserTest, parser_test_042, TestSize.Level1) 1438 { 1439 std::vector<std::vector<panda::pandasm::Token>> v; 1440 Lexer l; 1441 Parser p; 1442 v.push_back(l.TokenizeString(".function void f() {").first); 1443 v.push_back(l.TokenizeString("mov v67000, v0").first); 1444 v.push_back(l.TokenizeString("}").first); 1445 1446 p.Parse(v); 1447 1448 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_OPERAND); 1449 } 1450 1451 /** 1452 * @tc.name: parser_test_043 1453 * @tc.desc: Verify the ShowError function. 1454 * @tc.type: FUNC 1455 * @tc.require: issueNumber 1456 */ 1457 HWTEST_F(ParserTest, parser_test_043, TestSize.Level1) 1458 { 1459 std::vector<std::vector<panda::pandasm::Token>> v; 1460 Lexer l; 1461 Parser p; 1462 v.push_back(l.TokenizeString(".function void f() {").first); 1463 v.push_back(l.TokenizeString("stobjbyname 0x43, \"f\", v256").first); 1464 v.push_back(l.TokenizeString("}").first); 1465 1466 p.Parse(v); 1467 1468 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_OPERAND); 1469 } 1470 1471 /** 1472 * @tc.name: parser_test_044 1473 * @tc.desc: Verify the ERR_BAD_OPERATION_NAME function. 1474 * @tc.type: FUNC 1475 * @tc.require: issueNumber 1476 */ 1477 HWTEST_F(ParserTest, parser_test_044, TestSize.Level1) 1478 { 1479 std::vector<std::vector<panda::pandasm::Token>> v; 1480 Lexer l; 1481 Parser p; 1482 v.push_back(l.TokenizeString(".function void f() {").first); 1483 v.push_back(l.TokenizeString("movi v5, 0").first); 1484 v.push_back(l.TokenizeString("call.this1 g, a1, v15").first); 1485 v.push_back(l.TokenizeString("return").first); 1486 v.push_back(l.TokenizeString("}").first); 1487 1488 p.Parse(v); 1489 1490 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_OPERATION_NAME); 1491 } 1492 1493 /** 1494 * @tc.name: parser_test_045 1495 * @tc.desc: Verify the ERR_BAD_ID_FUNCTION function. 1496 * @tc.type: FUNC 1497 * @tc.require: issueNumber 1498 */ 1499 HWTEST_F(ParserTest, parser_test_045, TestSize.Level1) 1500 { 1501 std::vector<std::vector<panda::pandasm::Token>> v; 1502 Lexer l; 1503 Parser p; 1504 v.push_back(l.TokenizeString(".function u1 nain(i64 a0) <> {").first); 1505 v.push_back(l.TokenizeString("L: mov v0, a0").first); 1506 v.push_back(l.TokenizeString("}").first); 1507 v.push_back(l.TokenizeString(".function u1 nain(i64 a0) <> {").first); 1508 v.push_back(l.TokenizeString("L: mov v0, a0").first); 1509 v.push_back(l.TokenizeString("}").first); 1510 1511 auto item = p.Parse(v); 1512 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_ID_FUNCTION); 1513 } 1514 1515 /** 1516 * @tc.name: parser_test_046 1517 * @tc.desc: Verify the ERR_BAD_LABEL_EXT function. 1518 * @tc.type: FUNC 1519 * @tc.require: issueNumber 1520 */ 1521 HWTEST_F(ParserTest, parser_test_046, TestSize.Level1) 1522 { 1523 std::vector<std::vector<panda::pandasm::Token>> v; 1524 Lexer l; 1525 Parser p; 1526 v.push_back(l.TokenizeString(".function u1 nain(i64 a0) <> {").first); 1527 v.push_back(l.TokenizeString("SAME: mov v0, a0").first); 1528 v.push_back(l.TokenizeString("SAME: sta v0").first); 1529 v.push_back(l.TokenizeString("}").first); 1530 1531 auto item = p.Parse(v); 1532 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_LABEL_EXT); 1533 } 1534 1535 /** 1536 * @tc.name: parser_test_047 1537 * @tc.desc: Verify the lable function. 1538 * @tc.type: FUNC 1539 * @tc.require: issueNumber 1540 */ 1541 HWTEST_F(ParserTest, parser_test_047, TestSize.Level1) 1542 { 1543 std::vector<std::vector<panda::pandasm::Token>> v; 1544 Lexer l; 1545 Parser p; 1546 v.push_back(l.TokenizeString(".function u1 nain(i64 a0) <> {").first); 1547 v.push_back(l.TokenizeString("nain: mov v0, a0").first); 1548 v.push_back(l.TokenizeString("}").first); 1549 1550 auto item = p.Parse(v); 1551 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_NONE); 1552 } 1553 1554 /** 1555 * @tc.name: parser_test_048 1556 * @tc.desc: Verify the lable function. 1557 * @tc.type: FUNC 1558 * @tc.require: issueNumber 1559 */ 1560 HWTEST_F(ParserTest, parser_test_048, TestSize.Level1) 1561 { 1562 std::vector<std::vector<panda::pandasm::Token>> v; 1563 Lexer l; 1564 Parser p; 1565 v.push_back(l.TokenizeString(".function u1 mov(i64 a0) <> {").first); 1566 v.push_back(l.TokenizeString("L: mov v0, a0").first); 1567 v.push_back(l.TokenizeString("}").first); 1568 1569 auto item = p.Parse(v); 1570 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_NONE); 1571 } 1572 1573 /** 1574 * @tc.name: parser_test_049 1575 * @tc.desc: Verify the mov lable function. 1576 * @tc.type: FUNC 1577 * @tc.require: issueNumber 1578 */ 1579 HWTEST_F(ParserTest, parser_test_049, TestSize.Level1) 1580 { 1581 std::vector<std::vector<panda::pandasm::Token>> v; 1582 Lexer l; 1583 Parser p; 1584 v.push_back(l.TokenizeString(".function u1 mov(i64 a0) <> {").first); 1585 v.push_back(l.TokenizeString("jmp mov").first); 1586 v.push_back(l.TokenizeString("mov:").first); 1587 v.push_back(l.TokenizeString("return").first); 1588 v.push_back(l.TokenizeString("}").first); 1589 1590 auto item = p.Parse(v); 1591 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_NONE); 1592 } 1593 1594 /** 1595 * @tc.name: parser_test_050 1596 * @tc.desc: Verify the callargs2 function. 1597 * @tc.type: FUNC 1598 * @tc.require: issueNumber 1599 */ 1600 HWTEST_F(ParserTest, parser_test_050, TestSize.Level1) 1601 { 1602 std::vector<std::vector<panda::pandasm::Token>> v; 1603 Lexer l; 1604 Parser p; 1605 v.push_back(l.TokenizeString(".function u1 mov(i64 a0) <> {").first); 1606 v.push_back(l.TokenizeString("callargs2 0x0c, v0, v1").first); 1607 v.push_back(l.TokenizeString("}").first); 1608 1609 auto item = p.Parse(v); 1610 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_NONE); 1611 } 1612 1613 /** 1614 * @tc.name: parser_test_051 1615 * @tc.desc: Verify the ERR_BAD_NAME_REG function. 1616 * @tc.type: FUNC 1617 * @tc.require: issueNumber 1618 */ 1619 HWTEST_F(ParserTest, parser_test_051, TestSize.Level1) 1620 { 1621 { 1622 std::vector<std::vector<panda::pandasm::Token>> v; 1623 Lexer l; 1624 Parser p; 1625 v.push_back(l.TokenizeString(".function void f() {").first); 1626 v.push_back(l.TokenizeString("sta 123").first); 1627 v.push_back(l.TokenizeString("}").first); 1628 auto item = p.Parse(v); 1629 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_NAME_REG); 1630 } 1631 { 1632 std::vector<std::vector<panda::pandasm::Token>> v; 1633 Lexer l; 1634 Parser p; 1635 v.push_back(l.TokenizeString(".function void f() {").first); 1636 v.push_back(l.TokenizeString("sta a0").first); 1637 v.push_back(l.TokenizeString("}").first); 1638 auto item = p.Parse(v); 1639 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_NAME_REG); 1640 } 1641 { 1642 std::vector<std::vector<panda::pandasm::Token>> v; 1643 Lexer l; 1644 Parser p; 1645 v.push_back(l.TokenizeString(".function void f(i32 a0) {").first); 1646 v.push_back(l.TokenizeString("sta a01").first); 1647 v.push_back(l.TokenizeString("}").first); 1648 auto item = p.Parse(v); 1649 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_NAME_REG); 1650 } 1651 { 1652 std::vector<std::vector<panda::pandasm::Token>> v; 1653 Lexer l; 1654 Parser p; 1655 v.push_back(l.TokenizeString(".function void f() {").first); 1656 v.push_back(l.TokenizeString("sta 123").first); 1657 v.push_back(l.TokenizeString("}").first); 1658 auto item = p.Parse(v); 1659 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_NAME_REG); 1660 } 1661 { 1662 std::vector<std::vector<panda::pandasm::Token>> v; 1663 Lexer l; 1664 Parser p; 1665 v.push_back(l.TokenizeString(".function void f() {").first); 1666 v.push_back(l.TokenizeString("sta q0").first); 1667 v.push_back(l.TokenizeString("}").first); 1668 auto item = p.Parse(v); 1669 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_NAME_REG); 1670 } 1671 { 1672 std::vector<std::vector<panda::pandasm::Token>> v; 1673 Lexer l; 1674 Parser p; 1675 v.push_back(l.TokenizeString(".function void f() {").first); 1676 v.push_back(l.TokenizeString("sta vy1").first); 1677 v.push_back(l.TokenizeString("}").first); 1678 auto item = p.Parse(v); 1679 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_NAME_REG); 1680 } 1681 { 1682 std::vector<std::vector<panda::pandasm::Token>> v; 1683 Lexer l; 1684 Parser p; 1685 v.push_back(l.TokenizeString(".function void f() {").first); 1686 v.push_back(l.TokenizeString("sta v01").first); 1687 v.push_back(l.TokenizeString("}").first); 1688 auto item = p.Parse(v); 1689 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_NAME_REG); 1690 } 1691 } 1692 1693 /** 1694 * @tc.name: parser_test_052 1695 * @tc.desc: Verify the ERR_BAD_ARRAY_TYPE_BOUND function. 1696 * @tc.type: FUNC 1697 * @tc.require: issueNumber 1698 */ 1699 HWTEST_F(ParserTest, parser_test_052, TestSize.Level1) 1700 { 1701 { 1702 std::vector<std::vector<panda::pandasm::Token>> v; 1703 Lexer l; 1704 Parser p; 1705 1706 v.push_back(l.TokenizeString(".record R {").first); 1707 v.push_back(l.TokenizeString("R[][] f").first); 1708 v.push_back(l.TokenizeString("}").first); 1709 1710 auto item = p.Parse(v); 1711 1712 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_NONE); 1713 1714 std::vector<Function::Parameter> params; 1715 panda::panda_file::SourceLang language {panda::panda_file::SourceLang::PANDA_ASSEMBLY}; 1716 params.emplace_back(Type {"i8", 1}, language); 1717 const auto sig_f = GetFunctionSignatureFromName("f", params); 1718 1719 EXPECT_TRUE(item.HasValue()); 1720 1721 EXPECT_EQ(item.Value().record_table.at("R").field_list.size(), 1U); 1722 EXPECT_TRUE(item.Value().record_table.at("R").field_list[0].type.IsArray()); 1723 EXPECT_TRUE(item.Value().record_table.at("R").field_list[0].type.IsObject()); 1724 EXPECT_EQ(item.Value().record_table.at("R").field_list[0].type.GetName(), "R[][]"); 1725 EXPECT_EQ(item.Value().record_table.at("R").field_list[0].type.GetComponentName(), "R"); 1726 EXPECT_EQ(item.Value().record_table.at("R").field_list[0].type.GetDescriptor(), "[[LR;"); 1727 EXPECT_EQ(item.Value().record_table.at("R").field_list[0].type.GetDescriptor(true), "[[LR;"); 1728 } 1729 1730 { 1731 std::vector<std::vector<panda::pandasm::Token>> v; 1732 Lexer l; 1733 Parser p; 1734 v.push_back(l.TokenizeString(".function void f(i32 a0) {").first); 1735 v.push_back(l.TokenizeString("newarr v0, v0, i32[][").first); 1736 v.push_back(l.TokenizeString("}").first); 1737 1738 auto item = p.Parse(v); 1739 1740 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_OPERATION_NAME); 1741 } 1742 1743 { 1744 std::vector<std::vector<panda::pandasm::Token>> v; 1745 Lexer l; 1746 Parser p; 1747 v.push_back(l.TokenizeString(".function f64[ f(i32 a0) {").first); 1748 v.push_back(l.TokenizeString("newarr v0, v0, i32[]").first); 1749 v.push_back(l.TokenizeString("}").first); 1750 1751 auto item = p.Parse(v); 1752 1753 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_ARRAY_TYPE_BOUND); 1754 } 1755 1756 { 1757 std::vector<std::vector<panda::pandasm::Token>> v; 1758 Lexer l; 1759 Parser p; 1760 v.push_back(l.TokenizeString(".function void f(i32[][][ a0) {").first); 1761 v.push_back(l.TokenizeString("newarr v0, v0, i32[]").first); 1762 v.push_back(l.TokenizeString("}").first); 1763 1764 auto item = p.Parse(v); 1765 1766 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_ARRAY_TYPE_BOUND); 1767 } 1768 1769 { 1770 std::vector<std::vector<panda::pandasm::Token>> v; 1771 Lexer l; 1772 Parser p; 1773 v.push_back(l.TokenizeString(".record R {").first); 1774 v.push_back(l.TokenizeString("R[][ f").first); 1775 v.push_back(l.TokenizeString("}").first); 1776 1777 auto item = p.Parse(v); 1778 1779 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_ARRAY_TYPE_BOUND); 1780 } 1781 } 1782 1783 /** 1784 * @tc.name: parser_test_053 1785 * @tc.desc: Verify the ERR_BAD_OPERATION_NAME function. 1786 * @tc.type: FUNC 1787 * @tc.require: issueNumber 1788 */ 1789 HWTEST_F(ParserTest, parser_test_053, TestSize.Level1) 1790 { 1791 { 1792 std::vector<std::vector<panda::pandasm::Token>> v; 1793 Lexer l; 1794 Parser p; 1795 v.push_back(l.TokenizeString(".function void main() <> {").first); 1796 v.push_back(l.TokenizeString("movi v0, 5").first); 1797 v.push_back(l.TokenizeString("newarr v0, v0, panda.String[]").first); 1798 v.push_back(l.TokenizeString("return.void").first); 1799 v.push_back(l.TokenizeString("}").first); 1800 1801 auto item = p.Parse(v); 1802 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_OPERATION_NAME); 1803 } 1804 { 1805 std::vector<std::vector<panda::pandasm::Token>> v; 1806 Lexer l; 1807 Parser p; 1808 v.push_back(l.TokenizeString(".function void main() <> {").first); 1809 v.push_back(l.TokenizeString("mov v0, 5").first); 1810 v.push_back(l.TokenizeString("newarr v0, v0, i32[]").first); 1811 v.push_back(l.TokenizeString("return.void").first); 1812 v.push_back(l.TokenizeString("}").first); 1813 1814 auto item = p.Parse(v); 1815 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_NAME_REG); 1816 } 1817 } 1818 1819 /** 1820 * @tc.name: parser_test_054 1821 * @tc.desc: Verify the array function. 1822 * @tc.type: FUNC 1823 * @tc.require: issueNumber 1824 */ 1825 HWTEST_F(ParserTest, parser_test_054, TestSize.Level1) 1826 { 1827 std::vector<std::vector<panda::pandasm::Token>> v; 1828 Lexer l; 1829 Parser p; 1830 v.push_back(l.TokenizeString(".array array {").first); 1831 v.push_back(l.TokenizeString("u1 1").first); 1832 v.push_back(l.TokenizeString("u8 2").first); 1833 v.push_back(l.TokenizeString("i8 -30").first); 1834 v.push_back(l.TokenizeString("u16 400").first); 1835 v.push_back(l.TokenizeString("i16 -5000").first); 1836 v.push_back(l.TokenizeString("u32 60000").first); 1837 v.push_back(l.TokenizeString("i32 -700000").first); 1838 v.push_back(l.TokenizeString("u64 8000000").first); 1839 v.push_back(l.TokenizeString("i64 -90000000").first); 1840 v.push_back(l.TokenizeString("}").first); 1841 1842 auto item = p.Parse(v); 1843 EXPECT_EQ(item.Value().literalarray_table.at("array").literals_[0].tag_, panda::panda_file::LiteralTag::ARRAY_U1); 1844 EXPECT_EQ( 1845 static_cast<uint64_t>(std::get<bool>(item.Value().literalarray_table.at("array").literals_[0].value_)), true); 1846 EXPECT_EQ(item.Value().literalarray_table.at("array").literals_[1].tag_, panda::panda_file::LiteralTag::ARRAY_U8); 1847 int8_t u8 = 2; 1848 int8_t i8 = -30; 1849 EXPECT_EQ( 1850 static_cast<uint8_t>(std::get<uint8_t>(item.Value().literalarray_table.at("array").literals_[1].value_)), u8); 1851 EXPECT_EQ(item.Value().literalarray_table.at("array").literals_[2].tag_, panda::panda_file::LiteralTag::ARRAY_I8); 1852 EXPECT_EQ(static_cast<int8_t>(std::get<uint8_t>(item.Value().literalarray_table.at("array").literals_[2].value_)), 1853 i8); 1854 EXPECT_EQ(item.Value().literalarray_table.at("array").literals_[3].tag_, panda::panda_file::LiteralTag::ARRAY_U16); 1855 uint16_t u16 = 400; 1856 int16_t i16 = -5000; 1857 EXPECT_EQ( 1858 static_cast<uint16_t>(std::get<uint16_t>(item.Value().literalarray_table.at("array").literals_[3].value_)), 1859 u16); 1860 EXPECT_EQ(item.Value().literalarray_table.at("array").literals_[4].tag_, panda::panda_file::LiteralTag::ARRAY_I16); 1861 EXPECT_EQ(static_cast<int16_t>(std::get<uint16_t>(item.Value().literalarray_table.at("array").literals_[4].value_)), 1862 i16); 1863 EXPECT_EQ(item.Value().literalarray_table.at("array").literals_[5].tag_, panda::panda_file::LiteralTag::ARRAY_U32); 1864 uint32_t ui32 = 60000; 1865 int32_t i32 = -700000; 1866 EXPECT_EQ( 1867 static_cast<uint32_t>(std::get<uint32_t>(item.Value().literalarray_table.at("array").literals_[5].value_)), 1868 ui32); 1869 EXPECT_EQ(item.Value().literalarray_table.at("array").literals_[6].tag_, panda::panda_file::LiteralTag::ARRAY_I32); 1870 EXPECT_EQ(static_cast<int32_t>(std::get<uint32_t>(item.Value().literalarray_table.at("array").literals_[6].value_)), 1871 i32); 1872 EXPECT_EQ(item.Value().literalarray_table.at("array").literals_[7].tag_, panda::panda_file::LiteralTag::ARRAY_U64); 1873 uint64_t ui64 = 8000000; 1874 int64_t i64 = -90000000; 1875 EXPECT_EQ( 1876 static_cast<uint64_t>(std::get<uint64_t>(item.Value().literalarray_table.at("array").literals_[7].value_)), 1877 ui64); 1878 EXPECT_EQ(item.Value().literalarray_table.at("array").literals_[8].tag_, panda::panda_file::LiteralTag::ARRAY_I64); 1879 EXPECT_EQ(static_cast<int64_t>(std::get<uint64_t>(item.Value().literalarray_table.at("array").literals_[8].value_)), 1880 i64); 1881 } 1882 1883 /** 1884 * @tc.name: parser_test_055 1885 * @tc.desc: Verify the TokenizeString function. 1886 * @tc.type: FUNC 1887 * @tc.require: issueNumber 1888 */ 1889 HWTEST_F(ParserTest, parser_test_055, TestSize.Level1) 1890 { 1891 std::vector<std::vector<panda::pandasm::Token>> v; 1892 Lexer l; 1893 Parser p; 1894 v.push_back(l.TokenizeString(".array array {").first); 1895 v.push_back(l.TokenizeString("f32 -123.4").first); 1896 v.push_back(l.TokenizeString("f64 -1234.5").first); 1897 v.push_back(l.TokenizeString("}").first); 1898 auto item = p.Parse(v); 1899 double f32 = -123.4; 1900 double f64 = -1234.5; 1901 EXPECT_EQ(item.Value().literalarray_table.at("array").literals_[0].tag_, panda::panda_file::LiteralTag::ARRAY_F32); 1902 EXPECT_NEAR(std::get<float>(item.Value().literalarray_table.at("array").literals_[0].value_), f32, 0.01f); 1903 EXPECT_EQ(item.Value().literalarray_table.at("array").literals_[1].tag_, panda::panda_file::LiteralTag::ARRAY_F64); 1904 EXPECT_NEAR(std::get<double>(item.Value().literalarray_table.at("array").literals_[1].value_), f64, 0.01f); 1905 } 1906 1907 /** 1908 * @tc.name: parser_test_056 1909 * @tc.desc: Verify the TokenizeString function. 1910 * @tc.type: FUNC 1911 * @tc.require: issueNumber 1912 */ 1913 HWTEST_F(ParserTest, parser_test_056, TestSize.Level1) 1914 { 1915 std::vector<std::vector<panda::pandasm::Token>> v; 1916 Lexer l; 1917 Parser p; 1918 v.push_back(l.TokenizeString(".array array {").first); 1919 v.push_back(l.TokenizeString("panda.String \"a\"").first); 1920 v.push_back(l.TokenizeString("panda.String \"ab\"").first); 1921 v.push_back(l.TokenizeString("panda.String \"abc\"").first); 1922 v.push_back(l.TokenizeString("}").first); 1923 v.push_back(l.TokenizeString(".array array_static panda.String 3 { \"a\" \"ab\" \"abc\" }").first); 1924 auto item = p.Parse(v); 1925 1926 EXPECT_EQ(item.Value().literalarray_table.at("array").literals_[0].tag_, 1927 panda::panda_file::LiteralTag::ARRAY_STRING); 1928 EXPECT_EQ(std::get<std::string>(item.Value().literalarray_table.at("array").literals_[0].value_), "a"); 1929 EXPECT_EQ(item.Value().literalarray_table.at("array").literals_[1].tag_, 1930 panda::panda_file::LiteralTag::ARRAY_STRING); 1931 EXPECT_EQ(std::get<std::string>(item.Value().literalarray_table.at("array").literals_[1].value_), "ab"); 1932 EXPECT_EQ(item.Value().literalarray_table.at("array").literals_[2].tag_, 1933 panda::panda_file::LiteralTag::ARRAY_STRING); 1934 EXPECT_EQ(std::get<std::string>(item.Value().literalarray_table.at("array").literals_[2].value_), "abc"); 1935 1936 // string intro literals 1937 EXPECT_EQ(item.Value().literalarray_table.at("array_static").literals_[0].tag_, 1938 panda::panda_file::LiteralTag::TAGVALUE); 1939 EXPECT_EQ(std::get<uint8_t>(item.Value().literalarray_table.at("array_static").literals_[0].value_), 1940 static_cast<uint8_t>(panda::panda_file::LiteralTag::ARRAY_STRING)); 1941 EXPECT_EQ(item.Value().literalarray_table.at("array_static").literals_[1].tag_, 1942 panda::panda_file::LiteralTag::INTEGER); 1943 EXPECT_EQ(std::get<uint32_t>(item.Value().literalarray_table.at("array_static").literals_[1].value_), 3); 1944 1945 // string array elements 1946 EXPECT_EQ(item.Value().literalarray_table.at("array_static").literals_[2].tag_, 1947 panda::panda_file::LiteralTag::ARRAY_STRING); 1948 EXPECT_EQ(std::get<std::string>(item.Value().literalarray_table.at("array_static").literals_[2].value_), "a"); 1949 EXPECT_EQ(item.Value().literalarray_table.at("array_static").literals_[3].tag_, 1950 panda::panda_file::LiteralTag::ARRAY_STRING); 1951 EXPECT_EQ(std::get<std::string>(item.Value().literalarray_table.at("array_static").literals_[3].value_), "ab"); 1952 EXPECT_EQ(item.Value().literalarray_table.at("array_static").literals_[4].tag_, 1953 panda::panda_file::LiteralTag::ARRAY_STRING); 1954 EXPECT_EQ(std::get<std::string>(item.Value().literalarray_table.at("array_static").literals_[4].value_), "abc"); 1955 } 1956 1957 /** 1958 * @tc.name: parser_test_057 1959 * @tc.desc: Verify the TokenizeString function. 1960 * @tc.type: FUNC 1961 * @tc.require: issueNumber 1962 */ 1963 HWTEST_F(ParserTest, parser_test_057, TestSize.Level1) 1964 { 1965 std::vector<std::vector<panda::pandasm::Token>> v; 1966 Lexer l; 1967 Parser p; 1968 v.push_back(l.TokenizeString(".array array u1 3 { 1 0 1 }").first); 1969 auto item = p.Parse(v); 1970 1971 EXPECT_EQ(item.Value().literalarray_table.at("array").literals_[0].tag_, panda::panda_file::LiteralTag::TAGVALUE); 1972 EXPECT_EQ(std::get<uint8_t>(item.Value().literalarray_table.at("array").literals_[0].value_), 1973 static_cast<uint8_t>(panda::panda_file::LiteralTag::ARRAY_U1)); 1974 EXPECT_EQ(item.Value().literalarray_table.at("array").literals_[1].tag_, panda::panda_file::LiteralTag::INTEGER); 1975 EXPECT_EQ(std::get<uint32_t>(item.Value().literalarray_table.at("array").literals_[1].value_), 3); 1976 EXPECT_EQ(item.Value().literalarray_table.at("array").literals_[2].tag_, panda::panda_file::LiteralTag::ARRAY_U1); 1977 EXPECT_EQ(std::get<bool>(item.Value().literalarray_table.at("array").literals_[2].value_), true); 1978 EXPECT_EQ(item.Value().literalarray_table.at("array").literals_[3].tag_, panda::panda_file::LiteralTag::ARRAY_U1); 1979 EXPECT_EQ(std::get<bool>(item.Value().literalarray_table.at("array").literals_[3].value_), false); 1980 EXPECT_EQ(item.Value().literalarray_table.at("array").literals_[4].tag_, panda::panda_file::LiteralTag::ARRAY_U1); 1981 EXPECT_EQ(std::get<bool>(item.Value().literalarray_table.at("array").literals_[4].value_), true); 1982 } 1983 1984 /** 1985 * @tc.name: parser_test_058 1986 * @tc.desc: Verify the array_unsigned_byte function. 1987 * @tc.type: FUNC 1988 * @tc.require: issueNumber 1989 */ 1990 HWTEST_F(ParserTest, parser_test_058, TestSize.Level1) 1991 { 1992 std::vector<std::vector<panda::pandasm::Token>> v; 1993 Lexer l; 1994 Parser p; 1995 v.push_back(l.TokenizeString(".array array_unsigned_byte u8 3 { 1 2 3 }").first); 1996 v.push_back(l.TokenizeString(".array array_byte i8 3 { -1 2 -3 }").first); 1997 v.push_back(l.TokenizeString(".array array_unsigned_short u16 3 { 100 200 300 }").first); 1998 v.push_back(l.TokenizeString(".array array_short i16 3 { 100 -200 300 }").first); 1999 v.push_back(l.TokenizeString(".array array_unsigned_int u32 3 { 1000 2000 3000 }").first); 2000 v.push_back(l.TokenizeString(".array array_int i32 3 { -1000 2000 -3000 }").first); 2001 v.push_back(l.TokenizeString(".array array_unsigned_long u64 3 { 10000 20000 30000 }").first); 2002 v.push_back(l.TokenizeString(".array array_long i64 3 { 10000 -20000 30000 }").first); 2003 auto item = p.Parse(v); 2004 2005 // unsigned byte intro literals 2006 EXPECT_EQ(item.Value().literalarray_table.at("array_unsigned_byte").literals_[0].tag_, 2007 panda::panda_file::LiteralTag::TAGVALUE); 2008 EXPECT_EQ(std::get<uint8_t>(item.Value().literalarray_table.at("array_unsigned_byte").literals_[0].value_), 2009 static_cast<uint8_t>(panda::panda_file::LiteralTag::ARRAY_U8)); 2010 EXPECT_EQ(item.Value().literalarray_table.at("array_unsigned_byte").literals_[1].tag_, 2011 panda::panda_file::LiteralTag::INTEGER); 2012 uint32_t u8_value = 3; 2013 EXPECT_EQ(std::get<uint32_t>(item.Value().literalarray_table.at("array_unsigned_byte").literals_[1].value_), 2014 u8_value); 2015 2016 // unsigned byte array elements 2017 EXPECT_EQ(item.Value().literalarray_table.at("array_unsigned_byte").literals_[2].tag_, 2018 panda::panda_file::LiteralTag::ARRAY_U8); 2019 EXPECT_EQ(std::get<uint8_t>(item.Value().literalarray_table.at("array_unsigned_byte").literals_[2].value_), 1); 2020 EXPECT_EQ(item.Value().literalarray_table.at("array_unsigned_byte").literals_[3].tag_, 2021 panda::panda_file::LiteralTag::ARRAY_U8); 2022 uint8_t u8_value1 = 2; 2023 EXPECT_EQ(std::get<uint8_t>(item.Value().literalarray_table.at("array_unsigned_byte").literals_[3].value_), 2024 u8_value1); 2025 EXPECT_EQ(item.Value().literalarray_table.at("array_unsigned_byte").literals_[4].tag_, 2026 panda::panda_file::LiteralTag::ARRAY_U8); 2027 uint8_t u8_value2 = 3; 2028 EXPECT_EQ(std::get<uint8_t>(item.Value().literalarray_table.at("array_unsigned_byte").literals_[4].value_), 2029 u8_value2); 2030 2031 // byte intro literals 2032 EXPECT_EQ(item.Value().literalarray_table.at("array_byte").literals_[0].tag_, 2033 panda::panda_file::LiteralTag::TAGVALUE); 2034 EXPECT_EQ(std::get<uint8_t>(item.Value().literalarray_table.at("array_byte").literals_[0].value_), 2035 static_cast<uint8_t>(panda::panda_file::LiteralTag::ARRAY_I8)); 2036 EXPECT_EQ(item.Value().literalarray_table.at("array_byte").literals_[1].tag_, 2037 panda::panda_file::LiteralTag::INTEGER); 2038 EXPECT_EQ(std::get<uint32_t>(item.Value().literalarray_table.at("array_byte").literals_[1].value_), u8_value); 2039 2040 // byte array elements 2041 EXPECT_EQ(item.Value().literalarray_table.at("array_byte").literals_[2].tag_, 2042 panda::panda_file::LiteralTag::ARRAY_I8); 2043 EXPECT_EQ( 2044 static_cast<int8_t>(std::get<uint8_t>(item.Value().literalarray_table.at("array_byte").literals_[2].value_)), 2045 -1); 2046 EXPECT_EQ(item.Value().literalarray_table.at("array_byte").literals_[3].tag_, 2047 panda::panda_file::LiteralTag::ARRAY_I8); 2048 EXPECT_EQ( 2049 static_cast<int8_t>(std::get<uint8_t>(item.Value().literalarray_table.at("array_byte").literals_[3].value_)), 2050 2); 2051 EXPECT_EQ(item.Value().literalarray_table.at("array_byte").literals_[4].tag_, 2052 panda::panda_file::LiteralTag::ARRAY_I8); 2053 EXPECT_EQ( 2054 static_cast<int8_t>(std::get<uint8_t>(item.Value().literalarray_table.at("array_byte").literals_[4].value_)), 2055 -3); 2056 2057 // unsigned short intro literals 2058 EXPECT_EQ(item.Value().literalarray_table.at("array_unsigned_short").literals_[0].tag_, 2059 panda::panda_file::LiteralTag::TAGVALUE); 2060 EXPECT_EQ(std::get<uint8_t>(item.Value().literalarray_table.at("array_unsigned_short").literals_[0].value_), 2061 static_cast<uint8_t>(panda::panda_file::LiteralTag::ARRAY_U16)); 2062 EXPECT_EQ(item.Value().literalarray_table.at("array_unsigned_short").literals_[1].tag_, 2063 panda::panda_file::LiteralTag::INTEGER); 2064 EXPECT_EQ(std::get<uint32_t>(item.Value().literalarray_table.at("array_unsigned_short").literals_[1].value_), 2065 u8_value); 2066 2067 // unsigned short array elements 2068 EXPECT_EQ(item.Value().literalarray_table.at("array_unsigned_short").literals_[2].tag_, 2069 panda::panda_file::LiteralTag::ARRAY_U16); 2070 uint16_t u16_value = 100; 2071 EXPECT_EQ(std::get<uint16_t>(item.Value().literalarray_table.at("array_unsigned_short").literals_[2].value_), 2072 u16_value); 2073 EXPECT_EQ(item.Value().literalarray_table.at("array_unsigned_short").literals_[3].tag_, 2074 panda::panda_file::LiteralTag::ARRAY_U16); 2075 u16_value = 200; 2076 EXPECT_EQ(std::get<uint16_t>(item.Value().literalarray_table.at("array_unsigned_short").literals_[3].value_), 2077 u16_value); 2078 EXPECT_EQ(item.Value().literalarray_table.at("array_unsigned_short").literals_[4].tag_, 2079 panda::panda_file::LiteralTag::ARRAY_U16); 2080 u16_value = 300; 2081 EXPECT_EQ(std::get<uint16_t>(item.Value().literalarray_table.at("array_unsigned_short").literals_[4].value_), 2082 u16_value); 2083 2084 // short intro literals 2085 EXPECT_EQ(item.Value().literalarray_table.at("array_short").literals_[0].tag_, 2086 panda::panda_file::LiteralTag::TAGVALUE); 2087 EXPECT_EQ(std::get<uint8_t>(item.Value().literalarray_table.at("array_short").literals_[0].value_), 2088 static_cast<uint8_t>(panda::panda_file::LiteralTag::ARRAY_I16)); 2089 EXPECT_EQ(item.Value().literalarray_table.at("array_short").literals_[1].tag_, 2090 panda::panda_file::LiteralTag::INTEGER); 2091 uint32_t u32_value = 3; 2092 EXPECT_EQ(std::get<uint32_t>(item.Value().literalarray_table.at("array_short").literals_[1].value_), u32_value); 2093 2094 // short array elements 2095 EXPECT_EQ(item.Value().literalarray_table.at("array_short").literals_[2].tag_, 2096 panda::panda_file::LiteralTag::ARRAY_I16); 2097 int16_t i16_value = 100; 2098 EXPECT_EQ( 2099 static_cast<int16_t>(std::get<uint16_t>(item.Value().literalarray_table.at("array_short").literals_[2].value_)), 2100 i16_value); 2101 EXPECT_EQ(item.Value().literalarray_table.at("array_short").literals_[3].tag_, 2102 panda::panda_file::LiteralTag::ARRAY_I16); 2103 i16_value = -200; 2104 EXPECT_EQ( 2105 static_cast<int16_t>(std::get<uint16_t>(item.Value().literalarray_table.at("array_short").literals_[3].value_)), 2106 i16_value); 2107 EXPECT_EQ(item.Value().literalarray_table.at("array_short").literals_[4].tag_, 2108 panda::panda_file::LiteralTag::ARRAY_I16); 2109 i16_value = 300; 2110 EXPECT_EQ( 2111 static_cast<int16_t>(std::get<uint16_t>(item.Value().literalarray_table.at("array_short").literals_[4].value_)), 2112 i16_value); 2113 2114 // unsigned int intro literals 2115 EXPECT_EQ(item.Value().literalarray_table.at("array_unsigned_int").literals_[0].tag_, 2116 panda::panda_file::LiteralTag::TAGVALUE); 2117 EXPECT_EQ(std::get<uint8_t>(item.Value().literalarray_table.at("array_unsigned_int").literals_[0].value_), 2118 static_cast<uint8_t>(panda::panda_file::LiteralTag::ARRAY_U32)); 2119 EXPECT_EQ(item.Value().literalarray_table.at("array_unsigned_int").literals_[1].tag_, 2120 panda::panda_file::LiteralTag::INTEGER); 2121 EXPECT_EQ(std::get<uint32_t>(item.Value().literalarray_table.at("array_unsigned_int").literals_[1].value_), 3); 2122 2123 // unsigned int array elements 2124 EXPECT_EQ(item.Value().literalarray_table.at("array_unsigned_int").literals_[2].tag_, 2125 panda::panda_file::LiteralTag::ARRAY_U32); 2126 uint32_t lit_value = 1000; 2127 EXPECT_EQ(std::get<uint32_t>(item.Value().literalarray_table.at("array_unsigned_int").literals_[2].value_), 2128 lit_value); 2129 EXPECT_EQ(item.Value().literalarray_table.at("array_unsigned_int").literals_[3].tag_, 2130 panda::panda_file::LiteralTag::ARRAY_U32); 2131 lit_value = 2000; 2132 EXPECT_EQ(std::get<uint32_t>(item.Value().literalarray_table.at("array_unsigned_int").literals_[3].value_), 2133 lit_value); 2134 EXPECT_EQ(item.Value().literalarray_table.at("array_unsigned_int").literals_[4].tag_, 2135 panda::panda_file::LiteralTag::ARRAY_U32); 2136 lit_value = 3000; 2137 EXPECT_EQ(std::get<uint32_t>(item.Value().literalarray_table.at("array_unsigned_int").literals_[4].value_), 2138 lit_value); 2139 2140 // int intro literals 2141 EXPECT_EQ(item.Value().literalarray_table.at("array_int").literals_[0].tag_, 2142 panda::panda_file::LiteralTag::TAGVALUE); 2143 EXPECT_EQ(std::get<uint8_t>(item.Value().literalarray_table.at("array_int").literals_[0].value_), 2144 static_cast<uint8_t>(panda::panda_file::LiteralTag::ARRAY_I32)); 2145 EXPECT_EQ(item.Value().literalarray_table.at("array_int").literals_[1].tag_, 2146 panda::panda_file::LiteralTag::INTEGER); 2147 EXPECT_EQ(std::get<uint32_t>(item.Value().literalarray_table.at("array_int").literals_[1].value_), 3); 2148 2149 // int array elements 2150 EXPECT_EQ(item.Value().literalarray_table.at("array_int").literals_[2].tag_, 2151 panda::panda_file::LiteralTag::ARRAY_I32); 2152 int32_t lit_value1 = -1000; 2153 EXPECT_EQ( 2154 static_cast<int32_t>(std::get<uint32_t>(item.Value().literalarray_table.at("array_int").literals_[2].value_)), 2155 lit_value1); 2156 EXPECT_EQ(item.Value().literalarray_table.at("array_int").literals_[3].tag_, 2157 panda::panda_file::LiteralTag::ARRAY_I32); 2158 lit_value1 = 2000; 2159 EXPECT_EQ( 2160 static_cast<int32_t>(std::get<uint32_t>(item.Value().literalarray_table.at("array_int").literals_[3].value_)), 2161 lit_value1); 2162 EXPECT_EQ(item.Value().literalarray_table.at("array_int").literals_[4].tag_, 2163 panda::panda_file::LiteralTag::ARRAY_I32); 2164 lit_value1 = -3000; 2165 EXPECT_EQ( 2166 static_cast<int32_t>(std::get<uint32_t>(item.Value().literalarray_table.at("array_int").literals_[4].value_)), 2167 lit_value1); 2168 2169 // unsigned long intro literals 2170 auto literals = item.Value().literalarray_table.at("array_unsigned_long").literals_; 2171 EXPECT_EQ(literals[0].tag_, panda::panda_file::LiteralTag::TAGVALUE); 2172 EXPECT_EQ(std::get<uint8_t>(literals[0].value_), static_cast<uint8_t>(panda::panda_file::LiteralTag::ARRAY_U64)); 2173 EXPECT_EQ(literals[1].tag_, panda::panda_file::LiteralTag::INTEGER); 2174 EXPECT_EQ(std::get<uint32_t>(literals[1].value_), 3); 2175 2176 // unsigned long array elements 2177 EXPECT_EQ(literals[2].tag_, panda::panda_file::LiteralTag::ARRAY_U64); 2178 EXPECT_EQ(static_cast<int64_t>(std::get<uint64_t>(literals[2].value_)), 10000); 2179 EXPECT_EQ(literals[3].tag_, panda::panda_file::LiteralTag::ARRAY_U64); 2180 EXPECT_EQ(static_cast<int64_t>(std::get<uint64_t>(literals[3].value_)), 20000); 2181 EXPECT_EQ(literals[4].tag_, panda::panda_file::LiteralTag::ARRAY_U64); 2182 EXPECT_EQ(static_cast<int64_t>(std::get<uint64_t>(literals[4].value_)), 30000); 2183 2184 // long intro literals 2185 EXPECT_EQ(item.Value().literalarray_table.at("array_long").literals_[0].tag_, 2186 panda::panda_file::LiteralTag::TAGVALUE); 2187 EXPECT_EQ(std::get<uint8_t>(item.Value().literalarray_table.at("array_long").literals_[0].value_), 2188 static_cast<uint8_t>(panda::panda_file::LiteralTag::ARRAY_I64)); 2189 EXPECT_EQ(item.Value().literalarray_table.at("array_long").literals_[1].tag_, 2190 panda::panda_file::LiteralTag::INTEGER); 2191 uint32_t lit_value2 = 3; 2192 EXPECT_EQ(std::get<uint32_t>(item.Value().literalarray_table.at("array_long").literals_[1].value_), lit_value2); 2193 2194 // long array elements 2195 EXPECT_EQ(item.Value().literalarray_table.at("array_long").literals_[2].tag_, 2196 panda::panda_file::LiteralTag::ARRAY_I64); 2197 int64_t i64_value1 = 10000; 2198 EXPECT_EQ( 2199 static_cast<int64_t>(std::get<uint64_t>(item.Value().literalarray_table.at("array_long").literals_[2].value_)), 2200 i64_value1); 2201 EXPECT_EQ(item.Value().literalarray_table.at("array_long").literals_[3].tag_, 2202 panda::panda_file::LiteralTag::ARRAY_I64); 2203 i64_value1 = -20000; 2204 EXPECT_EQ( 2205 static_cast<int64_t>(std::get<uint64_t>(item.Value().literalarray_table.at("array_long").literals_[3].value_)), 2206 i64_value1); 2207 EXPECT_EQ(item.Value().literalarray_table.at("array_long").literals_[4].tag_, 2208 panda::panda_file::LiteralTag::ARRAY_I64); 2209 i64_value1 = 30000; 2210 EXPECT_EQ( 2211 static_cast<int64_t>(std::get<uint64_t>(item.Value().literalarray_table.at("array_long").literals_[4].value_)), 2212 i64_value1); 2213 } 2214 2215 /** 2216 * @tc.name: parser_test_059 2217 * @tc.desc: Verify the array_float function. 2218 * @tc.type: FUNC 2219 * @tc.require: issueNumber 2220 */ 2221 HWTEST_F(ParserTest, parser_test_059, TestSize.Level1) 2222 { 2223 std::vector<std::vector<panda::pandasm::Token>> v; 2224 Lexer l; 2225 Parser p; 2226 v.push_back(l.TokenizeString(".array array_float f32 3 { 12.3 -12.34 12.345 }").first); 2227 v.push_back(l.TokenizeString(".array array_double f64 3 { -120.3 120.34 -120.345 }").first); 2228 auto item = p.Parse(v); 2229 2230 // float intro literals 2231 EXPECT_EQ(item.Value().literalarray_table.at("array_float").literals_[0].tag_, 2232 panda::panda_file::LiteralTag::TAGVALUE); 2233 EXPECT_EQ(std::get<uint8_t>(item.Value().literalarray_table.at("array_float").literals_[0].value_), 2234 static_cast<uint8_t>(panda::panda_file::LiteralTag::ARRAY_F32)); 2235 EXPECT_EQ(item.Value().literalarray_table.at("array_float").literals_[1].tag_, 2236 panda::panda_file::LiteralTag::INTEGER); 2237 EXPECT_EQ(std::get<uint32_t>(item.Value().literalarray_table.at("array_float").literals_[1].value_), 3); 2238 2239 // float array elements 2240 EXPECT_EQ(item.Value().literalarray_table.at("array_float").literals_[2].tag_, 2241 panda::panda_file::LiteralTag::ARRAY_F32); 2242 float f_value = 12.3; 2243 double d_value = -12.34; 2244 ASSERT_NEAR(std::get<float>(item.Value().literalarray_table.at("array_float").literals_[2].value_), f_value, 0.01f); 2245 EXPECT_EQ(item.Value().literalarray_table.at("array_float").literals_[3].tag_, 2246 panda::panda_file::LiteralTag::ARRAY_F32); 2247 ASSERT_NEAR(std::get<float>(item.Value().literalarray_table.at("array_float").literals_[3].value_), d_value, 2248 0.001f); 2249 EXPECT_EQ(item.Value().literalarray_table.at("array_float").literals_[4].tag_, 2250 panda::panda_file::LiteralTag::ARRAY_F32); 2251 f_value = 12.345; 2252 ASSERT_NEAR(std::get<float>(item.Value().literalarray_table.at("array_float").literals_[4].value_), f_value, 2253 0.0001f); 2254 2255 // double intro literals 2256 EXPECT_EQ(item.Value().literalarray_table.at("array_double").literals_[0].tag_, 2257 panda::panda_file::LiteralTag::TAGVALUE); 2258 EXPECT_EQ(std::get<uint8_t>(item.Value().literalarray_table.at("array_double").literals_[0].value_), 2259 static_cast<uint8_t>(panda::panda_file::LiteralTag::ARRAY_F64)); 2260 EXPECT_EQ(item.Value().literalarray_table.at("array_double").literals_[1].tag_, 2261 panda::panda_file::LiteralTag::INTEGER); 2262 EXPECT_EQ(std::get<uint32_t>(item.Value().literalarray_table.at("array_double").literals_[1].value_), 3); 2263 2264 // double array elements 2265 EXPECT_EQ(item.Value().literalarray_table.at("array_double").literals_[2].tag_, 2266 panda::panda_file::LiteralTag::ARRAY_F64); 2267 d_value = -120.3; 2268 ASSERT_NEAR(std::get<double>(item.Value().literalarray_table.at("array_double").literals_[2].value_), d_value, 2269 0.01f); 2270 EXPECT_EQ(item.Value().literalarray_table.at("array_double").literals_[3].tag_, 2271 panda::panda_file::LiteralTag::ARRAY_F64); 2272 d_value = 120.34; 2273 ASSERT_NEAR(std::get<double>(item.Value().literalarray_table.at("array_double").literals_[3].value_), d_value, 2274 0.001f); 2275 EXPECT_EQ(item.Value().literalarray_table.at("array_double").literals_[4].tag_, 2276 panda::panda_file::LiteralTag::ARRAY_F64); 2277 d_value = -120.345; 2278 ASSERT_NEAR(std::get<double>(item.Value().literalarray_table.at("array_double").literals_[4].value_), d_value, 2279 0.0001f); 2280 } 2281 2282 /** 2283 * @tc.name: parser_test_060 2284 * @tc.desc: Verify the panda.String function. 2285 * @tc.type: FUNC 2286 * @tc.require: issueNumber 2287 */ 2288 HWTEST_F(ParserTest, parser_test_060, TestSize.Level1) 2289 { 2290 std::vector<std::vector<panda::pandasm::Token>> v; 2291 Lexer l; 2292 Parser p; 2293 v.push_back(l.TokenizeString(".array array panda.String 3 { \"a\" \"ab\" \"abc\" }").first); 2294 auto item = p.Parse(v); 2295 2296 // string intro literals 2297 EXPECT_EQ(item.Value().literalarray_table.at("array").literals_[0].tag_, panda::panda_file::LiteralTag::TAGVALUE); 2298 EXPECT_EQ(std::get<uint8_t>(item.Value().literalarray_table.at("array").literals_[0].value_), 2299 static_cast<uint8_t>(panda::panda_file::LiteralTag::ARRAY_STRING)); 2300 EXPECT_EQ(item.Value().literalarray_table.at("array").literals_[1].tag_, panda::panda_file::LiteralTag::INTEGER); 2301 EXPECT_EQ(std::get<uint32_t>(item.Value().literalarray_table.at("array").literals_[1].value_), 3); 2302 2303 // string array elements 2304 EXPECT_EQ(item.Value().literalarray_table.at("array").literals_[2].tag_, 2305 panda::panda_file::LiteralTag::ARRAY_STRING); 2306 EXPECT_EQ(std::get<std::string>(item.Value().literalarray_table.at("array").literals_[2].value_), "a"); 2307 EXPECT_EQ(item.Value().literalarray_table.at("array").literals_[3].tag_, 2308 panda::panda_file::LiteralTag::ARRAY_STRING); 2309 EXPECT_EQ(std::get<std::string>(item.Value().literalarray_table.at("array").literals_[3].value_), "ab"); 2310 EXPECT_EQ(item.Value().literalarray_table.at("array").literals_[4].tag_, 2311 panda::panda_file::LiteralTag::ARRAY_STRING); 2312 EXPECT_EQ(std::get<std::string>(item.Value().literalarray_table.at("array").literals_[4].value_), "abc"); 2313 } 2314 2315 /** 2316 * @tc.name: parser_test_061 2317 * @tc.desc: Verify the GetFunctionSignatureFromName function. 2318 * @tc.type: FUNC 2319 * @tc.require: issueNumber 2320 */ 2321 HWTEST_F(ParserTest, parser_test_061, TestSize.Level1) 2322 { 2323 Parser p; 2324 std::string source = R"( 2325 .function u1 f() {} 2326 .function u1 f(i8 a0) {} 2327 )"; 2328 2329 auto res = p.Parse(source); 2330 2331 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_NONE) << "ERR_NONE expected"; 2332 2333 auto &program = res.Value(); 2334 2335 std::vector<Function::Parameter> params; 2336 panda::panda_file::SourceLang language {panda::panda_file::SourceLang::PANDA_ASSEMBLY}; 2337 params.emplace_back(Type {"i8", 0}, language); 2338 const auto sig_f = GetFunctionSignatureFromName("f", {}); 2339 const auto sig_fi8 = GetFunctionSignatureFromName("f", params); 2340 2341 EXPECT_TRUE(program.function_table.find(sig_f) != program.function_table.end()); 2342 EXPECT_TRUE(program.function_table.find(sig_fi8) != program.function_table.end()); 2343 } 2344 2345 /** 2346 * @tc.name: parser_test_062 2347 * @tc.desc: Verify the ShowError function. 2348 * @tc.type: FUNC 2349 * @tc.require: issueNumber 2350 */ 2351 HWTEST_F(ParserTest, parser_test_062, TestSize.Level1) 2352 { 2353 Parser p; 2354 std::string source = R"( 2355 .function u1 f(i8 a0) {} 2356 .function i8 f(i8 a0) {} 2357 )"; 2358 2359 auto res = p.Parse(source); 2360 2361 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_BAD_ID_FUNCTION); 2362 } 2363 2364 /** 2365 * @tc.name: parser_test_063 2366 * @tc.desc: Verify the ldglobalvar function. 2367 * @tc.type: FUNC 2368 * @tc.require: issueNumber 2369 */ 2370 HWTEST_F(ParserTest, parser_test_063, TestSize.Level1) 2371 { 2372 Parser p; 2373 std::string source = R"( 2374 .function void gg(u1 a0) {} 2375 .function void f() { 2376 ldglobalvar 0x9, "gg" 2377 sta v4 2378 lda v4 2379 callarg0 0x1 2380 } 2381 )"; 2382 2383 auto res = p.Parse(source); 2384 2385 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_NONE); 2386 } 2387 2388 /** 2389 * @tc.name: parser_test_064 2390 * @tc.desc: Verify the ShowError function. 2391 * @tc.type: FUNC 2392 * @tc.require: issueNumber 2393 */ 2394 HWTEST_F(ParserTest, parser_test_064, TestSize.Level1) 2395 { 2396 Parser p; 2397 std::string source = R"( 2398 .function u1 f() {} 2399 .function u1 f(i8 a0) {} 2400 2401 .function void main(u1 a0) { 2402 ldglobalvar 0x9, "f" 2403 sta v4 2404 ldai 0x1 2405 sta v5 2406 lda v4 2407 callarg1 0x4, v5 2408 } 2409 )"; 2410 2411 auto res = p.Parse(source); 2412 2413 EXPECT_EQ(p.ShowError().err, Error::ErrorType::ERR_NONE); 2414 } 2415 }