src/ceph/src/test/common/test_time.cc

   1
   2 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   3 // vim: ts=8 sw=2 smarttab
   4 /*
   5  * Ceph - scalable distributed file system
   6  *
   7  * Copyright (C) 2004-2006 Sage Weil <sage@newdream.net>
   8  *
   9  * This is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License version 2.1, as published by the Free Software
  12  * Foundation.  See file COPYING.
  13  *
  14  */
  15
  16 #include <ctime>
  17
  18 #include "common/ceph_time.h"
  19 #include "include/rados.h"
  20 #include "gtest/gtest.h"
  21
  22
  23 using ceph::real_clock;
  24 using ceph::real_time;
  25
  26 using ceph::real_clock;
  27 using ceph::real_time;
  28
  29 using ceph::coarse_real_clock;
  30 using ceph::coarse_mono_clock;
  31
  32 using ceph::timespan;
  33 using ceph::signedspan;
  34
  35 using std::chrono::seconds;
  36 using std::chrono::microseconds;
  37 using std::chrono::nanoseconds;
  38
  39 static_assert(!real_clock::is_steady, "ceph::real_clock must not be steady.");
  40 static_assert(!coarse_real_clock::is_steady,
  41               "ceph::coarse_real_clock must not be steady.");
  42
  43 static_assert(mono_clock::is_steady, "ceph::mono_clock must be steady.");
  44 static_assert(coarse_mono_clock::is_steady,
  45               "ceph::coarse_mono_clock must be steady.");
  46
  47 // Before this file was written.
  48 static constexpr uint32_t bs = 1440701569;
  49 static constexpr uint32_t bns = 123456789;
  50 static constexpr uint32_t bus = 123456;
  51 static constexpr time_t btt = bs;
  52 static constexpr struct timespec bts = { bs, bns };
  53 static constexpr struct ceph_timespec bcts = { bs, bns };
  54 static constexpr struct timeval btv = { bs, bus };
  55 static constexpr double bd = bs + ((double)bns / 1000000000.);
  56
  57 template<typename Clock>
  58 static void system_clock_sanity() {
  59   static const typename Clock::time_point brt(seconds(bs) + nanoseconds(bns));
  60   const typename Clock::time_point now(Clock::now());
  61
  62   ASSERT_GT(now, brt);
  63
  64   ASSERT_GT(Clock::to_time_t(now), btt);
  65
  66   ASSERT_GT(Clock::to_timespec(now).tv_sec, bts.tv_sec);
  67   ASSERT_LT(Clock::to_timespec(now).tv_nsec, 1000000000L);
  68
  69   ASSERT_GT(Clock::to_ceph_timespec(now).tv_sec, bcts.tv_sec);
  70   ASSERT_LT(Clock::to_ceph_timespec(now).tv_nsec, 1000000000UL);
  71
  72   ASSERT_GT(Clock::to_timeval(now).tv_sec, btv.tv_sec);
  73   ASSERT_LT(Clock::to_timeval(now).tv_usec, 1000000L);
  74 }
  75
  76 template<typename Clock>
  77 static void system_clock_conversions() {
  78   static typename Clock::time_point brt(seconds(bs) +
  79                                                   nanoseconds(bns));
  80
  81   ASSERT_EQ(Clock::to_time_t(brt), btt);
  82   ASSERT_EQ(Clock::from_time_t(btt) + nanoseconds(bns), brt);
  83
  84   {
  85     const struct timespec tts = Clock::to_timespec(brt);
  86     ASSERT_EQ(tts.tv_sec, bts.tv_sec);
  87     ASSERT_EQ(tts.tv_nsec, bts.tv_nsec);
  88   }
  89   ASSERT_EQ(Clock::from_timespec(bts), brt);
  90   {
  91     struct timespec tts;
  92     Clock::to_timespec(brt, tts);
  93     ASSERT_EQ(tts.tv_sec, bts.tv_sec);
  94     ASSERT_EQ(tts.tv_nsec, bts.tv_nsec);
  95   }
  96
  97   {
  98     const struct ceph_timespec tcts = Clock::to_ceph_timespec(brt);
  99     ASSERT_EQ(tcts.tv_sec, bcts.tv_sec);
 100     ASSERT_EQ(tcts.tv_nsec, bcts.tv_nsec);
 101   }
 102   ASSERT_EQ(Clock::from_ceph_timespec(bcts), brt);
 103   {
 104     struct ceph_timespec tcts;
 105     Clock::to_ceph_timespec(brt, tcts);
 106     ASSERT_EQ(tcts.tv_sec, bcts.tv_sec);
 107     ASSERT_EQ(tcts.tv_nsec, bcts.tv_nsec);
 108   }
 109
 110   {
 111     const struct timeval ttv = Clock::to_timeval(brt);
 112     ASSERT_EQ(ttv.tv_sec, btv.tv_sec);
 113     ASSERT_EQ(ttv.tv_usec, btv.tv_usec);
 114   }
 115   ASSERT_EQ(Clock::from_timeval(btv), brt - nanoseconds(bns - bus * 1000));
 116   {
 117     struct timeval ttv;
 118     Clock::to_timeval(brt, ttv);
 119     ASSERT_EQ(ttv.tv_sec, btv.tv_sec);
 120     ASSERT_EQ(ttv.tv_usec, btv.tv_usec);
 121   }
 122
 123   ASSERT_EQ(Clock::to_double(brt), bd);
 124   // Fudge factor
 125   ASSERT_LT(std::abs((Clock::from_double(bd) - brt).count()), 30);
 126 }
 127
 128 TEST(RealClock, Sanity) {
 129   system_clock_sanity<real_clock>();
 130 }
 131
 132
 133 TEST(RealClock, Conversions) {
 134   system_clock_conversions<real_clock>();
 135 }
 136
 137 TEST(CoarseRealClock, Sanity) {
 138   system_clock_sanity<coarse_real_clock>();
 139 }
 140
 141
 142 TEST(CoarseRealClock, Conversions) {
 143   system_clock_conversions<coarse_real_clock>();
 144 }
 145
 146 TEST(TimePoints, SignedSubtraciton) {
 147   ceph::real_time rta(std::chrono::seconds(3));
 148   ceph::real_time rtb(std::chrono::seconds(5));
 149
 150   ceph::coarse_real_time crta(std::chrono::seconds(3));
 151   ceph::coarse_real_time crtb(std::chrono::seconds(5));
 152
 153   ceph::mono_time mta(std::chrono::seconds(3));
 154   ceph::mono_time mtb(std::chrono::seconds(5));
 155
 156   ceph::coarse_mono_time cmta(std::chrono::seconds(3));
 157   ceph::coarse_mono_time cmtb(std::chrono::seconds(5));
 158
 159   ASSERT_LT(rta - rtb, ceph::signedspan::zero());
 160   ASSERT_LT((rta - rtb).count(), 0);
 161   ASSERT_GT(rtb - rta, ceph::signedspan::zero());
 162   ASSERT_GT((rtb - rta).count(), 0);
 163
 164   ASSERT_LT(crta - crtb, ceph::signedspan::zero());
 165   ASSERT_LT((crta - crtb).count(), 0);
 166   ASSERT_GT(crtb - crta, ceph::signedspan::zero());
 167   ASSERT_GT((crtb - crta).count(), 0);
 168
 169   ASSERT_LT(mta - mtb, ceph::signedspan::zero());
 170   ASSERT_LT((mta - mtb).count(), 0);
 171   ASSERT_GT(mtb - mta, ceph::signedspan::zero());
 172   ASSERT_GT((mtb - mta).count(), 0);
 173
 174   ASSERT_LT(cmta - cmtb, ceph::signedspan::zero());
 175   ASSERT_LT((cmta - cmtb).count(), 0);
 176   ASSERT_GT(cmtb - cmta, ceph::signedspan::zero());
 177   ASSERT_GT((cmtb - cmta).count(), 0);
 178 }