1 // Copyright (c) 2010 Google Inc. 2 // All rights reserved. 3 // 4 // Redistribution and use in source and binary forms, with or without 5 // modification, are permitted provided that the following conditions are 6 // met: 7 // 8 // * Redistributions of source code must retain the above copyright 9 // notice, this list of conditions and the following disclaimer. 10 // * Redistributions in binary form must reproduce the above 11 // copyright notice, this list of conditions and the following disclaimer 12 // in the documentation and/or other materials provided with the 13 // distribution. 14 // * Neither the name of Google Inc. nor the names of its 15 // contributors may be used to endorse or promote products derived from 16 // this software without specific prior written permission. 17 // 18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 30 #include <assert.h> 31 #include <stdio.h> 32 33 #include <string> 34 35 #include "breakpad_googletest_includes.h" 36 #include "common/scoped_ptr.h" 37 #include "common/using_std_string.h" 38 #include "google_breakpad/processor/basic_source_line_resolver.h" 39 #include "google_breakpad/processor/code_module.h" 40 #include "google_breakpad/processor/stack_frame.h" 41 #include "google_breakpad/processor/memory_region.h" 42 #include "processor/linked_ptr.h" 43 #include "processor/logging.h" 44 #include "processor/windows_frame_info.h" 45 #include "processor/cfi_frame_info.h" 46 47 namespace { 48 49 using google_breakpad::BasicSourceLineResolver; 50 using google_breakpad::CFIFrameInfo; 51 using google_breakpad::CodeModule; 52 using google_breakpad::MemoryRegion; 53 using google_breakpad::StackFrame; 54 using google_breakpad::WindowsFrameInfo; 55 using google_breakpad::linked_ptr; 56 using google_breakpad::scoped_ptr; 57 using google_breakpad::SymbolParseHelper; 58 59 class TestCodeModule : public CodeModule { 60 public: 61 TestCodeModule(string code_file) : code_file_(code_file) {} 62 virtual ~TestCodeModule() {} 63 64 virtual uint64_t base_address() const { return 0; } 65 virtual uint64_t size() const { return 0xb000; } 66 virtual string code_file() const { return code_file_; } 67 virtual string code_identifier() const { return ""; } 68 virtual string debug_file() const { return ""; } 69 virtual string debug_identifier() const { return ""; } 70 virtual string version() const { return ""; } 71 virtual const CodeModule* Copy() const { 72 return new TestCodeModule(code_file_); 73 } 74 75 private: 76 string code_file_; 77 }; 78 79 // A mock memory region object, for use by the STACK CFI tests. 80 class MockMemoryRegion: public MemoryRegion { 81 uint64_t GetBase() const { return 0x10000; } 82 uint32_t GetSize() const { return 0x01000; } 83 bool GetMemoryAtAddress(uint64_t address, uint8_t *value) const { 84 *value = address & 0xff; 85 return true; 86 } 87 bool GetMemoryAtAddress(uint64_t address, uint16_t *value) const { 88 *value = address & 0xffff; 89 return true; 90 } 91 bool GetMemoryAtAddress(uint64_t address, uint32_t *value) const { 92 switch (address) { 93 case 0x10008: *value = 0x98ecadc3; break; // saved %ebx 94 case 0x1000c: *value = 0x878f7524; break; // saved %esi 95 case 0x10010: *value = 0x6312f9a5; break; // saved %edi 96 case 0x10014: *value = 0x10038; break; // caller's %ebp 97 case 0x10018: *value = 0xf6438648; break; // return address 98 default: *value = 0xdeadbeef; break; // junk 99 } 100 return true; 101 } 102 bool GetMemoryAtAddress(uint64_t address, uint64_t *value) const { 103 *value = address; 104 return true; 105 } 106 void Print() const { 107 assert(false); 108 } 109 }; 110 111 // Verify that, for every association in ACTUAL, EXPECTED has the same 112 // association. (That is, ACTUAL's associations should be a subset of 113 // EXPECTED's.) Also verify that ACTUAL has associations for ".ra" and 114 // ".cfa". 115 static bool VerifyRegisters( 116 const char *file, int line, 117 const CFIFrameInfo::RegisterValueMap<uint32_t> &expected, 118 const CFIFrameInfo::RegisterValueMap<uint32_t> &actual) { 119 CFIFrameInfo::RegisterValueMap<uint32_t>::const_iterator a; 120 a = actual.find(".cfa"); 121 if (a == actual.end()) 122 return false; 123 a = actual.find(".ra"); 124 if (a == actual.end()) 125 return false; 126 for (a = actual.begin(); a != actual.end(); a++) { 127 CFIFrameInfo::RegisterValueMap<uint32_t>::const_iterator e = 128 expected.find(a->first); 129 if (e == expected.end()) { 130 fprintf(stderr, "%s:%d: unexpected register '%s' recovered, value 0x%x\n", 131 file, line, a->first.c_str(), a->second); 132 return false; 133 } 134 if (e->second != a->second) { 135 fprintf(stderr, 136 "%s:%d: register '%s' recovered value was 0x%x, expected 0x%x\n", 137 file, line, a->first.c_str(), a->second, e->second); 138 return false; 139 } 140 // Don't complain if this doesn't recover all registers. Although 141 // the DWARF spec says that unmentioned registers are undefined, 142 // GCC uses omission to mean that they are unchanged. 143 } 144 return true; 145 } 146 147 148 static bool VerifyEmpty(const StackFrame &frame) { 149 if (frame.function_name.empty() && 150 frame.source_file_name.empty() && 151 frame.source_line == 0) 152 return true; 153 return false; 154 } 155 156 static void ClearSourceLineInfo(StackFrame *frame) { 157 frame->function_name.clear(); 158 frame->module = NULL; 159 frame->source_file_name.clear(); 160 frame->source_line = 0; 161 } 162 163 class TestBasicSourceLineResolver : public ::testing::Test { 164 public: 165 void SetUp() { 166 testdata_dir = string(getenv("srcdir") ? getenv("srcdir") : ".") + 167 "/src/processor/testdata"; 168 } 169 170 BasicSourceLineResolver resolver; 171 string testdata_dir; 172 }; 173 174 TEST_F(TestBasicSourceLineResolver, TestLoadAndResolve) 175 { 176 TestCodeModule module1("module1"); 177 ASSERT_TRUE(resolver.LoadModule(&module1, testdata_dir + "/module1.out")); 178 ASSERT_TRUE(resolver.HasModule(&module1)); 179 TestCodeModule module2("module2"); 180 ASSERT_TRUE(resolver.LoadModule(&module2, testdata_dir + "/module2.out")); 181 ASSERT_TRUE(resolver.HasModule(&module2)); 182 183 184 StackFrame frame; 185 scoped_ptr<WindowsFrameInfo> windows_frame_info; 186 scoped_ptr<CFIFrameInfo> cfi_frame_info; 187 frame.instruction = 0x1000; 188 frame.module = NULL; 189 resolver.FillSourceLineInfo(&frame); 190 ASSERT_FALSE(frame.module); 191 ASSERT_TRUE(frame.function_name.empty()); 192 ASSERT_EQ(frame.function_base, 0U); 193 ASSERT_TRUE(frame.source_file_name.empty()); 194 ASSERT_EQ(frame.source_line, 0); 195 ASSERT_EQ(frame.source_line_base, 0U); 196 197 frame.module = &module1; 198 resolver.FillSourceLineInfo(&frame); 199 ASSERT_EQ(frame.function_name, "Function1_1"); 200 ASSERT_TRUE(frame.module); 201 ASSERT_EQ(frame.module->code_file(), "module1"); 202 ASSERT_EQ(frame.function_base, 0x1000U); 203 ASSERT_EQ(frame.source_file_name, "file1_1.cc"); 204 ASSERT_EQ(frame.source_line, 44); 205 ASSERT_EQ(frame.source_line_base, 0x1000U); 206 windows_frame_info.reset(resolver.FindWindowsFrameInfo(&frame)); 207 ASSERT_TRUE(windows_frame_info.get()); 208 ASSERT_EQ(windows_frame_info->type_, WindowsFrameInfo::STACK_INFO_FRAME_DATA); 209 ASSERT_FALSE(windows_frame_info->allocates_base_pointer); 210 ASSERT_EQ(windows_frame_info->program_string, 211 "$eip 4 + ^ = $esp $ebp 8 + = $ebp $ebp ^ ="); 212 213 ClearSourceLineInfo(&frame); 214 frame.instruction = 0x800; 215 frame.module = &module1; 216 resolver.FillSourceLineInfo(&frame); 217 ASSERT_TRUE(VerifyEmpty(frame)); 218 windows_frame_info.reset(resolver.FindWindowsFrameInfo(&frame)); 219 ASSERT_FALSE(windows_frame_info.get()); 220 221 frame.instruction = 0x1280; 222 resolver.FillSourceLineInfo(&frame); 223 ASSERT_EQ(frame.function_name, "Function1_3"); 224 ASSERT_TRUE(frame.source_file_name.empty()); 225 ASSERT_EQ(frame.source_line, 0); 226 windows_frame_info.reset(resolver.FindWindowsFrameInfo(&frame)); 227 ASSERT_TRUE(windows_frame_info.get()); 228 ASSERT_EQ(windows_frame_info->type_, WindowsFrameInfo::STACK_INFO_UNKNOWN); 229 ASSERT_FALSE(windows_frame_info->allocates_base_pointer); 230 ASSERT_TRUE(windows_frame_info->program_string.empty()); 231 232 frame.instruction = 0x1380; 233 resolver.FillSourceLineInfo(&frame); 234 ASSERT_EQ(frame.function_name, "Function1_4"); 235 ASSERT_TRUE(frame.source_file_name.empty()); 236 ASSERT_EQ(frame.source_line, 0); 237 windows_frame_info.reset(resolver.FindWindowsFrameInfo(&frame)); 238 ASSERT_EQ(windows_frame_info->type_, WindowsFrameInfo::STACK_INFO_FRAME_DATA); 239 ASSERT_TRUE(windows_frame_info.get()); 240 ASSERT_FALSE(windows_frame_info->allocates_base_pointer); 241 ASSERT_FALSE(windows_frame_info->program_string.empty()); 242 243 frame.instruction = 0x2000; 244 windows_frame_info.reset(resolver.FindWindowsFrameInfo(&frame)); 245 ASSERT_FALSE(windows_frame_info.get()); 246 247 // module1 has STACK CFI records covering 3d40..3def; 248 // module2 has STACK CFI records covering 3df0..3e9f; 249 // check that FindCFIFrameInfo doesn't claim to find any outside those ranges. 250 frame.instruction = 0x3d3f; 251 frame.module = &module1; 252 cfi_frame_info.reset(resolver.FindCFIFrameInfo(&frame)); 253 ASSERT_FALSE(cfi_frame_info.get()); 254 255 frame.instruction = 0x3e9f; 256 frame.module = &module1; 257 cfi_frame_info.reset(resolver.FindCFIFrameInfo(&frame)); 258 ASSERT_FALSE(cfi_frame_info.get()); 259 260 CFIFrameInfo::RegisterValueMap<uint32_t> current_registers; 261 CFIFrameInfo::RegisterValueMap<uint32_t> caller_registers; 262 CFIFrameInfo::RegisterValueMap<uint32_t> expected_caller_registers; 263 MockMemoryRegion memory; 264 265 // Regardless of which instruction evaluation takes place at, it 266 // should produce the same values for the caller's registers. 267 expected_caller_registers[".cfa"] = 0x1001c; 268 expected_caller_registers[".ra"] = 0xf6438648; 269 expected_caller_registers["$ebp"] = 0x10038; 270 expected_caller_registers["$ebx"] = 0x98ecadc3; 271 expected_caller_registers["$esi"] = 0x878f7524; 272 expected_caller_registers["$edi"] = 0x6312f9a5; 273 274 frame.instruction = 0x3d40; 275 frame.module = &module1; 276 current_registers.clear(); 277 current_registers["$esp"] = 0x10018; 278 current_registers["$ebp"] = 0x10038; 279 current_registers["$ebx"] = 0x98ecadc3; 280 current_registers["$esi"] = 0x878f7524; 281 current_registers["$edi"] = 0x6312f9a5; 282 cfi_frame_info.reset(resolver.FindCFIFrameInfo(&frame)); 283 ASSERT_TRUE(cfi_frame_info.get()); 284 ASSERT_TRUE(cfi_frame_info.get() 285 ->FindCallerRegs<uint32_t>(current_registers, memory, 286 &caller_registers)); 287 ASSERT_TRUE(VerifyRegisters(__FILE__, __LINE__, 288 expected_caller_registers, caller_registers)); 289 290 frame.instruction = 0x3d41; 291 current_registers["$esp"] = 0x10014; 292 cfi_frame_info.reset(resolver.FindCFIFrameInfo(&frame)); 293 ASSERT_TRUE(cfi_frame_info.get()); 294 ASSERT_TRUE(cfi_frame_info.get() 295 ->FindCallerRegs<uint32_t>(current_registers, memory, 296 &caller_registers)); 297 ASSERT_TRUE(VerifyRegisters(__FILE__, __LINE__, 298 expected_caller_registers, caller_registers)); 299 300 frame.instruction = 0x3d43; 301 current_registers["$ebp"] = 0x10014; 302 cfi_frame_info.reset(resolver.FindCFIFrameInfo(&frame)); 303 ASSERT_TRUE(cfi_frame_info.get()); 304 ASSERT_TRUE(cfi_frame_info.get() 305 ->FindCallerRegs<uint32_t>(current_registers, memory, 306 &caller_registers)); 307 VerifyRegisters(__FILE__, __LINE__, 308 expected_caller_registers, caller_registers); 309 310 frame.instruction = 0x3d54; 311 current_registers["$ebx"] = 0x6864f054U; 312 cfi_frame_info.reset(resolver.FindCFIFrameInfo(&frame)); 313 ASSERT_TRUE(cfi_frame_info.get()); 314 ASSERT_TRUE(cfi_frame_info.get() 315 ->FindCallerRegs<uint32_t>(current_registers, memory, 316 &caller_registers)); 317 VerifyRegisters(__FILE__, __LINE__, 318 expected_caller_registers, caller_registers); 319 320 frame.instruction = 0x3d5a; 321 current_registers["$esi"] = 0x6285f79aU; 322 cfi_frame_info.reset(resolver.FindCFIFrameInfo(&frame)); 323 ASSERT_TRUE(cfi_frame_info.get()); 324 ASSERT_TRUE(cfi_frame_info.get() 325 ->FindCallerRegs<uint32_t>(current_registers, memory, 326 &caller_registers)); 327 VerifyRegisters(__FILE__, __LINE__, 328 expected_caller_registers, caller_registers); 329 330 frame.instruction = 0x3d84; 331 current_registers["$edi"] = 0x64061449U; 332 cfi_frame_info.reset(resolver.FindCFIFrameInfo(&frame)); 333 ASSERT_TRUE(cfi_frame_info.get()); 334 ASSERT_TRUE(cfi_frame_info.get() 335 ->FindCallerRegs<uint32_t>(current_registers, memory, 336 &caller_registers)); 337 VerifyRegisters(__FILE__, __LINE__, 338 expected_caller_registers, caller_registers); 339 340 frame.instruction = 0x2900; 341 frame.module = &module1; 342 resolver.FillSourceLineInfo(&frame); 343 ASSERT_EQ(frame.function_name, string("PublicSymbol")); 344 345 frame.instruction = 0x4000; 346 frame.module = &module1; 347 resolver.FillSourceLineInfo(&frame); 348 ASSERT_EQ(frame.function_name, string("LargeFunction")); 349 350 frame.instruction = 0x2181; 351 frame.module = &module2; 352 resolver.FillSourceLineInfo(&frame); 353 ASSERT_EQ(frame.function_name, "Function2_2"); 354 ASSERT_EQ(frame.function_base, 0x2170U); 355 ASSERT_TRUE(frame.module); 356 ASSERT_EQ(frame.module->code_file(), "module2"); 357 ASSERT_EQ(frame.source_file_name, "file2_2.cc"); 358 ASSERT_EQ(frame.source_line, 21); 359 ASSERT_EQ(frame.source_line_base, 0x2180U); 360 windows_frame_info.reset(resolver.FindWindowsFrameInfo(&frame)); 361 ASSERT_TRUE(windows_frame_info.get()); 362 ASSERT_EQ(windows_frame_info->type_, WindowsFrameInfo::STACK_INFO_FRAME_DATA); 363 ASSERT_EQ(windows_frame_info->prolog_size, 1U); 364 365 frame.instruction = 0x216f; 366 resolver.FillSourceLineInfo(&frame); 367 ASSERT_EQ(frame.function_name, "Public2_1"); 368 369 ClearSourceLineInfo(&frame); 370 frame.instruction = 0x219f; 371 frame.module = &module2; 372 resolver.FillSourceLineInfo(&frame); 373 ASSERT_TRUE(frame.function_name.empty()); 374 375 frame.instruction = 0x21a0; 376 frame.module = &module2; 377 resolver.FillSourceLineInfo(&frame); 378 ASSERT_EQ(frame.function_name, "Public2_2"); 379 } 380 381 TEST_F(TestBasicSourceLineResolver, TestInvalidLoads) 382 { 383 TestCodeModule module3("module3"); 384 ASSERT_TRUE(resolver.LoadModule(&module3, 385 testdata_dir + "/module3_bad.out")); 386 ASSERT_TRUE(resolver.HasModule(&module3)); 387 ASSERT_TRUE(resolver.IsModuleCorrupt(&module3)); 388 TestCodeModule module4("module4"); 389 ASSERT_TRUE(resolver.LoadModule(&module4, 390 testdata_dir + "/module4_bad.out")); 391 ASSERT_TRUE(resolver.HasModule(&module4)); 392 ASSERT_TRUE(resolver.IsModuleCorrupt(&module4)); 393 TestCodeModule module5("module5"); 394 ASSERT_FALSE(resolver.LoadModule(&module5, 395 testdata_dir + "/invalid-filename")); 396 ASSERT_FALSE(resolver.HasModule(&module5)); 397 TestCodeModule invalidmodule("invalid-module"); 398 ASSERT_FALSE(resolver.HasModule(&invalidmodule)); 399 } 400 401 TEST_F(TestBasicSourceLineResolver, TestUnload) 402 { 403 TestCodeModule module1("module1"); 404 ASSERT_FALSE(resolver.HasModule(&module1)); 405 ASSERT_TRUE(resolver.LoadModule(&module1, testdata_dir + "/module1.out")); 406 ASSERT_TRUE(resolver.HasModule(&module1)); 407 resolver.UnloadModule(&module1); 408 ASSERT_FALSE(resolver.HasModule(&module1)); 409 ASSERT_TRUE(resolver.LoadModule(&module1, testdata_dir + "/module1.out")); 410 ASSERT_TRUE(resolver.HasModule(&module1)); 411 } 412 413 // Test parsing of valid FILE lines. The format is: 414 // FILE <id> <filename> 415 TEST(SymbolParseHelper, ParseFileValid) { 416 long index; 417 char *filename; 418 419 char kTestLine[] = "FILE 1 file name"; 420 ASSERT_TRUE(SymbolParseHelper::ParseFile(kTestLine, &index, &filename)); 421 EXPECT_EQ(1, index); 422 EXPECT_EQ("file name", string(filename)); 423 424 // 0 is a valid index. 425 char kTestLine1[] = "FILE 0 file name"; 426 ASSERT_TRUE(SymbolParseHelper::ParseFile(kTestLine1, &index, &filename)); 427 EXPECT_EQ(0, index); 428 EXPECT_EQ("file name", string(filename)); 429 } 430 431 // Test parsing of invalid FILE lines. The format is: 432 // FILE <id> <filename> 433 TEST(SymbolParseHelper, ParseFileInvalid) { 434 long index; 435 char *filename; 436 437 // Test missing file name. 438 char kTestLine[] = "FILE 1 "; 439 ASSERT_FALSE(SymbolParseHelper::ParseFile(kTestLine, &index, &filename)); 440 441 // Test bad index. 442 char kTestLine1[] = "FILE x1 file name"; 443 ASSERT_FALSE(SymbolParseHelper::ParseFile(kTestLine1, &index, &filename)); 444 445 // Test large index. 446 char kTestLine2[] = "FILE 123123123123123123123123 file name"; 447 ASSERT_FALSE(SymbolParseHelper::ParseFile(kTestLine2, &index, &filename)); 448 449 // Test negative index. 450 char kTestLine3[] = "FILE -2 file name"; 451 ASSERT_FALSE(SymbolParseHelper::ParseFile(kTestLine3, &index, &filename)); 452 } 453 454 // Test parsing of valid FUNC lines. The format is: 455 // FUNC <address> <size> <stack_param_size> <name> 456 TEST(SymbolParseHelper, ParseFunctionValid) { 457 uint64_t address; 458 uint64_t size; 459 long stack_param_size; 460 char *name; 461 462 char kTestLine[] = "FUNC 1 2 3 function name"; 463 ASSERT_TRUE(SymbolParseHelper::ParseFunction(kTestLine, &address, &size, 464 &stack_param_size, &name)); 465 EXPECT_EQ(1ULL, address); 466 EXPECT_EQ(2ULL, size); 467 EXPECT_EQ(3, stack_param_size); 468 EXPECT_EQ("function name", string(name)); 469 470 // Test hex address, size, and param size. 471 char kTestLine1[] = "FUNC a1 a2 a3 function name"; 472 ASSERT_TRUE(SymbolParseHelper::ParseFunction(kTestLine1, &address, &size, 473 &stack_param_size, &name)); 474 EXPECT_EQ(0xa1ULL, address); 475 EXPECT_EQ(0xa2ULL, size); 476 EXPECT_EQ(0xa3, stack_param_size); 477 EXPECT_EQ("function name", string(name)); 478 479 char kTestLine2[] = "FUNC 0 0 0 function name"; 480 ASSERT_TRUE(SymbolParseHelper::ParseFunction(kTestLine2, &address, &size, 481 &stack_param_size, &name)); 482 EXPECT_EQ(0ULL, address); 483 EXPECT_EQ(0ULL, size); 484 EXPECT_EQ(0, stack_param_size); 485 EXPECT_EQ("function name", string(name)); 486 } 487 488 // Test parsing of invalid FUNC lines. The format is: 489 // FUNC <address> <size> <stack_param_size> <name> 490 TEST(SymbolParseHelper, ParseFunctionInvalid) { 491 uint64_t address; 492 uint64_t size; 493 long stack_param_size; 494 char *name; 495 496 // Test missing function name. 497 char kTestLine[] = "FUNC 1 2 3 "; 498 ASSERT_FALSE(SymbolParseHelper::ParseFunction(kTestLine, &address, &size, 499 &stack_param_size, &name)); 500 // Test bad address. 501 char kTestLine1[] = "FUNC 1z 2 3 function name"; 502 ASSERT_FALSE(SymbolParseHelper::ParseFunction(kTestLine1, &address, &size, 503 &stack_param_size, &name)); 504 // Test large address. 505 char kTestLine2[] = "FUNC 123123123123123123123123123 2 3 function name"; 506 ASSERT_FALSE(SymbolParseHelper::ParseFunction(kTestLine2, &address, &size, 507 &stack_param_size, &name)); 508 // Test bad size. 509 char kTestLine3[] = "FUNC 1 z2 3 function name"; 510 ASSERT_FALSE(SymbolParseHelper::ParseFunction(kTestLine3, &address, &size, 511 &stack_param_size, &name)); 512 // Test large size. 513 char kTestLine4[] = "FUNC 1 231231231231231231231231232 3 function name"; 514 ASSERT_FALSE(SymbolParseHelper::ParseFunction(kTestLine4, &address, &size, 515 &stack_param_size, &name)); 516 // Test bad param size. 517 char kTestLine5[] = "FUNC 1 2 3z function name"; 518 ASSERT_FALSE(SymbolParseHelper::ParseFunction(kTestLine5, &address, &size, 519 &stack_param_size, &name)); 520 // Test large param size. 521 char kTestLine6[] = "FUNC 1 2 312312312312312312312312323 function name"; 522 ASSERT_FALSE(SymbolParseHelper::ParseFunction(kTestLine6, &address, &size, 523 &stack_param_size, &name)); 524 // Negative param size. 525 char kTestLine7[] = "FUNC 1 2 -5 function name"; 526 ASSERT_FALSE(SymbolParseHelper::ParseFunction(kTestLine7, &address, &size, 527 &stack_param_size, &name)); 528 } 529 530 // Test parsing of valid lines. The format is: 531 // <address> <size> <line number> <source file id> 532 TEST(SymbolParseHelper, ParseLineValid) { 533 uint64_t address; 534 uint64_t size; 535 long line_number; 536 long source_file; 537 538 char kTestLine[] = "1 2 3 4"; 539 ASSERT_TRUE(SymbolParseHelper::ParseLine(kTestLine, &address, &size, 540 &line_number, &source_file)); 541 EXPECT_EQ(1ULL, address); 542 EXPECT_EQ(2ULL, size); 543 EXPECT_EQ(3, line_number); 544 EXPECT_EQ(4, source_file); 545 546 // Test hex size and address. 547 char kTestLine1[] = "a1 a2 3 4 // some comment"; 548 ASSERT_TRUE(SymbolParseHelper::ParseLine(kTestLine1, &address, &size, 549 &line_number, &source_file)); 550 EXPECT_EQ(0xa1ULL, address); 551 EXPECT_EQ(0xa2ULL, size); 552 EXPECT_EQ(3, line_number); 553 EXPECT_EQ(4, source_file); 554 555 // 0 is a valid line number. 556 char kTestLine2[] = "a1 a2 0 4 // some comment"; 557 ASSERT_TRUE(SymbolParseHelper::ParseLine(kTestLine2, &address, &size, 558 &line_number, &source_file)); 559 EXPECT_EQ(0xa1ULL, address); 560 EXPECT_EQ(0xa2ULL, size); 561 EXPECT_EQ(0, line_number); 562 EXPECT_EQ(4, source_file); 563 } 564 565 // Test parsing of invalid lines. The format is: 566 // <address> <size> <line number> <source file id> 567 TEST(SymbolParseHelper, ParseLineInvalid) { 568 uint64_t address; 569 uint64_t size; 570 long line_number; 571 long source_file; 572 573 // Test missing source file id. 574 char kTestLine[] = "1 2 3"; 575 ASSERT_FALSE(SymbolParseHelper::ParseLine(kTestLine, &address, &size, 576 &line_number, &source_file)); 577 // Test bad address. 578 char kTestLine1[] = "1z 2 3 4"; 579 ASSERT_FALSE(SymbolParseHelper::ParseLine(kTestLine1, &address, &size, 580 &line_number, &source_file)); 581 // Test large address. 582 char kTestLine2[] = "123123123123123123123123 2 3 4"; 583 ASSERT_FALSE(SymbolParseHelper::ParseLine(kTestLine2, &address, &size, 584 &line_number, &source_file)); 585 // Test bad size. 586 char kTestLine3[] = "1 z2 3 4"; 587 ASSERT_FALSE(SymbolParseHelper::ParseLine(kTestLine3, &address, &size, 588 &line_number, &source_file)); 589 // Test large size. 590 char kTestLine4[] = "1 123123123123123123123123 3 4"; 591 ASSERT_FALSE(SymbolParseHelper::ParseLine(kTestLine4, &address, &size, 592 &line_number, &source_file)); 593 // Test bad line number. 594 char kTestLine5[] = "1 2 z3 4"; 595 ASSERT_FALSE(SymbolParseHelper::ParseLine(kTestLine5, &address, &size, 596 &line_number, &source_file)); 597 // Test negative line number. 598 char kTestLine6[] = "1 2 -1 4"; 599 ASSERT_FALSE(SymbolParseHelper::ParseLine(kTestLine6, &address, &size, 600 &line_number, &source_file)); 601 // Test large line number. 602 char kTestLine7[] = "1 2 123123123123123123123 4"; 603 ASSERT_FALSE(SymbolParseHelper::ParseLine(kTestLine7, &address, &size, 604 &line_number, &source_file)); 605 // Test bad source file id. 606 char kTestLine8[] = "1 2 3 f"; 607 ASSERT_FALSE(SymbolParseHelper::ParseLine(kTestLine8, &address, &size, 608 &line_number, &source_file)); 609 } 610 611 // Test parsing of valid PUBLIC lines. The format is: 612 // PUBLIC <address> <stack_param_size> <name> 613 TEST(SymbolParseHelper, ParsePublicSymbolValid) { 614 uint64_t address; 615 long stack_param_size; 616 char *name; 617 618 char kTestLine[] = "PUBLIC 1 2 3"; 619 ASSERT_TRUE(SymbolParseHelper::ParsePublicSymbol(kTestLine, &address, 620 &stack_param_size, &name)); 621 EXPECT_EQ(1ULL, address); 622 EXPECT_EQ(2, stack_param_size); 623 EXPECT_EQ("3", string(name)); 624 625 // Test hex size and address. 626 char kTestLine1[] = "PUBLIC a1 a2 function name"; 627 ASSERT_TRUE(SymbolParseHelper::ParsePublicSymbol(kTestLine1, &address, 628 &stack_param_size, &name)); 629 EXPECT_EQ(0xa1ULL, address); 630 EXPECT_EQ(0xa2, stack_param_size); 631 EXPECT_EQ("function name", string(name)); 632 633 // Test 0 is a valid address. 634 char kTestLine2[] = "PUBLIC 0 a2 function name"; 635 ASSERT_TRUE(SymbolParseHelper::ParsePublicSymbol(kTestLine2, &address, 636 &stack_param_size, &name)); 637 EXPECT_EQ(0ULL, address); 638 EXPECT_EQ(0xa2, stack_param_size); 639 EXPECT_EQ("function name", string(name)); 640 } 641 642 // Test parsing of invalid PUBLIC lines. The format is: 643 // PUBLIC <address> <stack_param_size> <name> 644 TEST(SymbolParseHelper, ParsePublicSymbolInvalid) { 645 uint64_t address; 646 long stack_param_size; 647 char *name; 648 649 // Test missing source function name. 650 char kTestLine[] = "PUBLIC 1 2 "; 651 ASSERT_FALSE(SymbolParseHelper::ParsePublicSymbol(kTestLine, &address, 652 &stack_param_size, &name)); 653 // Test bad address. 654 char kTestLine1[] = "PUBLIC 1z 2 3"; 655 ASSERT_FALSE(SymbolParseHelper::ParsePublicSymbol(kTestLine1, &address, 656 &stack_param_size, &name)); 657 // Test large address. 658 char kTestLine2[] = "PUBLIC 123123123123123123123123 2 3"; 659 ASSERT_FALSE(SymbolParseHelper::ParsePublicSymbol(kTestLine2, &address, 660 &stack_param_size, &name)); 661 // Test bad param stack size. 662 char kTestLine3[] = "PUBLIC 1 z2 3"; 663 ASSERT_FALSE(SymbolParseHelper::ParsePublicSymbol(kTestLine3, &address, 664 &stack_param_size, &name)); 665 // Test large param stack size. 666 char kTestLine4[] = "PUBLIC 1 123123123123123123123123123 3"; 667 ASSERT_FALSE(SymbolParseHelper::ParsePublicSymbol(kTestLine4, &address, 668 &stack_param_size, &name)); 669 // Test negative param stack size. 670 char kTestLine5[] = "PUBLIC 1 -5 3"; 671 ASSERT_FALSE(SymbolParseHelper::ParsePublicSymbol(kTestLine5, &address, 672 &stack_param_size, &name)); 673 } 674 675 } // namespace 676 677 int main(int argc, char *argv[]) { 678 ::testing::InitGoogleTest(&argc, argv); 679 return RUN_ALL_TESTS(); 680 } 681
