]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
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 | } |