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