Use the GTest portability headers

[folly.git] / folly / experimental / test / AutoTimerTest.cpp

diff --git a/folly/experimental/test/AutoTimerTest.cpp b/folly/experimental/test/AutoTimerTest.cpp
index 9fb47a3d9b28979420da1bc7723a838eb034273a..f4c71c5189294fe2cd87397f18022a02125a0222 100644 (file)
--- a/folly/experimental/test/AutoTimerTest.cpp
+++ b/folly/experimental/test/AutoTimerTest.cpp
@@ -13,17 +13,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <gtest/gtest.h>
 
 #include <folly/experimental/AutoTimer.h>
 
+#include <folly/portability/GTest.h>
+
 using namespace folly;
 using namespace std;
 
 struct StubLogger {
-  void operator()(StringPiece msg, double sec) {
+  void operator()(StringPiece msg, std::chrono::duration<double> sec) {
     m = msg.str();
-    t = sec;
+    t = sec.count();
   }
   static std::string m;
   static double t;
@@ -44,15 +45,15 @@ struct StubClock {
 int StubClock::t = 0;
 
 TEST(TestAutoTimer, HandleBasicClosure) {
-  auto logger = [](StringPiece msg, double sec) {
+  auto logger = [](StringPiece msg, auto sec) {
     return StubLogger()(msg, 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>("", 0.0, std::move(logger));
+  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);
@@ -90,7 +91,9 @@ TEST(TestAutoTimer, HandleLogOnDestruct) {
 
 TEST(TestAutoTimer, HandleRealTimerClosure) {
   auto t = makeAutoTimer(
-      "Third message on destruction", 0.0, [](StringPiece msg, double sec) {
+      "Third message on destruction",
+      std::chrono::duration<double>::zero(),
+      [](StringPiece msg, auto sec) {
         GoogleLogger<GoogleLoggerStyle::PRETTY>()(msg, sec);
       });
   t.log("First message");
@@ -105,10 +108,34 @@ TEST(TestAutoTimer, HandleRealTimer) {
 
 TEST(TestAutoTimer, HandleMinLogTime) {
   StubClock::t = 1;
-  AutoTimer<StubLogger, StubClock> timer("", 3);
+  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(2.0, timer.log("foo"));
-  ASSERT_EQ(0, StubLogger::t);
+  ASSERT_EQ(std::chrono::duration<double>(2), timer.log("foo"));
+  ASSERT_EQ(std::chrono::duration<double>::zero().count(), StubLogger::t);
+}
+
+TEST(TestAutoTimer, MovedObjectDestructionDoesntLog) {
+  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");
 }