ExceptionCounterTest.cpp File Reference

#include <condition_variable>
#include <mutex>
#include <sstream>
#include <stdexcept>
#include <thread>
#include <folly/experimental/exception_tracer/ExceptionCounterLib.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Classes
class	MyException

Functions
void	bar ()
void	foo ()
void	baz ()
template<typename F >
void	throwAndCatch (F f)
	TEST (ExceptionCounter, oneThread)
	TEST (ExceptionCounter, testClearExceptionStatistics)
	TEST (ExceptionCounter, testDifferentStacks)
	TEST (ExceptionCounter, multyThreads)

Function Documentation

void bar

(

)

Definition at line 29 of file ExceptionCounterTest.cpp.

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

void baz

(

)

Definition at line 37 of file ExceptionCounterTest.cpp.

References foo().

Referenced by TEST().

                        {
  foo();
}

void foo

(

)

Definition at line 33 of file ExceptionCounterTest.cpp.

References MyException::MyException().

Referenced by baz().

                        {
  throw MyException();
}

TEST	(	ExceptionCounter	,
		oneThread
	)

Definition at line 53 of file ExceptionCounterTest.cpp.

References count, EXPECT_EQ, folly::exception_tracer::getExceptionStatistics(), i, deadlock::info(), and throwAndCatch().

                                  {
  throwAndCatch(foo);

  // Use volatile to prevent loop unrolling (it screws up stack frame grouping).
  for (volatile int i = 0; i < 10; ++i) {
    throwAndCatch(bar);
  }

  auto stats = getExceptionStatistics();
  EXPECT_EQ(stats.size(), 2);
  EXPECT_EQ(stats[0].count, 10);
  EXPECT_EQ(stats[1].count, 1);
  EXPECT_EQ(*(stats[0].info.type), typeid(std::runtime_error));
  EXPECT_EQ(*(stats[1].info.type), typeid(MyException));
}

TEST	(	ExceptionCounter	,
		testClearExceptionStatistics
	)

Definition at line 69 of file ExceptionCounterTest.cpp.

References EXPECT_EQ, folly::exception_tracer::getExceptionStatistics(), and throwAndCatch().

                                                     {
  throwAndCatch(foo);
  auto stats = getExceptionStatistics();
  EXPECT_EQ(stats.size(), 1);
  stats = getExceptionStatistics();
  EXPECT_EQ(stats.size(), 0);
}

TEST	(	ExceptionCounter	,
		testDifferentStacks
	)

Definition at line 77 of file ExceptionCounterTest.cpp.

References baz(), EXPECT_EQ, folly::exception_tracer::getExceptionStatistics(), and throwAndCatch().

                                            {
  throwAndCatch(foo);
  throwAndCatch(baz);
  auto stats = getExceptionStatistics();
  EXPECT_EQ(stats.size(), 2);
}

TEST	(	ExceptionCounter	,
		multyThreads
	)

Definition at line 84 of file ExceptionCounterTest.cpp.

References count, EXPECT_EQ, folly::exception_tracer::getExceptionStatistics(), i, kNumThreads, folly::detail::lock(), mutex, folly::pushmi::detail::t, threads, and throwAndCatch().

                                     {
  constexpr size_t kNumIterations = 10000;
  constexpr size_t kNumThreads = 10;
  std::vector<std::thread> threads;
  threads.resize(kNumThreads);

  std::mutex preparedMutex;
  std::mutex finishedMutex;
  std::condition_variable preparedBarrier;
  std::condition_variable finishedBarrier;
  int preparedThreads = 0;
  bool finished = false;

  for (auto& t : threads) {
    t = std::thread([&]() {
      for (size_t i = 0; i < kNumIterations; ++i) {
        throwAndCatch(foo);
      }

      {
        std::unique_lock<std::mutex> lock(preparedMutex);
        ++preparedThreads;
        preparedBarrier.notify_one();
      }

      std::unique_lock<std::mutex> lock(finishedMutex);
      finishedBarrier.wait(lock, [&]() { return finished; });
    });
  }

  {
    std::unique_lock<std::mutex> lock(preparedMutex);
    preparedBarrier.wait(
        lock, [&]() { return preparedThreads == kNumThreads; });
  }

  auto stats = getExceptionStatistics();
  EXPECT_EQ(stats.size(), 1);
  EXPECT_EQ(stats[0].count, kNumIterations * kNumThreads);

  {
    std::unique_lock<std::mutex> lock(finishedMutex);
    finished = true;
    finishedBarrier.notify_all();
  }

  for (auto& t : threads) {
    t.join();
  }
}

template<typename F >

void throwAndCatch

(

F

f

)

Definition at line 45 of file ExceptionCounterTest.cpp.

References f.

Referenced by TEST().

                        {
  try {
    f();
  } catch (...) {
    // ignore
  }
}