1// Copyright 2010 The Kyua Authors. 2// All rights reserved. 3// 4// Redistribution and use in source and binary forms, with or without 5// modification, are permitted provided that the following conditions are 6// met: 7// 8// * Redistributions of source code must retain the above copyright 9// notice, this list of conditions and the following disclaimer. 10// * Redistributions in binary form must reproduce the above copyright 11// notice, this list of conditions and the following disclaimer in the 12// documentation and/or other materials provided with the distribution. 13// * Neither the name of Google Inc. nor the names of its contributors 14// may be used to endorse or promote products derived from this software 15// without specific prior written permission. 16// 17// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 20// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 21// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 22// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 23// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 27// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 29#include "utils/datetime.hpp" 30 31extern "C" { 32#include <time.h> 33#include <unistd.h> 34} 35 36#include <sstream> 37#include <stdexcept> 38 39#include <atf-c++.hpp> 40 41namespace datetime = utils::datetime; 42 43 44ATF_TEST_CASE_WITHOUT_HEAD(delta__defaults); 45ATF_TEST_CASE_BODY(delta__defaults) 46{ 47 const datetime::delta delta; 48 ATF_REQUIRE_EQ(0, delta.seconds); 49 ATF_REQUIRE_EQ(0, delta.useconds); 50} 51 52 53ATF_TEST_CASE_WITHOUT_HEAD(delta__overrides); 54ATF_TEST_CASE_BODY(delta__overrides) 55{ 56 const datetime::delta delta(1, 2); 57 ATF_REQUIRE_EQ(1, delta.seconds); 58 ATF_REQUIRE_EQ(2, delta.useconds); 59 60 ATF_REQUIRE_THROW_RE( 61 std::runtime_error, "Negative.*not supported.*-4999997us", 62 datetime::delta(-5, 3)); 63} 64 65 66ATF_TEST_CASE_WITHOUT_HEAD(delta__from_microseconds); 67ATF_TEST_CASE_BODY(delta__from_microseconds) 68{ 69 { 70 const datetime::delta delta = datetime::delta::from_microseconds(0); 71 ATF_REQUIRE_EQ(0, delta.seconds); 72 ATF_REQUIRE_EQ(0, delta.useconds); 73 } 74 { 75 const datetime::delta delta = datetime::delta::from_microseconds( 76 999999); 77 ATF_REQUIRE_EQ(0, delta.seconds); 78 ATF_REQUIRE_EQ(999999, delta.useconds); 79 } 80 { 81 const datetime::delta delta = datetime::delta::from_microseconds( 82 1000000); 83 ATF_REQUIRE_EQ(1, delta.seconds); 84 ATF_REQUIRE_EQ(0, delta.useconds); 85 } 86 { 87 const datetime::delta delta = datetime::delta::from_microseconds( 88 10576293); 89 ATF_REQUIRE_EQ(10, delta.seconds); 90 ATF_REQUIRE_EQ(576293, delta.useconds); 91 } 92 { 93 const datetime::delta delta = datetime::delta::from_microseconds( 94 123456789123456LL); 95 ATF_REQUIRE_EQ(123456789, delta.seconds); 96 ATF_REQUIRE_EQ(123456, delta.useconds); 97 } 98 99 ATF_REQUIRE_THROW_RE( 100 std::runtime_error, "Negative.*not supported.*-12345us", 101 datetime::delta::from_microseconds(-12345)); 102} 103 104 105ATF_TEST_CASE_WITHOUT_HEAD(delta__to_microseconds); 106ATF_TEST_CASE_BODY(delta__to_microseconds) 107{ 108 ATF_REQUIRE_EQ(0, datetime::delta(0, 0).to_microseconds()); 109 ATF_REQUIRE_EQ(999999, datetime::delta(0, 999999).to_microseconds()); 110 ATF_REQUIRE_EQ(1000000, datetime::delta(1, 0).to_microseconds()); 111 ATF_REQUIRE_EQ(10576293, datetime::delta(10, 576293).to_microseconds()); 112 ATF_REQUIRE_EQ(11576293, datetime::delta(10, 1576293).to_microseconds()); 113} 114 115 116ATF_TEST_CASE_WITHOUT_HEAD(delta__equals); 117ATF_TEST_CASE_BODY(delta__equals) 118{ 119 ATF_REQUIRE(datetime::delta() == datetime::delta()); 120 ATF_REQUIRE(datetime::delta() == datetime::delta(0, 0)); 121 ATF_REQUIRE(datetime::delta(1, 2) == datetime::delta(1, 2)); 122 123 ATF_REQUIRE(!(datetime::delta() == datetime::delta(0, 1))); 124 ATF_REQUIRE(!(datetime::delta() == datetime::delta(1, 0))); 125 ATF_REQUIRE(!(datetime::delta(1, 2) == datetime::delta(2, 1))); 126} 127 128 129ATF_TEST_CASE_WITHOUT_HEAD(delta__differs); 130ATF_TEST_CASE_BODY(delta__differs) 131{ 132 ATF_REQUIRE(!(datetime::delta() != datetime::delta())); 133 ATF_REQUIRE(!(datetime::delta() != datetime::delta(0, 0))); 134 ATF_REQUIRE(!(datetime::delta(1, 2) != datetime::delta(1, 2))); 135 136 ATF_REQUIRE(datetime::delta() != datetime::delta(0, 1)); 137 ATF_REQUIRE(datetime::delta() != datetime::delta(1, 0)); 138 ATF_REQUIRE(datetime::delta(1, 2) != datetime::delta(2, 1)); 139} 140 141 142ATF_TEST_CASE_WITHOUT_HEAD(delta__sorting); 143ATF_TEST_CASE_BODY(delta__sorting) 144{ 145 ATF_REQUIRE(!(datetime::delta() < datetime::delta())); 146 ATF_REQUIRE( datetime::delta() <= datetime::delta()); 147 ATF_REQUIRE(!(datetime::delta() > datetime::delta())); 148 ATF_REQUIRE( datetime::delta() >= datetime::delta()); 149 150 ATF_REQUIRE(!(datetime::delta(9, 8) < datetime::delta(9, 8))); 151 ATF_REQUIRE( datetime::delta(9, 8) <= datetime::delta(9, 8)); 152 ATF_REQUIRE(!(datetime::delta(9, 8) > datetime::delta(9, 8))); 153 ATF_REQUIRE( datetime::delta(9, 8) >= datetime::delta(9, 8)); 154 155 ATF_REQUIRE( datetime::delta(2, 5) < datetime::delta(4, 8)); 156 ATF_REQUIRE( datetime::delta(2, 5) <= datetime::delta(4, 8)); 157 ATF_REQUIRE(!(datetime::delta(2, 5) > datetime::delta(4, 8))); 158 ATF_REQUIRE(!(datetime::delta(2, 5) >= datetime::delta(4, 8))); 159 160 ATF_REQUIRE( datetime::delta(2, 5) < datetime::delta(2, 8)); 161 ATF_REQUIRE( datetime::delta(2, 5) <= datetime::delta(2, 8)); 162 ATF_REQUIRE(!(datetime::delta(2, 5) > datetime::delta(2, 8))); 163 ATF_REQUIRE(!(datetime::delta(2, 5) >= datetime::delta(2, 8))); 164 165 ATF_REQUIRE(!(datetime::delta(4, 8) < datetime::delta(2, 5))); 166 ATF_REQUIRE(!(datetime::delta(4, 8) <= datetime::delta(2, 5))); 167 ATF_REQUIRE( datetime::delta(4, 8) > datetime::delta(2, 5)); 168 ATF_REQUIRE( datetime::delta(4, 8) >= datetime::delta(2, 5)); 169 170 ATF_REQUIRE(!(datetime::delta(2, 8) < datetime::delta(2, 5))); 171 ATF_REQUIRE(!(datetime::delta(2, 8) <= datetime::delta(2, 5))); 172 ATF_REQUIRE( datetime::delta(2, 8) > datetime::delta(2, 5)); 173 ATF_REQUIRE( datetime::delta(2, 8) >= datetime::delta(2, 5)); 174} 175 176 177ATF_TEST_CASE_WITHOUT_HEAD(delta__addition); 178ATF_TEST_CASE_BODY(delta__addition) 179{ 180 using datetime::delta; 181 182 ATF_REQUIRE_EQ(delta(), delta() + delta()); 183 ATF_REQUIRE_EQ(delta(0, 10), delta() + delta(0, 10)); 184 ATF_REQUIRE_EQ(delta(10, 0), delta(10, 0) + delta()); 185 186 ATF_REQUIRE_EQ(delta(1, 234567), delta(0, 1234567) + delta()); 187 ATF_REQUIRE_EQ(delta(12, 34), delta(10, 20) + delta(2, 14)); 188} 189 190 191ATF_TEST_CASE_WITHOUT_HEAD(delta__addition_and_set); 192ATF_TEST_CASE_BODY(delta__addition_and_set) 193{ 194 using datetime::delta; 195 196 { 197 delta d; 198 d += delta(3, 5); 199 ATF_REQUIRE_EQ(delta(3, 5), d); 200 } 201 { 202 delta d(1, 2); 203 d += delta(3, 5); 204 ATF_REQUIRE_EQ(delta(4, 7), d); 205 } 206 { 207 delta d(1, 2); 208 ATF_REQUIRE_EQ(delta(4, 7), (d += delta(3, 5))); 209 } 210} 211 212 213ATF_TEST_CASE_WITHOUT_HEAD(delta__scale); 214ATF_TEST_CASE_BODY(delta__scale) 215{ 216 using datetime::delta; 217 218 ATF_REQUIRE_EQ(delta(), delta() * 0); 219 ATF_REQUIRE_EQ(delta(), delta() * 5); 220 221 ATF_REQUIRE_EQ(delta(0, 30), delta(0, 10) * 3); 222 ATF_REQUIRE_EQ(delta(17, 500000), delta(3, 500000) * 5); 223} 224 225 226ATF_TEST_CASE_WITHOUT_HEAD(delta__scale_and_set); 227ATF_TEST_CASE_BODY(delta__scale_and_set) 228{ 229 using datetime::delta; 230 231 { 232 delta d(3, 5); 233 d *= 2; 234 ATF_REQUIRE_EQ(delta(6, 10), d); 235 } 236 { 237 delta d(8, 0); 238 d *= 8; 239 ATF_REQUIRE_EQ(delta(64, 0), d); 240 } 241 { 242 delta d(3, 5); 243 ATF_REQUIRE_EQ(delta(9, 15), (d *= 3)); 244 } 245} 246 247 248ATF_TEST_CASE_WITHOUT_HEAD(delta__output); 249ATF_TEST_CASE_BODY(delta__output) 250{ 251 { 252 std::ostringstream str; 253 str << datetime::delta(15, 8791); 254 ATF_REQUIRE_EQ("15008791us", str.str()); 255 } 256 { 257 std::ostringstream str; 258 str << datetime::delta(12345678, 0); 259 ATF_REQUIRE_EQ("12345678000000us", str.str()); 260 } 261} 262 263 264ATF_TEST_CASE_WITHOUT_HEAD(timestamp__copy); 265ATF_TEST_CASE_BODY(timestamp__copy) 266{ 267 const datetime::timestamp ts1 = datetime::timestamp::from_values( 268 2011, 2, 16, 19, 15, 30, 0); 269 { 270 const datetime::timestamp ts2 = ts1; 271 const datetime::timestamp ts3 = datetime::timestamp::from_values( 272 2012, 2, 16, 19, 15, 30, 0); 273 ATF_REQUIRE_EQ("2011", ts1.strftime("%Y")); 274 ATF_REQUIRE_EQ("2011", ts2.strftime("%Y")); 275 ATF_REQUIRE_EQ("2012", ts3.strftime("%Y")); 276 } 277 ATF_REQUIRE_EQ("2011", ts1.strftime("%Y")); 278} 279 280 281ATF_TEST_CASE_WITHOUT_HEAD(timestamp__from_microseconds); 282ATF_TEST_CASE_BODY(timestamp__from_microseconds) 283{ 284 const datetime::timestamp ts = datetime::timestamp::from_microseconds( 285 1328829351987654LL); 286 ATF_REQUIRE_EQ("2012-02-09 23:15:51", ts.strftime("%Y-%m-%d %H:%M:%S")); 287 ATF_REQUIRE_EQ(1328829351987654LL, ts.to_microseconds()); 288 ATF_REQUIRE_EQ(1328829351, ts.to_seconds()); 289} 290 291 292ATF_TEST_CASE_WITHOUT_HEAD(timestamp__now__mock); 293ATF_TEST_CASE_BODY(timestamp__now__mock) 294{ 295 datetime::set_mock_now(2011, 2, 21, 18, 5, 10, 0); 296 ATF_REQUIRE_EQ("2011-02-21 18:05:10", 297 datetime::timestamp::now().strftime("%Y-%m-%d %H:%M:%S")); 298 299 datetime::set_mock_now(datetime::timestamp::from_values( 300 2012, 3, 22, 19, 6, 11, 54321)); 301 ATF_REQUIRE_EQ("2012-03-22 19:06:11", 302 datetime::timestamp::now().strftime("%Y-%m-%d %H:%M:%S")); 303 ATF_REQUIRE_EQ("2012-03-22 19:06:11", 304 datetime::timestamp::now().strftime("%Y-%m-%d %H:%M:%S")); 305} 306 307 308ATF_TEST_CASE_WITHOUT_HEAD(timestamp__now__real); 309ATF_TEST_CASE_BODY(timestamp__now__real) 310{ 311 // This test is might fail if we happen to run at the crossing of one 312 // day to the other and the two measures we pick of the current time 313 // differ. This is so unlikely that I haven't bothered to do this in any 314 // other way. 315 316 const time_t just_before = ::time(NULL); 317 const datetime::timestamp now = datetime::timestamp::now(); 318 319 ::tm data; 320 char buf[1024]; 321 ATF_REQUIRE(::gmtime_r(&just_before, &data) != 0); 322 ATF_REQUIRE(::strftime(buf, sizeof(buf), "%Y-%m-%d", &data) != 0); 323 ATF_REQUIRE_EQ(buf, now.strftime("%Y-%m-%d")); 324 325 ATF_REQUIRE(now.strftime("%Z") == "GMT" || now.strftime("%Z") == "UTC"); 326} 327 328 329ATF_TEST_CASE_WITHOUT_HEAD(timestamp__now__granularity); 330ATF_TEST_CASE_BODY(timestamp__now__granularity) 331{ 332 const datetime::timestamp first = datetime::timestamp::now(); 333 ::usleep(1); 334 const datetime::timestamp second = datetime::timestamp::now(); 335 ATF_REQUIRE(first.to_microseconds() != second.to_microseconds()); 336} 337 338 339ATF_TEST_CASE_WITHOUT_HEAD(timestamp__strftime); 340ATF_TEST_CASE_BODY(timestamp__strftime) 341{ 342 const datetime::timestamp ts1 = datetime::timestamp::from_values( 343 2010, 12, 10, 8, 45, 50, 0); 344 ATF_REQUIRE_EQ("2010-12-10", ts1.strftime("%Y-%m-%d")); 345 ATF_REQUIRE_EQ("08:45:50", ts1.strftime("%H:%M:%S")); 346 347 const datetime::timestamp ts2 = datetime::timestamp::from_values( 348 2011, 2, 16, 19, 15, 30, 0); 349 ATF_REQUIRE_EQ("2011-02-16T19:15:30", ts2.strftime("%Y-%m-%dT%H:%M:%S")); 350} 351 352 353ATF_TEST_CASE_WITHOUT_HEAD(timestamp__to_iso8601_in_utc); 354ATF_TEST_CASE_BODY(timestamp__to_iso8601_in_utc) 355{ 356 const datetime::timestamp ts1 = datetime::timestamp::from_values( 357 2010, 12, 10, 8, 45, 50, 0); 358 ATF_REQUIRE_EQ("2010-12-10T08:45:50.000000Z", ts1.to_iso8601_in_utc()); 359 360 const datetime::timestamp ts2= datetime::timestamp::from_values( 361 2016, 7, 11, 17, 51, 28, 123456); 362 ATF_REQUIRE_EQ("2016-07-11T17:51:28.123456Z", ts2.to_iso8601_in_utc()); 363} 364 365 366ATF_TEST_CASE_WITHOUT_HEAD(timestamp__to_microseconds); 367ATF_TEST_CASE_BODY(timestamp__to_microseconds) 368{ 369 const datetime::timestamp ts1 = datetime::timestamp::from_values( 370 2010, 12, 10, 8, 45, 50, 123456); 371 ATF_REQUIRE_EQ(1291970750123456LL, ts1.to_microseconds()); 372} 373 374 375ATF_TEST_CASE_WITHOUT_HEAD(timestamp__to_seconds); 376ATF_TEST_CASE_BODY(timestamp__to_seconds) 377{ 378 const datetime::timestamp ts1 = datetime::timestamp::from_values( 379 2010, 12, 10, 8, 45, 50, 123456); 380 ATF_REQUIRE_EQ(1291970750, ts1.to_seconds()); 381} 382 383 384ATF_TEST_CASE_WITHOUT_HEAD(timestamp__leap_second); 385ATF_TEST_CASE_BODY(timestamp__leap_second) 386{ 387 // This is actually a test for from_values(), which is the function that 388 // includes assertions to validate the input parameters. 389 const datetime::timestamp ts1 = datetime::timestamp::from_values( 390 2012, 6, 30, 23, 59, 60, 543); 391 ATF_REQUIRE_EQ(1341100800, ts1.to_seconds()); 392} 393 394 395ATF_TEST_CASE_WITHOUT_HEAD(timestamp__equals); 396ATF_TEST_CASE_BODY(timestamp__equals) 397{ 398 ATF_REQUIRE(datetime::timestamp::from_microseconds(1291970750123456LL) == 399 datetime::timestamp::from_microseconds(1291970750123456LL)); 400} 401 402 403ATF_TEST_CASE_WITHOUT_HEAD(timestamp__differs); 404ATF_TEST_CASE_BODY(timestamp__differs) 405{ 406 ATF_REQUIRE(datetime::timestamp::from_microseconds(1291970750123456LL) != 407 datetime::timestamp::from_microseconds(1291970750123455LL)); 408} 409 410 411ATF_TEST_CASE_WITHOUT_HEAD(timestamp__sorting); 412ATF_TEST_CASE_BODY(timestamp__sorting) 413{ 414 { 415 const datetime::timestamp ts1 = datetime::timestamp::from_microseconds( 416 1291970750123455LL); 417 const datetime::timestamp ts2 = datetime::timestamp::from_microseconds( 418 1291970750123455LL); 419 420 ATF_REQUIRE(!(ts1 < ts2)); 421 ATF_REQUIRE( ts1 <= ts2); 422 ATF_REQUIRE(!(ts1 > ts2)); 423 ATF_REQUIRE( ts1 >= ts2); 424 } 425 { 426 const datetime::timestamp ts1 = datetime::timestamp::from_microseconds( 427 1291970750123455LL); 428 const datetime::timestamp ts2 = datetime::timestamp::from_microseconds( 429 1291970759123455LL); 430 431 ATF_REQUIRE( ts1 < ts2); 432 ATF_REQUIRE( ts1 <= ts2); 433 ATF_REQUIRE(!(ts1 > ts2)); 434 ATF_REQUIRE(!(ts1 >= ts2)); 435 } 436 { 437 const datetime::timestamp ts1 = datetime::timestamp::from_microseconds( 438 1291970759123455LL); 439 const datetime::timestamp ts2 = datetime::timestamp::from_microseconds( 440 1291970750123455LL); 441 442 ATF_REQUIRE(!(ts1 < ts2)); 443 ATF_REQUIRE(!(ts1 <= ts2)); 444 ATF_REQUIRE( ts1 > ts2); 445 ATF_REQUIRE( ts1 >= ts2); 446 } 447} 448 449 450ATF_TEST_CASE_WITHOUT_HEAD(timestamp__add_delta); 451ATF_TEST_CASE_BODY(timestamp__add_delta) 452{ 453 using datetime::delta; 454 using datetime::timestamp; 455 456 ATF_REQUIRE_EQ(timestamp::from_values(2014, 12, 11, 21, 43, 30, 1234), 457 timestamp::from_values(2014, 12, 11, 21, 43, 0, 0) + 458 delta(30, 1234)); 459 ATF_REQUIRE_EQ(timestamp::from_values(2014, 12, 11, 22, 43, 7, 100), 460 timestamp::from_values(2014, 12, 11, 21, 43, 0, 0) + 461 delta(3602, 5000100)); 462} 463 464 465ATF_TEST_CASE_WITHOUT_HEAD(timestamp__add_delta_and_set); 466ATF_TEST_CASE_BODY(timestamp__add_delta_and_set) 467{ 468 using datetime::delta; 469 using datetime::timestamp; 470 471 { 472 timestamp ts = timestamp::from_values(2014, 12, 11, 21, 43, 0, 0); 473 ts += delta(30, 1234); 474 ATF_REQUIRE_EQ(timestamp::from_values(2014, 12, 11, 21, 43, 30, 1234), 475 ts); 476 } 477 { 478 timestamp ts = timestamp::from_values(2014, 12, 11, 21, 43, 0, 0); 479 ATF_REQUIRE_EQ(timestamp::from_values(2014, 12, 11, 22, 43, 7, 100), 480 ts += delta(3602, 5000100)); 481 } 482} 483 484 485ATF_TEST_CASE_WITHOUT_HEAD(timestamp__subtract_delta); 486ATF_TEST_CASE_BODY(timestamp__subtract_delta) 487{ 488 using datetime::delta; 489 using datetime::timestamp; 490 491 ATF_REQUIRE_EQ(timestamp::from_values(2014, 12, 11, 21, 43, 10, 4321), 492 timestamp::from_values(2014, 12, 11, 21, 43, 40, 5555) - 493 delta(30, 1234)); 494 ATF_REQUIRE_EQ(timestamp::from_values(2014, 12, 11, 20, 43, 1, 300), 495 timestamp::from_values(2014, 12, 11, 21, 43, 8, 400) - 496 delta(3602, 5000100)); 497} 498 499 500ATF_TEST_CASE_WITHOUT_HEAD(timestamp__subtract_delta_and_set); 501ATF_TEST_CASE_BODY(timestamp__subtract_delta_and_set) 502{ 503 using datetime::delta; 504 using datetime::timestamp; 505 506 { 507 timestamp ts = timestamp::from_values(2014, 12, 11, 21, 43, 40, 5555); 508 ts -= delta(30, 1234); 509 ATF_REQUIRE_EQ(timestamp::from_values(2014, 12, 11, 21, 43, 10, 4321), 510 ts); 511 } 512 { 513 timestamp ts = timestamp::from_values(2014, 12, 11, 21, 43, 8, 400); 514 ATF_REQUIRE_EQ(timestamp::from_values(2014, 12, 11, 20, 43, 1, 300), 515 ts -= delta(3602, 5000100)); 516 } 517} 518 519 520ATF_TEST_CASE_WITHOUT_HEAD(timestamp__subtraction); 521ATF_TEST_CASE_BODY(timestamp__subtraction) 522{ 523 const datetime::timestamp ts1 = datetime::timestamp::from_microseconds( 524 1291970750123456LL); 525 const datetime::timestamp ts2 = datetime::timestamp::from_microseconds( 526 1291970750123468LL); 527 const datetime::timestamp ts3 = datetime::timestamp::from_microseconds( 528 1291970850123456LL); 529 530 ATF_REQUIRE_EQ(datetime::delta(0, 0), ts1 - ts1); 531 ATF_REQUIRE_EQ(datetime::delta(0, 12), ts2 - ts1); 532 ATF_REQUIRE_EQ(datetime::delta(100, 0), ts3 - ts1); 533 ATF_REQUIRE_EQ(datetime::delta(99, 999988), ts3 - ts2); 534 535 /* 536 * NOTE (ngie): behavior change for 537 * https://github.com/jmmv/kyua/issues/155 . 538 */ 539 ATF_REQUIRE_EQ(datetime::delta::from_microseconds(1), ts2 - ts3); 540} 541 542 543ATF_TEST_CASE_WITHOUT_HEAD(timestamp__output); 544ATF_TEST_CASE_BODY(timestamp__output) 545{ 546 { 547 std::ostringstream str; 548 str << datetime::timestamp::from_microseconds(1291970750123456LL); 549 ATF_REQUIRE_EQ("1291970750123456us", str.str()); 550 } 551 { 552 std::ostringstream str; 553 str << datetime::timestamp::from_microseconds(1028309798759812LL); 554 ATF_REQUIRE_EQ("1028309798759812us", str.str()); 555 } 556} 557 558 559ATF_INIT_TEST_CASES(tcs) 560{ 561 ATF_ADD_TEST_CASE(tcs, delta__defaults); 562 ATF_ADD_TEST_CASE(tcs, delta__overrides); 563 ATF_ADD_TEST_CASE(tcs, delta__from_microseconds); 564 ATF_ADD_TEST_CASE(tcs, delta__to_microseconds); 565 ATF_ADD_TEST_CASE(tcs, delta__equals); 566 ATF_ADD_TEST_CASE(tcs, delta__differs); 567 ATF_ADD_TEST_CASE(tcs, delta__sorting); 568 ATF_ADD_TEST_CASE(tcs, delta__addition); 569 ATF_ADD_TEST_CASE(tcs, delta__addition_and_set); 570 ATF_ADD_TEST_CASE(tcs, delta__scale); 571 ATF_ADD_TEST_CASE(tcs, delta__scale_and_set); 572 ATF_ADD_TEST_CASE(tcs, delta__output); 573 574 ATF_ADD_TEST_CASE(tcs, timestamp__copy); 575 ATF_ADD_TEST_CASE(tcs, timestamp__from_microseconds); 576 ATF_ADD_TEST_CASE(tcs, timestamp__now__mock); 577 ATF_ADD_TEST_CASE(tcs, timestamp__now__real); 578 ATF_ADD_TEST_CASE(tcs, timestamp__now__granularity); 579 ATF_ADD_TEST_CASE(tcs, timestamp__strftime); 580 ATF_ADD_TEST_CASE(tcs, timestamp__to_iso8601_in_utc); 581 ATF_ADD_TEST_CASE(tcs, timestamp__to_microseconds); 582 ATF_ADD_TEST_CASE(tcs, timestamp__to_seconds); 583 ATF_ADD_TEST_CASE(tcs, timestamp__leap_second); 584 ATF_ADD_TEST_CASE(tcs, timestamp__equals); 585 ATF_ADD_TEST_CASE(tcs, timestamp__differs); 586 ATF_ADD_TEST_CASE(tcs, timestamp__sorting); 587 ATF_ADD_TEST_CASE(tcs, timestamp__add_delta); 588 ATF_ADD_TEST_CASE(tcs, timestamp__add_delta_and_set); 589 ATF_ADD_TEST_CASE(tcs, timestamp__subtract_delta); 590 ATF_ADD_TEST_CASE(tcs, timestamp__subtract_delta_and_set); 591 ATF_ADD_TEST_CASE(tcs, timestamp__subtraction); 592 ATF_ADD_TEST_CASE(tcs, timestamp__output); 593} 594