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