AutoTimerTest.cpp File Reference

#include <folly/experimental/AutoTimer.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Classes
struct	StubLogger
struct	StubClock

Functions
	TEST (TestAutoTimer, HandleBasicClosure)
	TEST (TestAutoTimer, HandleBasic)
	TEST (TestAutoTimer, HandleLogOnDestruct)
	TEST (TestAutoTimer, HandleRealTimerClosure)
	TEST (TestAutoTimer, HandleRealTimer)
	TEST (TestAutoTimer, HandleMinLogTime)
	TEST (TestAutoTimer, MovedObjectDestructionDoesntLog)

Function Documentation

TEST	(	TestAutoTimer	,
		HandleBasicClosure
	)

Definition at line 47 of file AutoTimerTest.cpp.

References ASSERT_EQ, StubLogger::m, folly::gen::move, StubLogger::t, and StubClock::t.

                                        {
  auto logger = [](StringPiece mesg, auto sec) {
    return StubLogger()(mesg, sec);
  };
  StubClock::t = 1;
  // Here decltype is needed. But since most users are expected to use this
  // method with the default clock, template specification won't be needed even
  // when they use a closure. See test case HandleRealTimerClosure
  auto timer = makeAutoTimer<decltype(logger), StubClock>(
      "", std::chrono::duration<double>::zero(), std::move(logger));
  StubClock::t = 3;
  timer.log("foo");
  ASSERT_EQ("foo", StubLogger::m);
  ASSERT_EQ(2, StubLogger::t);
  timer.logFormat("bar {}", 5e-2);
  ASSERT_EQ("bar 0.05", StubLogger::m);
  ASSERT_EQ(0, StubLogger::t);
}

TEST	(	TestAutoTimer	,
		HandleBasic
	)

Definition at line 66 of file AutoTimerTest.cpp.

References ASSERT_EQ, folly::AutoTimer< Logger, Clock >::log(), folly::AutoTimer< Logger, Clock >::logFormat(), StubLogger::m, StubLogger::t, and StubClock::t.

                                 {
  StubClock::t = 1;
  AutoTimer<StubLogger, StubClock> timer;
  StubClock::t = 3;
  timer.log("foo");
  ASSERT_EQ("foo", StubLogger::m);
  ASSERT_EQ(2, StubLogger::t);
  timer.logFormat("bar {}", 5e-2);
  ASSERT_EQ("bar 0.05", StubLogger::m);
  ASSERT_EQ(0, StubLogger::t);
}

TEST	(	TestAutoTimer	,
		HandleLogOnDestruct
	)

Definition at line 78 of file AutoTimerTest.cpp.

References ASSERT_EQ, EXPECT_EQ, folly::AutoTimer< Logger, Clock >::log(), StubLogger::m, StubLogger::t, and StubClock::t.

                                         {
  {
    StubClock::t = 0;
    AutoTimer<StubLogger, StubClock> timer("message");
    StubClock::t = 3;
    timer.log("foo");
    EXPECT_EQ("foo", StubLogger::m);
    EXPECT_EQ(3, StubLogger::t);
    StubClock::t = 5;
  }
  ASSERT_EQ("message", StubLogger::m);
  ASSERT_EQ(2, StubLogger::t);
}

TEST	(	TestAutoTimer	,
		HandleRealTimerClosure
	)

Definition at line 92 of file AutoTimerTest.cpp.

References folly::makeAutoTimer(), and folly::pushmi::detail::t.

                                            {
  auto t = makeAutoTimer(
      "Third message on destruction",
      std::chrono::duration<double>::zero(),
      [](StringPiece mesg, auto sec) {
        GoogleLogger<GoogleLoggerStyle::PRETTY>()(mesg, sec);
      });
  t.log("First message");
  t.log("Second message");
}

TEST	(	TestAutoTimer	,
		HandleRealTimer
	)

Definition at line 103 of file AutoTimerTest.cpp.

References folly::AutoTimer< Logger, Clock >::log(), and folly::pushmi::detail::t.

                                     {
  AutoTimer<> t("Third message on destruction");
  t.log("First message");
  t.log("Second message");
}

TEST	(	TestAutoTimer	,
		HandleMinLogTime
	)

Definition at line 109 of file AutoTimerTest.cpp.

References ASSERT_EQ, count, folly::AutoTimer< Logger, Clock >::log(), StubLogger::t, and StubClock::t.

                                      {
  StubClock::t = 1;
  AutoTimer<StubLogger, StubClock> timer("", std::chrono::duration<double>(3));
  StubClock::t = 3;
  // only 2 "seconds" have passed, so this shouldn't log
  StubLogger::t = 0;
  ASSERT_EQ(std::chrono::duration<double>(2), timer.log("foo"));
  ASSERT_EQ(std::chrono::duration<double>::zero().count(), StubLogger::t);
}

TEST	(	TestAutoTimer	,
		MovedObjectDestructionDoesntLog
	)

Definition at line 119 of file AutoTimerTest.cpp.

References current, EXPECT_EQ, int32_t, folly::makeAutoTimer(), folly::gen::move, and SCOPE_EXIT.

                                                     {
  const std::vector<std::string> expectedMsgs = {
      "BEFORE_MOVE", "AFTER_MOVE", "END"};
  int32_t current = 0;
  SCOPE_EXIT {
    EXPECT_EQ(3, current);
  };

  auto timer = [&expectedMsgs, &current] {
    auto oldTimer = folly::makeAutoTimer(
        "END",
        std::chrono::duration<double>::zero(),
        [&expectedMsgs, &current](
            StringPiece msg, const std::chrono::duration<double>&) {
          EXPECT_EQ(expectedMsgs.at(current), msg);
          current++;
        });
    oldTimer.log("BEFORE_MOVE");
    auto newTimer = std::move(oldTimer); // force the move-ctor
    return newTimer;
  }();
  timer.log("AFTER_MOVE");
}