1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2008 Google Inc. All rights reserved.
3 //
4 // Use of this source code is governed by a BSD-style
5 // license that can be found in the LICENSE file or at
6 // https://developers.google.com/open-source/licenses/bsd
7
8 #include "google/protobuf/util/time_util.h"
9
10 #include <cstdint>
11 #include <ctime>
12
13 #include "google/protobuf/duration.pb.h"
14 #include "google/protobuf/timestamp.pb.h"
15 #include "google/protobuf/testing/googletest.h"
16 #include <gtest/gtest.h>
17
18 namespace google {
19 namespace protobuf {
20 namespace util {
21
22 using google::protobuf::Duration;
23 using google::protobuf::Timestamp;
24
25 namespace {
26
TEST(TimeUtilTest,TimestampStringFormat)27 TEST(TimeUtilTest, TimestampStringFormat) {
28 // These these are out of bounds for 32-bit architectures.
29 if(sizeof(time_t) >= sizeof(uint64_t)) {
30 Timestamp begin, end;
31 EXPECT_TRUE(TimeUtil::FromString("0001-01-01T00:00:00Z", &begin));
32 EXPECT_EQ(TimeUtil::kTimestampMinSeconds, begin.seconds());
33 EXPECT_EQ(0, begin.nanos());
34 EXPECT_TRUE(TimeUtil::FromString("9999-12-31T23:59:59.999999999Z", &end));
35 EXPECT_EQ(TimeUtil::kTimestampMaxSeconds, end.seconds());
36 EXPECT_EQ(999999999, end.nanos());
37 EXPECT_EQ("0001-01-01T00:00:00Z", TimeUtil::ToString(begin));
38 EXPECT_EQ("9999-12-31T23:59:59.999999999Z", TimeUtil::ToString(end));
39 }
40
41 // Test negative timestamps.
42 Timestamp time = TimeUtil::NanosecondsToTimestamp(-1);
43 EXPECT_EQ(-1, time.seconds());
44 // Timestamp's nano part is always non-negative.
45 EXPECT_EQ(999999999, time.nanos());
46 EXPECT_EQ("1969-12-31T23:59:59.999999999Z", TimeUtil::ToString(time));
47
48 // Generated output should contain 3, 6, or 9 fractional digits.
49 EXPECT_EQ("1970-01-01T00:00:00Z",
50 TimeUtil::ToString(TimeUtil::NanosecondsToTimestamp(0)));
51 EXPECT_EQ("1970-01-01T00:00:00.010Z",
52 TimeUtil::ToString(TimeUtil::NanosecondsToTimestamp(10000000)));
53 EXPECT_EQ("1970-01-01T00:00:00.000010Z",
54 TimeUtil::ToString(TimeUtil::NanosecondsToTimestamp(10000)));
55 EXPECT_EQ("1970-01-01T00:00:00.000000010Z",
56 TimeUtil::ToString(TimeUtil::NanosecondsToTimestamp(10)));
57
58 // Parsing accepts an fractional digits as long as they fit into nano
59 // precision.
60 EXPECT_TRUE(TimeUtil::FromString("1970-01-01T00:00:00.1Z", &time));
61 EXPECT_EQ(100000000, TimeUtil::TimestampToNanoseconds(time));
62 EXPECT_TRUE(TimeUtil::FromString("1970-01-01T00:00:00.0001Z", &time));
63 EXPECT_EQ(100000, TimeUtil::TimestampToNanoseconds(time));
64 EXPECT_TRUE(TimeUtil::FromString("1970-01-01T00:00:00.0000001Z", &time));
65 EXPECT_EQ(100, TimeUtil::TimestampToNanoseconds(time));
66
67 // Also accepts offsets.
68 EXPECT_TRUE(TimeUtil::FromString("1970-01-01T00:00:00-08:00", &time));
69 EXPECT_EQ(8 * 3600, TimeUtil::TimestampToSeconds(time));
70 }
71
TEST(TimeUtilTest,DurationStringFormat)72 TEST(TimeUtilTest, DurationStringFormat) {
73 Timestamp begin, end;
74 EXPECT_TRUE(TimeUtil::FromString("0001-01-01T00:00:00Z", &begin));
75 EXPECT_TRUE(TimeUtil::FromString("9999-12-31T23:59:59.999999999Z", &end));
76
77 // These these are out of bounds for 32-bit architectures.
78 if(sizeof(time_t) >= sizeof(uint64_t)) {
79 EXPECT_EQ("315537897599.999999999s", TimeUtil::ToString(end - begin));
80 EXPECT_EQ("-315537897599.999999999s", TimeUtil::ToString(begin - end));
81 }
82 EXPECT_EQ(999999999, (end - begin).nanos());
83 EXPECT_EQ(-999999999, (begin - end).nanos());
84
85 // Generated output should contain 3, 6, or 9 fractional digits.
86 EXPECT_EQ("1s", TimeUtil::ToString(TimeUtil::SecondsToDuration(1)));
87 EXPECT_EQ("0.010s", TimeUtil::ToString(TimeUtil::MillisecondsToDuration(10)));
88 EXPECT_EQ("0.000010s",
89 TimeUtil::ToString(TimeUtil::MicrosecondsToDuration(10)));
90 EXPECT_EQ("0.000000010s",
91 TimeUtil::ToString(TimeUtil::NanosecondsToDuration(10)));
92
93 // Parsing accepts an fractional digits as long as they fit into nano
94 // precision.
95 Duration d;
96 EXPECT_TRUE(TimeUtil::FromString("0.1s", &d));
97 EXPECT_EQ(100, TimeUtil::DurationToMilliseconds(d));
98 EXPECT_TRUE(TimeUtil::FromString("0.0001s", &d));
99 EXPECT_EQ(100, TimeUtil::DurationToMicroseconds(d));
100 EXPECT_TRUE(TimeUtil::FromString("0.0000001s", &d));
101 EXPECT_EQ(100, TimeUtil::DurationToNanoseconds(d));
102
103 // Duration must support range from -315,576,000,000s to +315576000000s
104 // which includes negative values.
105 EXPECT_TRUE(TimeUtil::FromString("315576000000.999999999s", &d));
106 EXPECT_EQ(int64_t{315576000000}, d.seconds());
107 EXPECT_EQ(999999999, d.nanos());
108 EXPECT_TRUE(TimeUtil::FromString("-315576000000.999999999s", &d));
109 EXPECT_EQ(int64_t{-315576000000}, d.seconds());
110 EXPECT_EQ(-999999999, d.nanos());
111 }
112
TEST(TimeUtilTest,GetEpoch)113 TEST(TimeUtilTest, GetEpoch) {
114 EXPECT_EQ(0, TimeUtil::TimestampToNanoseconds(TimeUtil::GetEpoch()));
115 }
116
TEST(TimeUtilTest,DurationIntegerConversion)117 TEST(TimeUtilTest, DurationIntegerConversion) {
118 EXPECT_EQ("0.000000001s",
119 TimeUtil::ToString(TimeUtil::NanosecondsToDuration(1)));
120 EXPECT_EQ("-0.000000001s",
121 TimeUtil::ToString(TimeUtil::NanosecondsToDuration(-1)));
122 EXPECT_EQ("0.000001s",
123 TimeUtil::ToString(TimeUtil::MicrosecondsToDuration(1)));
124 EXPECT_EQ("-0.000001s",
125 TimeUtil::ToString(TimeUtil::MicrosecondsToDuration(-1)));
126 EXPECT_EQ("0.001s", TimeUtil::ToString(TimeUtil::MillisecondsToDuration(1)));
127 EXPECT_EQ("-0.001s",
128 TimeUtil::ToString(TimeUtil::MillisecondsToDuration(-1)));
129 EXPECT_EQ("1s", TimeUtil::ToString(TimeUtil::SecondsToDuration(1)));
130 EXPECT_EQ("-1s", TimeUtil::ToString(TimeUtil::SecondsToDuration(-1)));
131 EXPECT_EQ("60s", TimeUtil::ToString(TimeUtil::MinutesToDuration(1)));
132 EXPECT_EQ("-60s", TimeUtil::ToString(TimeUtil::MinutesToDuration(-1)));
133 EXPECT_EQ("3600s", TimeUtil::ToString(TimeUtil::HoursToDuration(1)));
134 EXPECT_EQ("-3600s", TimeUtil::ToString(TimeUtil::HoursToDuration(-1)));
135
136 EXPECT_EQ(
137 1, TimeUtil::DurationToNanoseconds(TimeUtil::NanosecondsToDuration(1)));
138 EXPECT_EQ(
139 -1, TimeUtil::DurationToNanoseconds(TimeUtil::NanosecondsToDuration(-1)));
140 EXPECT_EQ(
141 1, TimeUtil::DurationToMicroseconds(TimeUtil::MicrosecondsToDuration(1)));
142 EXPECT_EQ(-1, TimeUtil::DurationToMicroseconds(
143 TimeUtil::MicrosecondsToDuration(-1)));
144 EXPECT_EQ(
145 1, TimeUtil::DurationToMilliseconds(TimeUtil::MillisecondsToDuration(1)));
146 EXPECT_EQ(-1, TimeUtil::DurationToMilliseconds(
147 TimeUtil::MillisecondsToDuration(-1)));
148 // Test overflow issue
149 EXPECT_EQ(315576000000000, TimeUtil::DurationToMilliseconds(
150 TimeUtil::SecondsToDuration(315576000000)));
151 // Test overflow issue
152 EXPECT_EQ(315576000000000000, TimeUtil::DurationToMicroseconds(
153 TimeUtil::SecondsToDuration(315576000000)));
154 EXPECT_EQ(1, TimeUtil::DurationToSeconds(TimeUtil::SecondsToDuration(1)));
155 EXPECT_EQ(-1, TimeUtil::DurationToSeconds(TimeUtil::SecondsToDuration(-1)));
156 EXPECT_EQ(1, TimeUtil::DurationToMinutes(TimeUtil::MinutesToDuration(1)));
157 EXPECT_EQ(-1, TimeUtil::DurationToMinutes(TimeUtil::MinutesToDuration(-1)));
158 EXPECT_EQ(1, TimeUtil::DurationToHours(TimeUtil::HoursToDuration(1)));
159 EXPECT_EQ(-1, TimeUtil::DurationToHours(TimeUtil::HoursToDuration(-1)));
160
161 // Test truncation behavior.
162 EXPECT_EQ(1, TimeUtil::DurationToMicroseconds(
163 TimeUtil::NanosecondsToDuration(1999)));
164 // For negative values, Duration will be rounded towards 0.
165 EXPECT_EQ(-1, TimeUtil::DurationToMicroseconds(
166 TimeUtil::NanosecondsToDuration(-1999)));
167 }
168
TEST(TestUtilTest,TimestampIntegerConversion)169 TEST(TestUtilTest, TimestampIntegerConversion) {
170 EXPECT_EQ("1970-01-01T00:00:00.000000001Z",
171 TimeUtil::ToString(TimeUtil::NanosecondsToTimestamp(1)));
172 EXPECT_EQ("1969-12-31T23:59:59.999999999Z",
173 TimeUtil::ToString(TimeUtil::NanosecondsToTimestamp(-1)));
174 EXPECT_EQ("1970-01-01T00:00:00.000001Z",
175 TimeUtil::ToString(TimeUtil::MicrosecondsToTimestamp(1)));
176 EXPECT_EQ("1969-12-31T23:59:59.999999Z",
177 TimeUtil::ToString(TimeUtil::MicrosecondsToTimestamp(-1)));
178 EXPECT_EQ("1970-01-01T00:00:00.001Z",
179 TimeUtil::ToString(TimeUtil::MillisecondsToTimestamp(1)));
180 EXPECT_EQ("1969-12-31T23:59:59.999Z",
181 TimeUtil::ToString(TimeUtil::MillisecondsToTimestamp(-1)));
182 EXPECT_EQ("1970-01-01T00:00:01Z",
183 TimeUtil::ToString(TimeUtil::SecondsToTimestamp(1)));
184 EXPECT_EQ("1969-12-31T23:59:59Z",
185 TimeUtil::ToString(TimeUtil::SecondsToTimestamp(-1)));
186
187 EXPECT_EQ(
188 1, TimeUtil::TimestampToNanoseconds(TimeUtil::NanosecondsToTimestamp(1)));
189 EXPECT_EQ(-1, TimeUtil::TimestampToNanoseconds(
190 TimeUtil::NanosecondsToTimestamp(-1)));
191 EXPECT_EQ(1, TimeUtil::TimestampToMicroseconds(
192 TimeUtil::MicrosecondsToTimestamp(1)));
193 EXPECT_EQ(-1, TimeUtil::TimestampToMicroseconds(
194 TimeUtil::MicrosecondsToTimestamp(-1)));
195 EXPECT_EQ(1, TimeUtil::TimestampToMilliseconds(
196 TimeUtil::MillisecondsToTimestamp(1)));
197 EXPECT_EQ(-1, TimeUtil::TimestampToMilliseconds(
198 TimeUtil::MillisecondsToTimestamp(-1)));
199 EXPECT_EQ(1, TimeUtil::TimestampToSeconds(TimeUtil::SecondsToTimestamp(1)));
200 EXPECT_EQ(-1, TimeUtil::TimestampToSeconds(TimeUtil::SecondsToTimestamp(-1)));
201
202 // Test truncation behavior.
203 EXPECT_EQ(1, TimeUtil::TimestampToMicroseconds(
204 TimeUtil::NanosecondsToTimestamp(1999)));
205 // For negative values, Timestamp will be rounded down.
206 // For example, "1969-12-31T23:59:59.5Z" (i.e., -0.5s) rounded to seconds
207 // will be "1969-12-31T23:59:59Z" (i.e., -1s) rather than
208 // "1970-01-01T00:00:00Z" (i.e., 0s).
209 EXPECT_EQ(-2, TimeUtil::TimestampToMicroseconds(
210 TimeUtil::NanosecondsToTimestamp(-1999)));
211 }
212
TEST(TimeUtilTest,TimeTConversion)213 TEST(TimeUtilTest, TimeTConversion) {
214 time_t value = time(nullptr);
215 EXPECT_EQ(value,
216 TimeUtil::TimestampToTimeT(TimeUtil::TimeTToTimestamp(value)));
217 EXPECT_EQ(
218 1, TimeUtil::TimestampToTimeT(TimeUtil::MillisecondsToTimestamp(1999)));
219 }
220
TEST(TimeUtilTest,TimevalConversion)221 TEST(TimeUtilTest, TimevalConversion) {
222 timeval value = TimeUtil::TimestampToTimeval(
223 TimeUtil::NanosecondsToTimestamp(1999999999));
224 EXPECT_EQ(1, value.tv_sec);
225 EXPECT_EQ(999999, value.tv_usec);
226 value = TimeUtil::TimestampToTimeval(
227 TimeUtil::NanosecondsToTimestamp(-1999999999));
228 EXPECT_EQ(-2, value.tv_sec);
229 EXPECT_EQ(0, value.tv_usec);
230
231 value =
232 TimeUtil::DurationToTimeval(TimeUtil::NanosecondsToDuration(1999999999));
233 EXPECT_EQ(1, value.tv_sec);
234 EXPECT_EQ(999999, value.tv_usec);
235 value =
236 TimeUtil::DurationToTimeval(TimeUtil::NanosecondsToDuration(-1999999999));
237 EXPECT_EQ(-2, value.tv_sec);
238 EXPECT_EQ(1, value.tv_usec);
239 }
240
TEST(TimeUtilTest,DurationOperators)241 TEST(TimeUtilTest, DurationOperators) {
242 Duration one_second = TimeUtil::SecondsToDuration(1);
243 Duration one_nano = TimeUtil::NanosecondsToDuration(1);
244
245 // Test +/-
246 Duration a = one_second;
247 a += one_second;
248 a -= one_nano;
249 EXPECT_EQ("1.999999999s", TimeUtil::ToString(a));
250 Duration b = -a;
251 EXPECT_EQ("-1.999999999s", TimeUtil::ToString(b));
252 EXPECT_EQ("3.999999998s", TimeUtil::ToString(a + a));
253 EXPECT_EQ("0s", TimeUtil::ToString(a + b));
254 EXPECT_EQ("0s", TimeUtil::ToString(b + a));
255 EXPECT_EQ("-3.999999998s", TimeUtil::ToString(b + b));
256 EXPECT_EQ("3.999999998s", TimeUtil::ToString(a - b));
257 EXPECT_EQ("0s", TimeUtil::ToString(a - a));
258 EXPECT_EQ("0s", TimeUtil::ToString(b - b));
259 EXPECT_EQ("-3.999999998s", TimeUtil::ToString(b - a));
260
261 // Test *
262 EXPECT_EQ(a + a, a * 2);
263 EXPECT_EQ(b + b, a * (-2));
264 EXPECT_EQ(b + b, b * 2);
265 EXPECT_EQ(a + a, b * (-2));
266 EXPECT_EQ("0.999999999s", TimeUtil::ToString(a * 0.5));
267 EXPECT_EQ("-0.999999999s", TimeUtil::ToString(b * 0.5));
268 // Multiplication should not overflow if the result fits into the supported
269 // range of Duration (intermediate result may be larger than int64).
270 EXPECT_EQ("315575999684.424s", TimeUtil::ToString((one_second - one_nano) *
271 int64_t{315576000000}));
272 EXPECT_EQ("-315575999684.424s", TimeUtil::ToString((one_nano - one_second) *
273 int64_t{315576000000}));
274 EXPECT_EQ("-315575999684.424s", TimeUtil::ToString((one_second - one_nano) *
275 (int64_t{-315576000000})));
276
277 // Test / and %
278 EXPECT_EQ("0.999999999s", TimeUtil::ToString(a / 2));
279 EXPECT_EQ("-0.999999999s", TimeUtil::ToString(b / 2));
280 Duration large =
281 TimeUtil::SecondsToDuration(int64_t{315576000000}) - one_nano;
282 // We have to handle division with values beyond 64 bits.
283 EXPECT_EQ("0.999999999s", TimeUtil::ToString(large / int64_t{315576000000}));
284 EXPECT_EQ("-0.999999999s",
285 TimeUtil::ToString((-large) / int64_t{315576000000}));
286 EXPECT_EQ("-0.999999999s",
287 TimeUtil::ToString(large / (int64_t{-315576000000})));
288 Duration large2 = large + one_nano;
289 EXPECT_EQ(large, large % large2);
290 EXPECT_EQ(-large, (-large) % large2);
291 EXPECT_EQ(large, large % (-large2));
292 EXPECT_EQ(one_nano, large2 % large);
293 EXPECT_EQ(-one_nano, (-large2) % large);
294 EXPECT_EQ(one_nano, large2 % (-large));
295 // Some corner cases about negative values.
296 //
297 // (-5) / 2 = -2, remainder = -1
298 // (-5) / (-2) = 2, remainder = -1
299 a = TimeUtil::NanosecondsToDuration(-5);
300 EXPECT_EQ(TimeUtil::NanosecondsToDuration(-2), a / 2);
301 EXPECT_EQ(TimeUtil::NanosecondsToDuration(2), a / (-2));
302 b = TimeUtil::NanosecondsToDuration(2);
303 EXPECT_EQ(-2, a / b);
304 EXPECT_EQ(TimeUtil::NanosecondsToDuration(-1), a % b);
305 EXPECT_EQ(2, a / (-b));
306 EXPECT_EQ(TimeUtil::NanosecondsToDuration(-1), a % (-b));
307
308 // Test relational operators.
309 EXPECT_TRUE(one_nano < one_second);
310 EXPECT_FALSE(one_second < one_second);
311 EXPECT_FALSE(one_second < one_nano);
312 EXPECT_FALSE(-one_nano < -one_second);
313 EXPECT_FALSE(-one_second < -one_second);
314 EXPECT_TRUE(-one_second < -one_nano);
315 EXPECT_TRUE(-one_nano < one_nano);
316 EXPECT_FALSE(one_nano < -one_nano);
317
318 EXPECT_FALSE(one_nano > one_second);
319 EXPECT_FALSE(one_nano > one_nano);
320 EXPECT_TRUE(one_second > one_nano);
321
322 EXPECT_FALSE(one_nano >= one_second);
323 EXPECT_TRUE(one_nano >= one_nano);
324 EXPECT_TRUE(one_second >= one_nano);
325
326 EXPECT_TRUE(one_nano <= one_second);
327 EXPECT_TRUE(one_nano <= one_nano);
328 EXPECT_FALSE(one_second <= one_nano);
329
330 EXPECT_TRUE(one_nano == one_nano);
331 EXPECT_FALSE(one_nano == one_second);
332
333 EXPECT_FALSE(one_nano != one_nano);
334 EXPECT_TRUE(one_nano != one_second);
335 }
336
TEST(TimeUtilTest,TimestampOperators)337 TEST(TimeUtilTest, TimestampOperators) {
338 Timestamp begin, end;
339 EXPECT_TRUE(TimeUtil::FromString("0001-01-01T00:00:00Z", &begin));
340 EXPECT_TRUE(TimeUtil::FromString("9999-12-31T23:59:59.999999999Z", &end));
341 Duration d = end - begin;
342 EXPECT_TRUE(end == begin + d);
343 EXPECT_TRUE(end == d + begin);
344 EXPECT_TRUE(begin == end - d);
345
346 // Test relational operators
347 Timestamp t1 = begin + d / 4;
348 Timestamp t2 = end - d / 4;
349 EXPECT_TRUE(t1 < t2);
350 EXPECT_FALSE(t1 < t1);
351 EXPECT_FALSE(t2 < t1);
352 EXPECT_FALSE(t1 > t2);
353 EXPECT_FALSE(t1 > t1);
354 EXPECT_TRUE(t2 > t1);
355 EXPECT_FALSE(t1 >= t2);
356 EXPECT_TRUE(t1 >= t1);
357 EXPECT_TRUE(t2 >= t1);
358 EXPECT_TRUE(t1 <= t2);
359 EXPECT_TRUE(t1 <= t1);
360 EXPECT_FALSE(t2 <= t1);
361
362 EXPECT_FALSE(t1 == t2);
363 EXPECT_TRUE(t1 == t1);
364 EXPECT_FALSE(t2 == t1);
365 EXPECT_TRUE(t1 != t2);
366 EXPECT_FALSE(t1 != t1);
367 EXPECT_TRUE(t2 != t1);
368 }
369
TEST(TimeUtilTest,IsDurationValid)370 TEST(TimeUtilTest, IsDurationValid) {
371 Duration valid;
372 Duration overflow;
373 overflow.set_seconds(TimeUtil::kDurationMaxSeconds + 1);
374 Duration underflow;
375 underflow.set_seconds(TimeUtil::kDurationMinSeconds - 1);
376 Duration overflow_nanos;
377 overflow_nanos.set_nanos(TimeUtil::kDurationMaxNanoseconds + 1);
378 Duration underflow_nanos;
379 underflow_nanos.set_nanos(TimeUtil::kDurationMinNanoseconds - 1);
380 Duration positive_seconds_negative_nanos;
381 positive_seconds_negative_nanos.set_seconds(1);
382 positive_seconds_negative_nanos.set_nanos(-1);
383 Duration negative_seconds_positive_nanos;
384 negative_seconds_positive_nanos.set_seconds(-1);
385 negative_seconds_positive_nanos.set_nanos(1);
386
387 EXPECT_TRUE(TimeUtil::IsDurationValid(valid));
388 EXPECT_FALSE(TimeUtil::IsDurationValid(overflow));
389 EXPECT_FALSE(TimeUtil::IsDurationValid(underflow));
390 EXPECT_FALSE(TimeUtil::IsDurationValid(overflow_nanos));
391 EXPECT_FALSE(TimeUtil::IsDurationValid(underflow_nanos));
392 EXPECT_FALSE(TimeUtil::IsDurationValid(positive_seconds_negative_nanos));
393 EXPECT_FALSE(TimeUtil::IsDurationValid(negative_seconds_positive_nanos));
394 }
395
TEST(TimeUtilTest,IsTimestampValid)396 TEST(TimeUtilTest, IsTimestampValid) {
397 Timestamp valid;
398 Timestamp overflow;
399 overflow.set_seconds(TimeUtil::kTimestampMaxSeconds + 1);
400 Timestamp underflow;
401 underflow.set_seconds(TimeUtil::kTimestampMinSeconds - 1);
402 Timestamp overflow_nanos;
403 overflow_nanos.set_nanos(TimeUtil::kTimestampMaxNanoseconds + 1);
404 Timestamp underflow_nanos;
405 underflow_nanos.set_nanos(TimeUtil::kTimestampMinNanoseconds - 1);
406
407 EXPECT_TRUE(TimeUtil::IsTimestampValid(valid));
408 EXPECT_FALSE(TimeUtil::IsTimestampValid(overflow));
409 EXPECT_FALSE(TimeUtil::IsTimestampValid(underflow));
410 EXPECT_FALSE(TimeUtil::IsTimestampValid(overflow_nanos));
411 EXPECT_FALSE(TimeUtil::IsTimestampValid(underflow_nanos));
412 }
413
414 #if GTEST_HAS_DEATH_TEST // death tests do not work on Windows yet.
415 #ifndef NDEBUG
416
TEST(TimeUtilTest,DurationBounds)417 TEST(TimeUtilTest, DurationBounds) {
418 Duration overflow;
419 overflow.set_seconds(TimeUtil::kDurationMaxSeconds + 1);
420 Duration underflow;
421 underflow.set_seconds(TimeUtil::kDurationMinSeconds - 1);
422 Duration overflow_nanos;
423 overflow_nanos.set_nanos(TimeUtil::kDurationMaxNanoseconds + 1);
424 Duration underflow_nanos;
425 underflow_nanos.set_nanos(TimeUtil::kDurationMinNanoseconds - 1);
426
427 EXPECT_DEATH({ TimeUtil::SecondsToDuration(overflow.seconds()); },
428 "Duration seconds");
429 EXPECT_DEATH({ TimeUtil::SecondsToDuration(underflow.seconds()); },
430 "Duration seconds");
431 EXPECT_DEATH(
432 { TimeUtil::MinutesToDuration(overflow.seconds() / 60 + 1); },
433 "Duration minutes");
434 EXPECT_DEATH(
435 { TimeUtil::MinutesToDuration(underflow.seconds() / 60 - 1); },
436 "Duration minutes");
437 EXPECT_DEATH(
438 { TimeUtil::HoursToDuration(overflow.seconds() / 60 + 1); },
439 "Duration hours");
440 EXPECT_DEATH(
441 { TimeUtil::HoursToDuration(underflow.seconds() / 60 - 1); },
442 "Duration hours");
443
444 EXPECT_DEATH({ TimeUtil::DurationToNanoseconds(overflow); },
445 "outside of the valid range");
446 EXPECT_DEATH({ TimeUtil::DurationToNanoseconds(underflow); },
447 "outside of the valid range");
448 EXPECT_DEATH({ TimeUtil::DurationToNanoseconds(overflow_nanos); },
449 "outside of the valid range");
450 EXPECT_DEATH({ TimeUtil::DurationToNanoseconds(underflow_nanos); },
451 "outside of the valid range");
452 EXPECT_DEATH({ TimeUtil::DurationToSeconds(overflow); },
453 "outside of the valid range");
454 EXPECT_DEATH({ TimeUtil::DurationToSeconds(underflow); },
455 "outside of the valid range");
456 EXPECT_DEATH({ TimeUtil::DurationToSeconds(overflow_nanos); },
457 "outside of the valid range");
458 EXPECT_DEATH({ TimeUtil::DurationToSeconds(underflow_nanos); },
459 "outside of the valid range");
460 }
461
TEST(TimeUtilTest,TimestampBounds)462 TEST(TimeUtilTest, TimestampBounds) {
463 Timestamp overflow;
464 overflow.set_seconds(TimeUtil::kDurationMaxSeconds + 1);
465 Timestamp underflow;
466 underflow.set_seconds(TimeUtil::kDurationMinSeconds - 1);
467 Timestamp overflow_nanos;
468 overflow_nanos.set_nanos(TimeUtil::kDurationMaxNanoseconds + 1);
469 Timestamp underflow_nanos;
470 underflow_nanos.set_nanos(TimeUtil::kDurationMinNanoseconds - 1);
471
472 EXPECT_DEATH({ TimeUtil::TimestampToNanoseconds(overflow); },
473 "outside of the valid range");
474 EXPECT_DEATH({ TimeUtil::TimestampToNanoseconds(underflow); },
475 "outside of the valid range");
476 EXPECT_DEATH({ TimeUtil::TimestampToNanoseconds(overflow_nanos); },
477 "outside of the valid range");
478 EXPECT_DEATH({ TimeUtil::TimestampToNanoseconds(underflow_nanos); },
479 "outside of the valid range");
480
481 EXPECT_DEATH({ TimeUtil::TimestampToMicroseconds(overflow); },
482 "outside of the valid range");
483 EXPECT_DEATH({ TimeUtil::TimestampToMicroseconds(underflow); },
484 "outside of the valid range");
485 EXPECT_DEATH({ TimeUtil::TimestampToMicroseconds(overflow_nanos); },
486 "outside of the valid range");
487 EXPECT_DEATH({ TimeUtil::TimestampToMicroseconds(underflow_nanos); },
488 "outside of the valid range");
489
490 EXPECT_DEATH({ TimeUtil::TimestampToMilliseconds(overflow); },
491 "outside of the valid range");
492 EXPECT_DEATH({ TimeUtil::TimestampToMilliseconds(underflow); },
493 "outside of the valid range");
494 EXPECT_DEATH({ TimeUtil::TimestampToMilliseconds(overflow_nanos); },
495 "outside of the valid range");
496 EXPECT_DEATH({ TimeUtil::TimestampToMilliseconds(underflow_nanos); },
497 "outside of the valid range");
498
499 EXPECT_DEATH({ TimeUtil::TimestampToSeconds(overflow); },
500 "outside of the valid range");
501 EXPECT_DEATH({ TimeUtil::TimestampToSeconds(underflow); },
502 "outside of the valid range");
503 EXPECT_DEATH({ TimeUtil::TimestampToSeconds(overflow_nanos); },
504 "outside of the valid range");
505 EXPECT_DEATH({ TimeUtil::TimestampToSeconds(underflow_nanos); },
506 "outside of the valid range");
507 }
508 #endif // !NDEBUG
509 #endif // GTEST_HAS_DEATH_TEST
510
511 } // namespace
512 } // namespace util
513 } // namespace protobuf
514 } // namespace google
515