folly::symbolizer::test Namespace Reference

Classes
class	ElfCacheTest

Functions
void	writeAll (int fd, const char *str)
void	expect (LineReader &lr, const char *expected)
	TEST (LineReader, Simple)
	TEST (SignalHandler, Simple)
void	failHard ()
void	foo ()
	TEST (Symbolizer, Single)
int	comparator (const void *ap, const void *bp)
FOLLY_NOINLINE void	bar ()
void	bar (FrameArray< 100 > &frames)
void	runElfCacheTest (Symbolizer &symbolizer)
	TEST_F (ElfCacheTest, TinyElfCache)
	TEST_F (ElfCacheTest, SignalSafeElfCache)
	TEST (SymbolizerTest, SymbolCache)

Variables
FrameArray< 100 > *	framesToFill {nullptr}
FrameArray< 100 >	goldenFrames

Function Documentation

FOLLY_NOINLINE void folly::symbolizer::test::bar

(

)

Definition at line 29 of file ExceptionCounterTest.cpp.

Referenced by baz(), comparator(), foo(), folly::symbolizer::test::ElfCacheTest::SetUp(), TEST(), and testExceptionPtr1().

                        {
  throw std::runtime_error("hello");
}

void folly::symbolizer::test::bar

(

FrameArray< 100 > &

frames

)

Definition at line 69 of file SymbolizerTest.cpp.

References a, comparator(), and framesToFill.

                                  {
  framesToFill = &frames;
  int a[2] = {1, 2};
  // Use qsort, which is in a different library
  qsort(a, 2, sizeof(int), comparator);
  framesToFill = nullptr;
}

int folly::symbolizer::test::comparator	(	const void *	ap,
		const void *	bp
	)

Definition at line 58 of file SymbolizerTest.cpp.

References a, b, bar(), FOLLY_NOINLINE, framesToFill, and folly::symbolizer::getStackTrace().

Referenced by bar(), testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), and testing::WhenSortedBy().

                                               {
  getStackTrace(*framesToFill);

  int a = *static_cast<const int*>(ap);
  int b = *static_cast<const int*>(bp);
  return a < b ? -1 : a > b ? 1 : 0;
}

void folly::symbolizer::test::expect	(	LineReader &	lr,
		const char *	expected
	)

Definition at line 36 of file LineReaderTest.cpp.

References EXPECT_EQ, folly::symbolizer::LineReader::kEof, folly::symbolizer::LineReader::kReading, folly::symbolizer::LineReader::readLine(), folly::Range< Iter >::size(), folly::Range< Iter >::str(), and string.

Referenced by folly::AtomicHashArray< KeyT, ValueT, HashFcn, EqualFcn, Allocator, ProbeFcn, KeyConvertFcn >::erase(), TEST(), TEST(), folly::io::test::TEST_P(), folly::RWSpinLock::try_lock(), folly::RWSpinLock::try_unlock_upgrade_and_lock(), folly::AtomicHashArray< KeyT, ValueT, HashFcn, EqualFcn, Allocator, ProbeFcn, KeyConvertFcn >::tryLockCell(), UpdateSyncState::waitForUpdate(), and PollerWithState::waitForUpdate().

                                                  {
  StringPiece line;
  size_t expectedLen = strlen(expected);
  EXPECT_EQ(
      expectedLen != 0 ? LineReader::kReading : LineReader::kEof,
      lr.readLine(line));
  EXPECT_EQ(expectedLen, line.size());
  EXPECT_EQ(std::string(expected, expectedLen), line.str());
}

void folly::symbolizer::test::failHard ( )

inline

Definition at line 23 of file SignalHandlerTest.h.

Referenced by TEST().

                       {
  *(/* nolint */ volatile char*)42; // SIGSEGV
}

void folly::symbolizer::test::foo

(

)

Definition at line 29 of file SymbolizerTest.cpp.

{}

void folly::symbolizer::test::runElfCacheTest

(

Symbolizer &

symbolizer

)

Definition at line 93 of file SymbolizerTest.cpp.

References ASSERT_LE, EXPECT_STREQ, folly::symbolizer::FrameArray< N >::frameCount, folly::symbolizer::FrameArray< N >::frames, goldenFrames, i, and folly::symbolizer::Symbolizer::symbolize().

Referenced by TEST_F().

                                             {
  FrameArray<100> frames = goldenFrames;
  for (size_t i = 0; i < frames.frameCount; ++i) {
    frames.frames[i].clear();
  }
  symbolizer.symbolize(frames);
  ASSERT_LE(4, frames.frameCount);
  for (size_t i = 1; i < 4; ++i) {
    EXPECT_STREQ(goldenFrames.frames[i].name, frames.frames[i].name);
  }
}

folly::symbolizer::test::TEST	(	Symbolizer	,
		Single
	)

Definition at line 31 of file SymbolizerTest.cpp.

References a, folly::Range< Iter >::advance(), ASSERT_TRUE, folly::symbolizer::SymbolizedFrame::demangledName(), EXPECT_EQ, folly::symbolizer::Dwarf::LocationInfo::file, folly::symbolizer::SymbolizedFrame::location, folly::Range< const char * >::npos, folly::Range< Iter >::rfind(), folly::Range< Iter >::str(), folly::symbolizer::Symbolizer::symbolize(), and folly::symbolizer::Dwarf::Path::toString().

                         {
  Symbolizer symbolizer;
  SymbolizedFrame a;
  ASSERT_TRUE(symbolizer.symbolize(reinterpret_cast<uintptr_t>(foo), a));
  EXPECT_EQ("folly::symbolizer::test::foo()", a.demangledName());

  // The version of clang we use doesn't generate a `.debug_aranges` section,
  // which the symbolizer needs to lookup the filename.
  constexpr bool built_with_clang =
#ifdef __clang__
      true;
#else
      false;
#endif
  if (!built_with_clang) {
    auto path = a.location.file.toString();
    folly::StringPiece basename(path);
    auto pos = basename.rfind('/');
    if (pos != folly::StringPiece::npos) {
      basename.advance(pos + 1);
    }
    EXPECT_EQ("SymbolizerTest.cpp", basename.str());
  }
}

folly::symbolizer::test::TEST	(	SignalHandler	,
		Simple
	)

Definition at line 45 of file SignalHandlerTest.cpp.

References folly::symbolizer::addFatalSignalCallback(), failHard(), folly::symbolizer::installFatalSignalCallbacks(), and folly::symbolizer::installFatalSignalHandler().

                            {
  addFatalSignalCallback(callback1);
  addFatalSignalCallback(callback2);
  installFatalSignalHandler();
  installFatalSignalCallbacks();

  EXPECT_DEATH(
      failHard(),
      "^\\*\\*\\* Aborted at [0-9]+ \\(Unix time, try 'date -d @[0-9]+'\\) "
      "\\*\\*\\*\n"
      "\\*\\*\\* Signal 11 \\(SIGSEGV\\) \\(0x2a\\) received by PID [0-9]+ "
      "\\(pthread TID 0x[0-9a-f]+\\) \\(linux TID [0-9]+\\) "
      "\\(maybe from PID [0-9]+, UID [0-9]+\\) "
      "\\(code: address not mapped to object\\), "
      "stack trace: \\*\\*\\*\n"
      ".*\n"
      ".*    @ [0-9a-f]+.* folly::symbolizer::test::SignalHandler_Simple_Test"
      "::TestBody\\(\\).*\n"
      ".*\n"
      ".*    @ [0-9a-f]+.* main.*\n"
      ".*\n"
      "Callback1\n"
      "Callback2\n"
      ".*");
}

folly::symbolizer::test::TEST	(	LineReader	,
		Simple
	)

Definition at line 46 of file LineReaderTest.cpp.

References expect(), folly::test::TemporaryFile::fd(), and writeAll().

                         {
  TemporaryFile file;
  int fd = file.fd();
  writeAll(
      fd,
      "Meow\n"
      "Hello world\n"
      "This is a long line. It is longer than the other lines.\n"
      "\n"
      "Incomplete last line");

  {
    CHECK_ERR(lseek(fd, 0, SEEK_SET));
    char buf[10];
    LineReader lr(fd, buf, sizeof(buf));
    expect(lr, "Meow\n");
    expect(lr, "Hello worl");
    expect(lr, "d\n");
    expect(lr, "This is a ");
    expect(lr, "long line.");
    expect(lr, " It is lon");
    expect(lr, "ger than t");
    expect(lr, "he other l");
    expect(lr, "ines.\n");
    expect(lr, "\n");
    expect(lr, "Incomplete");
    expect(lr, " last line");
    expect(lr, "");
  }

  {
    CHECK_ERR(lseek(fd, 0, SEEK_SET));
    char buf[80];
    LineReader lr(fd, buf, sizeof(buf));
    expect(lr, "Meow\n");
    expect(lr, "Hello world\n");
    expect(lr, "This is a long line. It is longer than the other lines.\n");
    expect(lr, "\n");
    expect(lr, "Incomplete last line");
    expect(lr, "");
  }
}

folly::symbolizer::test::TEST	(	SymbolizerTest	,
		SymbolCache
	)

Definition at line 122 of file SymbolizerTest.cpp.

References bar(), EXPECT_STREQ, folly::symbolizer::FrameArray< N >::frameCount, folly::symbolizer::FrameArray< N >::frames, folly::symbolizer::Dwarf::FULL, i, and folly::symbolizer::Symbolizer::symbolize().

                                  {
  Symbolizer symbolizer(nullptr, Dwarf::LocationInfoMode::FULL, 100);

  FrameArray<100> frames;
  bar(frames);
  symbolizer.symbolize(frames);

  FrameArray<100> frames2;
  bar(frames2);
  symbolizer.symbolize(frames2);
  for (size_t i = 0; i < frames.frameCount; i++) {
    EXPECT_STREQ(frames.frames[i].name, frames2.frames[i].name);
  }
}

folly::symbolizer::test::TEST_F	(	ElfCacheTest	,
		TinyElfCache
	)

Definition at line 105 of file SymbolizerTest.cpp.

References i, and runElfCacheTest().

                                   {
  ElfCache cache(1);
  Symbolizer symbolizer(&cache);
  // Run twice, in case the wrong stuff gets evicted?
  for (size_t i = 0; i < 2; ++i) {
    runElfCacheTest(symbolizer);
  }
}

folly::symbolizer::test::TEST_F	(	ElfCacheTest	,
		SignalSafeElfCache
	)

Definition at line 114 of file SymbolizerTest.cpp.

References i, and runElfCacheTest().

                                         {
  SignalSafeElfCache cache(100);
  Symbolizer symbolizer(&cache);
  for (size_t i = 0; i < 2; ++i) {
    runElfCacheTest(symbolizer);
  }
}

void folly::symbolizer::test::writeAll	(	int	fd,
		const char *	str
	)

Definition at line 31 of file LineReaderTest.cpp.

References folly::writeFull().

Referenced by TEST().

                                       {
  ssize_t n = strlen(str);
  CHECK_EQ(n, writeFull(fd, str, n));
}

Variable Documentation

FrameArray<100>* folly::symbolizer::test::framesToFill {nullptr}

Definition at line 56 of file SymbolizerTest.cpp.

Referenced by bar(), and comparator().

FrameArray<100> folly::symbolizer::test::goldenFrames

Definition at line 83 of file SymbolizerTest.cpp.

Referenced by runElfCacheTest().