1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2008 Google Inc. All rights reserved.
3 // https://developers.google.com/protocol-buffers/
4 //
5 // Redistribution and use in source and binary forms, with or without
6 // modification, are permitted provided that the following conditions are
7 // met:
8 //
9 // * Redistributions of source code must retain the above copyright
10 // notice, this list of conditions and the following disclaimer.
11 // * Redistributions in binary form must reproduce the above
12 // copyright notice, this list of conditions and the following disclaimer
13 // in the documentation and/or other materials provided with the
14 // distribution.
15 // * Neither the name of Google Inc. nor the names of its
16 // contributors may be used to endorse or promote products derived from
17 // this software without specific prior written permission.
18 //
19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30
31 #include <google/protobuf/util/time_util.h>
32
33 #include <cstdint>
34 #include <ctime>
35
36 #include <google/protobuf/duration.pb.h>
37 #include <google/protobuf/timestamp.pb.h>
38 #include <google/protobuf/testing/googletest.h>
39 #include <gtest/gtest.h>
40
41 namespace google {
42 namespace protobuf {
43 namespace util {
44
45 using google::protobuf::Duration;
46 using google::protobuf::Timestamp;
47
48 namespace {
49
TEST(TimeUtilTest,TimestampStringFormat)50 TEST(TimeUtilTest, TimestampStringFormat) {
51 Timestamp begin, end;
52 EXPECT_TRUE(TimeUtil::FromString("0001-01-01T00:00:00Z", &begin));
53 EXPECT_EQ(TimeUtil::kTimestampMinSeconds, begin.seconds());
54 EXPECT_EQ(0, begin.nanos());
55 EXPECT_TRUE(TimeUtil::FromString("9999-12-31T23:59:59.999999999Z", &end));
56 EXPECT_EQ(TimeUtil::kTimestampMaxSeconds, end.seconds());
57 EXPECT_EQ(999999999, end.nanos());
58 EXPECT_EQ("0001-01-01T00:00:00Z", TimeUtil::ToString(begin));
59 EXPECT_EQ("9999-12-31T23:59:59.999999999Z", TimeUtil::ToString(end));
60
61 // Test negative timestamps.
62 Timestamp time = TimeUtil::NanosecondsToTimestamp(-1);
63 EXPECT_EQ(-1, time.seconds());
64 // Timestamp's nano part is always non-negative.
65 EXPECT_EQ(999999999, time.nanos());
66 EXPECT_EQ("1969-12-31T23:59:59.999999999Z", TimeUtil::ToString(time));
67
68 // Generated output should contain 3, 6, or 9 fractional digits.
69 EXPECT_EQ("1970-01-01T00:00:00Z",
70 TimeUtil::ToString(TimeUtil::NanosecondsToTimestamp(0)));
71 EXPECT_EQ("1970-01-01T00:00:00.010Z",
72 TimeUtil::ToString(TimeUtil::NanosecondsToTimestamp(10000000)));
73 EXPECT_EQ("1970-01-01T00:00:00.000010Z",
74 TimeUtil::ToString(TimeUtil::NanosecondsToTimestamp(10000)));
75 EXPECT_EQ("1970-01-01T00:00:00.000000010Z",
76 TimeUtil::ToString(TimeUtil::NanosecondsToTimestamp(10)));
77
78 // Parsing accepts an fractional digits as long as they fit into nano
79 // precision.
80 EXPECT_TRUE(TimeUtil::FromString("1970-01-01T00:00:00.1Z", &time));
81 EXPECT_EQ(100000000, TimeUtil::TimestampToNanoseconds(time));
82 EXPECT_TRUE(TimeUtil::FromString("1970-01-01T00:00:00.0001Z", &time));
83 EXPECT_EQ(100000, TimeUtil::TimestampToNanoseconds(time));
84 EXPECT_TRUE(TimeUtil::FromString("1970-01-01T00:00:00.0000001Z", &time));
85 EXPECT_EQ(100, TimeUtil::TimestampToNanoseconds(time));
86
87 // Also accepts offsets.
88 EXPECT_TRUE(TimeUtil::FromString("1970-01-01T00:00:00-08:00", &time));
89 EXPECT_EQ(8 * 3600, TimeUtil::TimestampToSeconds(time));
90 }
91
TEST(TimeUtilTest,DurationStringFormat)92 TEST(TimeUtilTest, DurationStringFormat) {
93 Timestamp begin, end;
94 EXPECT_TRUE(TimeUtil::FromString("0001-01-01T00:00:00Z", &begin));
95 EXPECT_TRUE(TimeUtil::FromString("9999-12-31T23:59:59.999999999Z", &end));
96
97 EXPECT_EQ("315537897599.999999999s", TimeUtil::ToString(end - begin));
98 EXPECT_EQ(999999999, (end - begin).nanos());
99 EXPECT_EQ("-315537897599.999999999s", TimeUtil::ToString(begin - end));
100 EXPECT_EQ(-999999999, (begin - end).nanos());
101
102 // Generated output should contain 3, 6, or 9 fractional digits.
103 EXPECT_EQ("1s", TimeUtil::ToString(TimeUtil::SecondsToDuration(1)));
104 EXPECT_EQ("0.010s", TimeUtil::ToString(TimeUtil::MillisecondsToDuration(10)));
105 EXPECT_EQ("0.000010s",
106 TimeUtil::ToString(TimeUtil::MicrosecondsToDuration(10)));
107 EXPECT_EQ("0.000000010s",
108 TimeUtil::ToString(TimeUtil::NanosecondsToDuration(10)));
109
110 // Parsing accepts an fractional digits as long as they fit into nano
111 // precision.
112 Duration d;
113 EXPECT_TRUE(TimeUtil::FromString("0.1s", &d));
114 EXPECT_EQ(100, TimeUtil::DurationToMilliseconds(d));
115 EXPECT_TRUE(TimeUtil::FromString("0.0001s", &d));
116 EXPECT_EQ(100, TimeUtil::DurationToMicroseconds(d));
117 EXPECT_TRUE(TimeUtil::FromString("0.0000001s", &d));
118 EXPECT_EQ(100, TimeUtil::DurationToNanoseconds(d));
119
120 // Duration must support range from -315,576,000,000s to +315576000000s
121 // which includes negative values.
122 EXPECT_TRUE(TimeUtil::FromString("315576000000.999999999s", &d));
123 EXPECT_EQ(int64_t{315576000000}, d.seconds());
124 EXPECT_EQ(999999999, d.nanos());
125 EXPECT_TRUE(TimeUtil::FromString("-315576000000.999999999s", &d));
126 EXPECT_EQ(int64_t{-315576000000}, d.seconds());
127 EXPECT_EQ(-999999999, d.nanos());
128 }
129
TEST(TimeUtilTest,GetEpoch)130 TEST(TimeUtilTest, GetEpoch) {
131 EXPECT_EQ(0, TimeUtil::TimestampToNanoseconds(TimeUtil::GetEpoch()));
132 }
133
TEST(TimeUtilTest,DurationIntegerConversion)134 TEST(TimeUtilTest, DurationIntegerConversion) {
135 EXPECT_EQ("0.000000001s",
136 TimeUtil::ToString(TimeUtil::NanosecondsToDuration(1)));
137 EXPECT_EQ("-0.000000001s",
138 TimeUtil::ToString(TimeUtil::NanosecondsToDuration(-1)));
139 EXPECT_EQ("0.000001s",
140 TimeUtil::ToString(TimeUtil::MicrosecondsToDuration(1)));
141 EXPECT_EQ("-0.000001s",
142 TimeUtil::ToString(TimeUtil::MicrosecondsToDuration(-1)));
143 EXPECT_EQ("0.001s", TimeUtil::ToString(TimeUtil::MillisecondsToDuration(1)));
144 EXPECT_EQ("-0.001s",
145 TimeUtil::ToString(TimeUtil::MillisecondsToDuration(-1)));
146 EXPECT_EQ("1s", TimeUtil::ToString(TimeUtil::SecondsToDuration(1)));
147 EXPECT_EQ("-1s", TimeUtil::ToString(TimeUtil::SecondsToDuration(-1)));
148 EXPECT_EQ("60s", TimeUtil::ToString(TimeUtil::MinutesToDuration(1)));
149 EXPECT_EQ("-60s", TimeUtil::ToString(TimeUtil::MinutesToDuration(-1)));
150 EXPECT_EQ("3600s", TimeUtil::ToString(TimeUtil::HoursToDuration(1)));
151 EXPECT_EQ("-3600s", TimeUtil::ToString(TimeUtil::HoursToDuration(-1)));
152
153 EXPECT_EQ(
154 1, TimeUtil::DurationToNanoseconds(TimeUtil::NanosecondsToDuration(1)));
155 EXPECT_EQ(
156 -1, TimeUtil::DurationToNanoseconds(TimeUtil::NanosecondsToDuration(-1)));
157 EXPECT_EQ(
158 1, TimeUtil::DurationToMicroseconds(TimeUtil::MicrosecondsToDuration(1)));
159 EXPECT_EQ(-1, TimeUtil::DurationToMicroseconds(
160 TimeUtil::MicrosecondsToDuration(-1)));
161 EXPECT_EQ(
162 1, TimeUtil::DurationToMilliseconds(TimeUtil::MillisecondsToDuration(1)));
163 EXPECT_EQ(-1, TimeUtil::DurationToMilliseconds(
164 TimeUtil::MillisecondsToDuration(-1)));
165 EXPECT_EQ(1, TimeUtil::DurationToSeconds(TimeUtil::SecondsToDuration(1)));
166 EXPECT_EQ(-1, TimeUtil::DurationToSeconds(TimeUtil::SecondsToDuration(-1)));
167 EXPECT_EQ(1, TimeUtil::DurationToMinutes(TimeUtil::MinutesToDuration(1)));
168 EXPECT_EQ(-1, TimeUtil::DurationToMinutes(TimeUtil::MinutesToDuration(-1)));
169 EXPECT_EQ(1, TimeUtil::DurationToHours(TimeUtil::HoursToDuration(1)));
170 EXPECT_EQ(-1, TimeUtil::DurationToHours(TimeUtil::HoursToDuration(-1)));
171
172 // Test truncation behavior.
173 EXPECT_EQ(1, TimeUtil::DurationToMicroseconds(
174 TimeUtil::NanosecondsToDuration(1999)));
175 // For negative values, Duration will be rounded towards 0.
176 EXPECT_EQ(-1, TimeUtil::DurationToMicroseconds(
177 TimeUtil::NanosecondsToDuration(-1999)));
178 }
179
TEST(TestUtilTest,TimestampIntegerConversion)180 TEST(TestUtilTest, TimestampIntegerConversion) {
181 EXPECT_EQ("1970-01-01T00:00:00.000000001Z",
182 TimeUtil::ToString(TimeUtil::NanosecondsToTimestamp(1)));
183 EXPECT_EQ("1969-12-31T23:59:59.999999999Z",
184 TimeUtil::ToString(TimeUtil::NanosecondsToTimestamp(-1)));
185 EXPECT_EQ("1970-01-01T00:00:00.000001Z",
186 TimeUtil::ToString(TimeUtil::MicrosecondsToTimestamp(1)));
187 EXPECT_EQ("1969-12-31T23:59:59.999999Z",
188 TimeUtil::ToString(TimeUtil::MicrosecondsToTimestamp(-1)));
189 EXPECT_EQ("1970-01-01T00:00:00.001Z",
190 TimeUtil::ToString(TimeUtil::MillisecondsToTimestamp(1)));
191 EXPECT_EQ("1969-12-31T23:59:59.999Z",
192 TimeUtil::ToString(TimeUtil::MillisecondsToTimestamp(-1)));
193 EXPECT_EQ("1970-01-01T00:00:01Z",
194 TimeUtil::ToString(TimeUtil::SecondsToTimestamp(1)));
195 EXPECT_EQ("1969-12-31T23:59:59Z",
196 TimeUtil::ToString(TimeUtil::SecondsToTimestamp(-1)));
197
198 EXPECT_EQ(
199 1, TimeUtil::TimestampToNanoseconds(TimeUtil::NanosecondsToTimestamp(1)));
200 EXPECT_EQ(-1, TimeUtil::TimestampToNanoseconds(
201 TimeUtil::NanosecondsToTimestamp(-1)));
202 EXPECT_EQ(1, TimeUtil::TimestampToMicroseconds(
203 TimeUtil::MicrosecondsToTimestamp(1)));
204 EXPECT_EQ(-1, TimeUtil::TimestampToMicroseconds(
205 TimeUtil::MicrosecondsToTimestamp(-1)));
206 EXPECT_EQ(1, TimeUtil::TimestampToMilliseconds(
207 TimeUtil::MillisecondsToTimestamp(1)));
208 EXPECT_EQ(-1, TimeUtil::TimestampToMilliseconds(
209 TimeUtil::MillisecondsToTimestamp(-1)));
210 EXPECT_EQ(1, TimeUtil::TimestampToSeconds(TimeUtil::SecondsToTimestamp(1)));
211 EXPECT_EQ(-1, TimeUtil::TimestampToSeconds(TimeUtil::SecondsToTimestamp(-1)));
212
213 // Test truncation behavior.
214 EXPECT_EQ(1, TimeUtil::TimestampToMicroseconds(
215 TimeUtil::NanosecondsToTimestamp(1999)));
216 // For negative values, Timestamp will be rounded down.
217 // For example, "1969-12-31T23:59:59.5Z" (i.e., -0.5s) rounded to seconds
218 // will be "1969-12-31T23:59:59Z" (i.e., -1s) rather than
219 // "1970-01-01T00:00:00Z" (i.e., 0s).
220 EXPECT_EQ(-2, TimeUtil::TimestampToMicroseconds(
221 TimeUtil::NanosecondsToTimestamp(-1999)));
222 }
223
TEST(TimeUtilTest,TimeTConversion)224 TEST(TimeUtilTest, TimeTConversion) {
225 time_t value = time(nullptr);
226 EXPECT_EQ(value,
227 TimeUtil::TimestampToTimeT(TimeUtil::TimeTToTimestamp(value)));
228 EXPECT_EQ(
229 1, TimeUtil::TimestampToTimeT(TimeUtil::MillisecondsToTimestamp(1999)));
230 }
231
TEST(TimeUtilTest,TimevalConversion)232 TEST(TimeUtilTest, TimevalConversion) {
233 timeval value = TimeUtil::TimestampToTimeval(
234 TimeUtil::NanosecondsToTimestamp(1999999999));
235 EXPECT_EQ(1, value.tv_sec);
236 EXPECT_EQ(999999, value.tv_usec);
237 value = TimeUtil::TimestampToTimeval(
238 TimeUtil::NanosecondsToTimestamp(-1999999999));
239 EXPECT_EQ(-2, value.tv_sec);
240 EXPECT_EQ(0, value.tv_usec);
241
242 value =
243 TimeUtil::DurationToTimeval(TimeUtil::NanosecondsToDuration(1999999999));
244 EXPECT_EQ(1, value.tv_sec);
245 EXPECT_EQ(999999, value.tv_usec);
246 value =
247 TimeUtil::DurationToTimeval(TimeUtil::NanosecondsToDuration(-1999999999));
248 EXPECT_EQ(-2, value.tv_sec);
249 EXPECT_EQ(1, value.tv_usec);
250 }
251
TEST(TimeUtilTest,DurationOperators)252 TEST(TimeUtilTest, DurationOperators) {
253 Duration one_second = TimeUtil::SecondsToDuration(1);
254 Duration one_nano = TimeUtil::NanosecondsToDuration(1);
255
256 // Test +/-
257 Duration a = one_second;
258 a += one_second;
259 a -= one_nano;
260 EXPECT_EQ("1.999999999s", TimeUtil::ToString(a));
261 Duration b = -a;
262 EXPECT_EQ("-1.999999999s", TimeUtil::ToString(b));
263 EXPECT_EQ("3.999999998s", TimeUtil::ToString(a + a));
264 EXPECT_EQ("0s", TimeUtil::ToString(a + b));
265 EXPECT_EQ("0s", TimeUtil::ToString(b + a));
266 EXPECT_EQ("-3.999999998s", TimeUtil::ToString(b + b));
267 EXPECT_EQ("3.999999998s", TimeUtil::ToString(a - b));
268 EXPECT_EQ("0s", TimeUtil::ToString(a - a));
269 EXPECT_EQ("0s", TimeUtil::ToString(b - b));
270 EXPECT_EQ("-3.999999998s", TimeUtil::ToString(b - a));
271
272 // Test *
273 EXPECT_EQ(a + a, a * 2);
274 EXPECT_EQ(b + b, a * (-2));
275 EXPECT_EQ(b + b, b * 2);
276 EXPECT_EQ(a + a, b * (-2));
277 EXPECT_EQ("0.999999999s", TimeUtil::ToString(a * 0.5));
278 EXPECT_EQ("-0.999999999s", TimeUtil::ToString(b * 0.5));
279 // Multiplication should not overflow if the result fits into the supported
280 // range of Duration (intermediate result may be larger than int64).
281 EXPECT_EQ("315575999684.424s", TimeUtil::ToString((one_second - one_nano) *
282 int64_t{315576000000}));
283 EXPECT_EQ("-315575999684.424s", TimeUtil::ToString((one_nano - one_second) *
284 int64_t{315576000000}));
285 EXPECT_EQ("-315575999684.424s", TimeUtil::ToString((one_second - one_nano) *
286 (int64_t{-315576000000})));
287
288 // Test / and %
289 EXPECT_EQ("0.999999999s", TimeUtil::ToString(a / 2));
290 EXPECT_EQ("-0.999999999s", TimeUtil::ToString(b / 2));
291 Duration large =
292 TimeUtil::SecondsToDuration(int64_t{315576000000}) - one_nano;
293 // We have to handle division with values beyond 64 bits.
294 EXPECT_EQ("0.999999999s", TimeUtil::ToString(large / int64_t{315576000000}));
295 EXPECT_EQ("-0.999999999s",
296 TimeUtil::ToString((-large) / int64_t{315576000000}));
297 EXPECT_EQ("-0.999999999s",
298 TimeUtil::ToString(large / (int64_t{-315576000000})));
299 Duration large2 = large + one_nano;
300 EXPECT_EQ(large, large % large2);
301 EXPECT_EQ(-large, (-large) % large2);
302 EXPECT_EQ(large, large % (-large2));
303 EXPECT_EQ(one_nano, large2 % large);
304 EXPECT_EQ(-one_nano, (-large2) % large);
305 EXPECT_EQ(one_nano, large2 % (-large));
306 // Some corner cases about negative values.
307 //
308 // (-5) / 2 = -2, remainder = -1
309 // (-5) / (-2) = 2, remainder = -1
310 a = TimeUtil::NanosecondsToDuration(-5);
311 EXPECT_EQ(TimeUtil::NanosecondsToDuration(-2), a / 2);
312 EXPECT_EQ(TimeUtil::NanosecondsToDuration(2), a / (-2));
313 b = TimeUtil::NanosecondsToDuration(2);
314 EXPECT_EQ(-2, a / b);
315 EXPECT_EQ(TimeUtil::NanosecondsToDuration(-1), a % b);
316 EXPECT_EQ(2, a / (-b));
317 EXPECT_EQ(TimeUtil::NanosecondsToDuration(-1), a % (-b));
318
319 // Test relational operators.
320 EXPECT_TRUE(one_nano < one_second);
321 EXPECT_FALSE(one_second < one_second);
322 EXPECT_FALSE(one_second < one_nano);
323 EXPECT_FALSE(-one_nano < -one_second);
324 EXPECT_FALSE(-one_second < -one_second);
325 EXPECT_TRUE(-one_second < -one_nano);
326 EXPECT_TRUE(-one_nano < one_nano);
327 EXPECT_FALSE(one_nano < -one_nano);
328
329 EXPECT_FALSE(one_nano > one_second);
330 EXPECT_FALSE(one_nano > one_nano);
331 EXPECT_TRUE(one_second > one_nano);
332
333 EXPECT_FALSE(one_nano >= one_second);
334 EXPECT_TRUE(one_nano >= one_nano);
335 EXPECT_TRUE(one_second >= one_nano);
336
337 EXPECT_TRUE(one_nano <= one_second);
338 EXPECT_TRUE(one_nano <= one_nano);
339 EXPECT_FALSE(one_second <= one_nano);
340
341 EXPECT_TRUE(one_nano == one_nano);
342 EXPECT_FALSE(one_nano == one_second);
343
344 EXPECT_FALSE(one_nano != one_nano);
345 EXPECT_TRUE(one_nano != one_second);
346 }
347
TEST(TimeUtilTest,TimestampOperators)348 TEST(TimeUtilTest, TimestampOperators) {
349 Timestamp begin, end;
350 EXPECT_TRUE(TimeUtil::FromString("0001-01-01T00:00:00Z", &begin));
351 EXPECT_TRUE(TimeUtil::FromString("9999-12-31T23:59:59.999999999Z", &end));
352 Duration d = end - begin;
353 EXPECT_TRUE(end == begin + d);
354 EXPECT_TRUE(end == d + begin);
355 EXPECT_TRUE(begin == end - d);
356
357 // Test relational operators
358 Timestamp t1 = begin + d / 4;
359 Timestamp t2 = end - d / 4;
360 EXPECT_TRUE(t1 < t2);
361 EXPECT_FALSE(t1 < t1);
362 EXPECT_FALSE(t2 < t1);
363 EXPECT_FALSE(t1 > t2);
364 EXPECT_FALSE(t1 > t1);
365 EXPECT_TRUE(t2 > t1);
366 EXPECT_FALSE(t1 >= t2);
367 EXPECT_TRUE(t1 >= t1);
368 EXPECT_TRUE(t2 >= t1);
369 EXPECT_TRUE(t1 <= t2);
370 EXPECT_TRUE(t1 <= t1);
371 EXPECT_FALSE(t2 <= t1);
372
373 EXPECT_FALSE(t1 == t2);
374 EXPECT_TRUE(t1 == t1);
375 EXPECT_FALSE(t2 == t1);
376 EXPECT_TRUE(t1 != t2);
377 EXPECT_FALSE(t1 != t1);
378 EXPECT_TRUE(t2 != t1);
379 }
380
381 } // namespace
382 } // namespace util
383 } // namespace protobuf
384 } // namespace google
385