1 //
2 //
3 // Copyright 2015 gRPC authors.
4 //
5 // Licensed under the Apache License, Version 2.0 (the "License");
6 // you may not use this file except in compliance with the License.
7 // You may obtain a copy of the License at
8 //
9 // http://www.apache.org/licenses/LICENSE-2.0
10 //
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an "AS IS" BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
16 //
17 //
18
19 // Test of gpr time support.
20
21 #include <grpc/support/time.h>
22 #include <inttypes.h>
23 #include <stdio.h>
24 #include <string.h>
25
26 #include <memory>
27
28 #include "gtest/gtest.h"
29 #include "test/core/test_util/test_config.h"
30
to_fp(void * arg,const char * buf,size_t len)31 static void to_fp(void* arg, const char* buf, size_t len) {
32 fwrite(buf, 1, len, static_cast<FILE*>(arg));
33 }
34
35 // Convert gpr_intmax x to ascii base b (2..16), and write with
36 // (*writer)(arg, ...), zero padding to "chars" digits).
i_to_s(intmax_t x,int base,int chars,void (* writer)(void * arg,const char * buf,size_t len),void * arg)37 static void i_to_s(intmax_t x, int base, int chars,
38 void (*writer)(void* arg, const char* buf, size_t len),
39 void* arg) {
40 char buf[64];
41 char fmt[32];
42 ASSERT_TRUE(base == 16 || base == 10);
43 sprintf(fmt, "%%0%d%s", chars, base == 16 ? PRIxMAX : PRIdMAX);
44 sprintf(buf, fmt, x);
45 (*writer)(arg, buf, strlen(buf));
46 }
47
48 // Convert ts to ascii, and write with (*writer)(arg, ...).
ts_to_s(gpr_timespec t,void (* writer)(void * arg,const char * buf,size_t len),void * arg)49 static void ts_to_s(gpr_timespec t,
50 void (*writer)(void* arg, const char* buf, size_t len),
51 void* arg) {
52 if (t.tv_sec < 0 && t.tv_nsec != 0) {
53 t.tv_sec++;
54 t.tv_nsec = GPR_NS_PER_SEC - t.tv_nsec;
55 }
56 i_to_s(t.tv_sec, 10, 0, writer, arg);
57 (*writer)(arg, ".", 1);
58 i_to_s(t.tv_nsec, 10, 9, writer, arg);
59 }
60
TEST(TimeTest,Values)61 TEST(TimeTest, Values) {
62 int i;
63
64 gpr_timespec x = gpr_time_0(GPR_CLOCK_REALTIME);
65 ASSERT_TRUE(x.tv_sec == 0 && x.tv_nsec == 0);
66
67 x = gpr_inf_future(GPR_CLOCK_REALTIME);
68 fprintf(stderr, "far future ");
69 fflush(stderr);
70 i_to_s(x.tv_sec, 16, 16, &to_fp, stderr);
71 fprintf(stderr, "\n");
72 ASSERT_EQ(x.tv_sec, INT64_MAX);
73 fprintf(stderr, "far future ");
74 fflush(stderr);
75 ts_to_s(x, &to_fp, stderr);
76 fprintf(stderr, "\n");
77 fflush(stderr);
78
79 x = gpr_inf_past(GPR_CLOCK_REALTIME);
80 fprintf(stderr, "far past ");
81 fflush(stderr);
82 i_to_s(x.tv_sec, 16, 16, &to_fp, stderr);
83 fprintf(stderr, "\n");
84 fflush(stderr);
85 ASSERT_EQ(x.tv_sec, INT64_MIN);
86 fprintf(stderr, "far past ");
87 fflush(stderr);
88 ts_to_s(x, &to_fp, stderr);
89 fprintf(stderr, "\n");
90 fflush(stderr);
91
92 for (i = 1; i != 1000 * 1000 * 1000; i *= 10) {
93 x = gpr_time_from_micros(i, GPR_TIMESPAN);
94 ASSERT_TRUE(x.tv_sec == i / GPR_US_PER_SEC &&
95 x.tv_nsec == (i % GPR_US_PER_SEC) * GPR_NS_PER_US);
96 x = gpr_time_from_nanos(i, GPR_TIMESPAN);
97 ASSERT_TRUE(x.tv_sec == i / GPR_NS_PER_SEC &&
98 x.tv_nsec == (i % GPR_NS_PER_SEC));
99 x = gpr_time_from_millis(i, GPR_TIMESPAN);
100 ASSERT_TRUE(x.tv_sec == i / GPR_MS_PER_SEC &&
101 x.tv_nsec == (i % GPR_MS_PER_SEC) * GPR_NS_PER_MS);
102 }
103
104 // Test possible overflow in conversion of -ve values.
105 x = gpr_time_from_micros(-(INT64_MAX - 999997), GPR_TIMESPAN);
106 ASSERT_LT(x.tv_sec, 0);
107 ASSERT_TRUE(x.tv_nsec >= 0 && x.tv_nsec < GPR_NS_PER_SEC);
108 EXPECT_EQ((x.tv_sec * GPR_US_PER_SEC +
109 x.tv_nsec / (GPR_NS_PER_SEC / GPR_US_PER_SEC)),
110 -(INT64_MAX - 999997));
111
112 x = gpr_time_from_nanos(-(INT64_MAX - 999999997), GPR_TIMESPAN);
113 ASSERT_LT(x.tv_sec, 0);
114 ASSERT_TRUE(x.tv_nsec >= 0 && x.tv_nsec < GPR_NS_PER_SEC);
115 EXPECT_EQ((x.tv_sec * GPR_NS_PER_SEC + x.tv_nsec), -(INT64_MAX - 999999997));
116
117 x = gpr_time_from_millis(-(INT64_MAX - 997), GPR_TIMESPAN);
118 ASSERT_LT(x.tv_sec, 0);
119 ASSERT_TRUE(x.tv_nsec >= 0 && x.tv_nsec < GPR_NS_PER_SEC);
120 EXPECT_EQ((x.tv_sec * GPR_MS_PER_SEC +
121 x.tv_nsec / (GPR_NS_PER_SEC / GPR_MS_PER_SEC)),
122 -(INT64_MAX - 997));
123
124 // Test general -ve values.
125 for (i = -1; i > -1000 * 1000 * 1000; i *= 7) {
126 x = gpr_time_from_micros(i, GPR_TIMESPAN);
127 ASSERT_EQ(x.tv_sec * GPR_US_PER_SEC + x.tv_nsec / GPR_NS_PER_US, i);
128 x = gpr_time_from_nanos(i, GPR_TIMESPAN);
129 ASSERT_EQ(x.tv_sec * GPR_NS_PER_SEC + x.tv_nsec, i);
130 x = gpr_time_from_millis(i, GPR_TIMESPAN);
131 ASSERT_EQ(x.tv_sec * GPR_MS_PER_SEC + x.tv_nsec / GPR_NS_PER_MS, i);
132 }
133 }
134
TEST(TimeTest,AddSub)135 TEST(TimeTest, AddSub) {
136 int i;
137 int j;
138 int k;
139 // Basic addition and subtraction.
140 for (i = -100; i <= 100; i++) {
141 for (j = -100; j <= 100; j++) {
142 for (k = 1; k <= 10000000; k *= 10) {
143 int sum = i + j;
144 int diff = i - j;
145 gpr_timespec it = gpr_time_from_micros(i * k, GPR_TIMESPAN);
146 gpr_timespec jt = gpr_time_from_micros(j * k, GPR_TIMESPAN);
147 gpr_timespec sumt = gpr_time_add(it, jt);
148 gpr_timespec difft = gpr_time_sub(it, jt);
149 if (gpr_time_cmp(gpr_time_from_micros(sum * k, GPR_TIMESPAN), sumt) !=
150 0) {
151 fprintf(stderr, "i %d j %d sum %d sumt ", i, j, sum);
152 fflush(stderr);
153 ts_to_s(sumt, &to_fp, stderr);
154 fprintf(stderr, "\n");
155 fflush(stderr);
156 ASSERT_TRUE(0);
157 }
158 if (gpr_time_cmp(gpr_time_from_micros(diff * k, GPR_TIMESPAN), difft) !=
159 0) {
160 fprintf(stderr, "i %d j %d diff %d diff ", i, j, diff);
161 fflush(stderr);
162 ts_to_s(sumt, &to_fp, stderr);
163 fprintf(stderr, "\n");
164 fflush(stderr);
165 ASSERT_TRUE(0);
166 }
167 }
168 }
169 }
170 }
171
TEST(TimeTest,Overflow)172 TEST(TimeTest, Overflow) {
173 // overflow
174 gpr_timespec x = gpr_time_from_micros(1, GPR_TIMESPAN);
175 do {
176 x = gpr_time_add(x, x);
177 } while (gpr_time_cmp(x, gpr_inf_future(GPR_TIMESPAN)) < 0);
178 ASSERT_EQ(gpr_time_cmp(x, gpr_inf_future(GPR_TIMESPAN)), 0);
179 x = gpr_time_from_micros(-1, GPR_TIMESPAN);
180 do {
181 x = gpr_time_add(x, x);
182 } while (gpr_time_cmp(x, gpr_inf_past(GPR_TIMESPAN)) > 0);
183 ASSERT_EQ(gpr_time_cmp(x, gpr_inf_past(GPR_TIMESPAN)), 0);
184 }
185
TEST(TimeTest,StickyInfinities)186 TEST(TimeTest, StickyInfinities) {
187 int i;
188 int j;
189 int k;
190 gpr_timespec infinity[2];
191 gpr_timespec addend[3];
192 infinity[0] = gpr_inf_future(GPR_TIMESPAN);
193 infinity[1] = gpr_inf_past(GPR_TIMESPAN);
194 addend[0] = gpr_inf_future(GPR_TIMESPAN);
195 addend[1] = gpr_inf_past(GPR_TIMESPAN);
196 addend[2] = gpr_time_0(GPR_TIMESPAN);
197
198 // Infinities are sticky
199 for (i = 0; i != sizeof(infinity) / sizeof(infinity[0]); i++) {
200 for (j = 0; j != sizeof(addend) / sizeof(addend[0]); j++) {
201 gpr_timespec x = gpr_time_add(infinity[i], addend[j]);
202 ASSERT_EQ(gpr_time_cmp(x, infinity[i]), 0);
203 x = gpr_time_sub(infinity[i], addend[j]);
204 ASSERT_EQ(gpr_time_cmp(x, infinity[i]), 0);
205 }
206 for (k = -200; k <= 200; k++) {
207 gpr_timespec y = gpr_time_from_micros(k * 100000, GPR_TIMESPAN);
208 gpr_timespec x = gpr_time_add(infinity[i], y);
209 ASSERT_EQ(gpr_time_cmp(x, infinity[i]), 0);
210 x = gpr_time_sub(infinity[i], y);
211 ASSERT_EQ(gpr_time_cmp(x, infinity[i]), 0);
212 }
213 }
214 }
215
TEST(TimeTest,Similar)216 TEST(TimeTest, Similar) {
217 ASSERT_EQ(1, gpr_time_similar(gpr_inf_future(GPR_TIMESPAN),
218 gpr_inf_future(GPR_TIMESPAN),
219 gpr_time_0(GPR_TIMESPAN)));
220 ASSERT_EQ(1, gpr_time_similar(gpr_inf_past(GPR_TIMESPAN),
221 gpr_inf_past(GPR_TIMESPAN),
222 gpr_time_0(GPR_TIMESPAN)));
223 ASSERT_EQ(0, gpr_time_similar(gpr_inf_past(GPR_TIMESPAN),
224 gpr_inf_future(GPR_TIMESPAN),
225 gpr_time_0(GPR_TIMESPAN)));
226 ASSERT_EQ(0, gpr_time_similar(gpr_inf_future(GPR_TIMESPAN),
227 gpr_inf_past(GPR_TIMESPAN),
228 gpr_time_0(GPR_TIMESPAN)));
229 ASSERT_EQ(1, gpr_time_similar(gpr_time_from_micros(10, GPR_TIMESPAN),
230 gpr_time_from_micros(10, GPR_TIMESPAN),
231 gpr_time_0(GPR_TIMESPAN)));
232 ASSERT_EQ(1, gpr_time_similar(gpr_time_from_micros(10, GPR_TIMESPAN),
233 gpr_time_from_micros(15, GPR_TIMESPAN),
234 gpr_time_from_micros(10, GPR_TIMESPAN)));
235 ASSERT_EQ(1, gpr_time_similar(gpr_time_from_micros(15, GPR_TIMESPAN),
236 gpr_time_from_micros(10, GPR_TIMESPAN),
237 gpr_time_from_micros(10, GPR_TIMESPAN)));
238 ASSERT_EQ(0, gpr_time_similar(gpr_time_from_micros(10, GPR_TIMESPAN),
239 gpr_time_from_micros(25, GPR_TIMESPAN),
240 gpr_time_from_micros(10, GPR_TIMESPAN)));
241 ASSERT_EQ(0, gpr_time_similar(gpr_time_from_micros(25, GPR_TIMESPAN),
242 gpr_time_from_micros(10, GPR_TIMESPAN),
243 gpr_time_from_micros(10, GPR_TIMESPAN)));
244 }
245
TEST(TimeTest,ConvertExtreme)246 TEST(TimeTest, ConvertExtreme) {
247 gpr_timespec realtime = {INT64_MAX, 1, GPR_CLOCK_REALTIME};
248 gpr_timespec monotime = gpr_convert_clock_type(realtime, GPR_CLOCK_MONOTONIC);
249 ASSERT_EQ(monotime.tv_sec, realtime.tv_sec);
250 ASSERT_EQ(monotime.clock_type, GPR_CLOCK_MONOTONIC);
251 }
252
TEST(TimeTest,CmpExtreme)253 TEST(TimeTest, CmpExtreme) {
254 gpr_timespec t1 = {INT64_MAX, 1, GPR_CLOCK_REALTIME};
255 gpr_timespec t2 = {INT64_MAX, 2, GPR_CLOCK_REALTIME};
256 ASSERT_EQ(gpr_time_cmp(t1, t2), 0);
257 t1.tv_sec = INT64_MIN;
258 t2.tv_sec = INT64_MIN;
259 ASSERT_EQ(gpr_time_cmp(t1, t2), 0);
260 }
261
main(int argc,char ** argv)262 int main(int argc, char** argv) {
263 grpc::testing::TestEnvironment env(&argc, argv);
264 ::testing::InitGoogleTest(&argc, argv);
265 return RUN_ALL_TESTS();
266 }
267