external/bsd/kyua-cli/dist/utils/datetime_test.cpp

   1 // Copyright 2010 Google Inc.
   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
  31 extern "C" {
  32 #include <time.h>
  33 #include <unistd.h>
  34 }
  35
  36 #include <sstream>
  37
  38 #include <atf-c++.hpp>
  39
  40 namespace datetime = utils::datetime;
  41
  42
  43 ATF_TEST_CASE_WITHOUT_HEAD(delta__defaults);
  44 ATF_TEST_CASE_BODY(delta__defaults)
  45 {
  46     const datetime::delta delta;
  47     ATF_REQUIRE_EQ(0, delta.seconds);
  48     ATF_REQUIRE_EQ(0, delta.useconds);
  49 }
  50
  51
  52 ATF_TEST_CASE_WITHOUT_HEAD(delta__overrides);
  53 ATF_TEST_CASE_BODY(delta__overrides)
  54 {
  55     const datetime::delta delta(1, 2);
  56     ATF_REQUIRE_EQ(1, delta.seconds);
  57     ATF_REQUIRE_EQ(2, delta.useconds);
  58 }
  59
  60
  61 ATF_TEST_CASE_WITHOUT_HEAD(delta__from_microseconds);
  62 ATF_TEST_CASE_BODY(delta__from_microseconds)
  63 {
  64     {
  65         const datetime::delta delta = datetime::delta::from_microseconds(0);
  66         ATF_REQUIRE_EQ(0, delta.seconds);
  67         ATF_REQUIRE_EQ(0, delta.useconds);
  68     }
  69     {
  70         const datetime::delta delta = datetime::delta::from_microseconds(
  71             999999);
  72         ATF_REQUIRE_EQ(0, delta.seconds);
  73         ATF_REQUIRE_EQ(999999, delta.useconds);
  74     }
  75     {
  76         const datetime::delta delta = datetime::delta::from_microseconds(
  77             1000000);
  78         ATF_REQUIRE_EQ(1, delta.seconds);
  79         ATF_REQUIRE_EQ(0, delta.useconds);
  80     }
  81     {
  82         const datetime::delta delta = datetime::delta::from_microseconds(
  83             10576293);
  84         ATF_REQUIRE_EQ(10, delta.seconds);
  85         ATF_REQUIRE_EQ(576293, delta.useconds);
  86     }
  87     {
  88         const datetime::delta delta = datetime::delta::from_microseconds(
  89             123456789123456);
  90         ATF_REQUIRE_EQ(123456789, delta.seconds);
  91         ATF_REQUIRE_EQ(123456, delta.useconds);
  92     }
  93 }
  94
  95
  96 ATF_TEST_CASE_WITHOUT_HEAD(delta__to_microseconds);
  97 ATF_TEST_CASE_BODY(delta__to_microseconds)
  98 {
  99     ATF_REQUIRE_EQ(0, datetime::delta(0, 0).to_microseconds());
 100     ATF_REQUIRE_EQ(999999, datetime::delta(0, 999999).to_microseconds());
 101     ATF_REQUIRE_EQ(1000000, datetime::delta(1, 0).to_microseconds());
 102     ATF_REQUIRE_EQ(10576293, datetime::delta(10, 576293).to_microseconds());
 103     ATF_REQUIRE_EQ(11576293, datetime::delta(10, 1576293).to_microseconds());
 104 }
 105
 106
 107 ATF_TEST_CASE_WITHOUT_HEAD(delta__equals);
 108 ATF_TEST_CASE_BODY(delta__equals)
 109 {
 110     ATF_REQUIRE(datetime::delta() == datetime::delta());
 111     ATF_REQUIRE(datetime::delta() == datetime::delta(0, 0));
 112     ATF_REQUIRE(datetime::delta(1, 2) == datetime::delta(1, 2));
 113
 114     ATF_REQUIRE(!(datetime::delta() == datetime::delta(0, 1)));
 115     ATF_REQUIRE(!(datetime::delta() == datetime::delta(1, 0)));
 116     ATF_REQUIRE(!(datetime::delta(1, 2) == datetime::delta(2, 1)));
 117 }
 118
 119
 120 ATF_TEST_CASE_WITHOUT_HEAD(delta__differs);
 121 ATF_TEST_CASE_BODY(delta__differs)
 122 {
 123     ATF_REQUIRE(!(datetime::delta() != datetime::delta()));
 124     ATF_REQUIRE(!(datetime::delta() != datetime::delta(0, 0)));
 125     ATF_REQUIRE(!(datetime::delta(1, 2) != datetime::delta(1, 2)));
 126
 127     ATF_REQUIRE(datetime::delta() != datetime::delta(0, 1));
 128     ATF_REQUIRE(datetime::delta() != datetime::delta(1, 0));
 129     ATF_REQUIRE(datetime::delta(1, 2) != datetime::delta(2, 1));
 130 }
 131
 132
 133 ATF_TEST_CASE_WITHOUT_HEAD(delta__addition);
 134 ATF_TEST_CASE_BODY(delta__addition)
 135 {
 136     using datetime::delta;
 137
 138     ATF_REQUIRE(delta() == delta() + delta());
 139     ATF_REQUIRE(delta(0, 10) == delta() + delta(0, 10));
 140     ATF_REQUIRE(delta(10, 0) == delta(10, 0) + delta());
 141
 142     ATF_REQUIRE(delta(1, 234567) == delta(0, 1234567) + delta());
 143     ATF_REQUIRE(delta(12, 34) == delta(10, 20) + delta(2, 14));
 144 }
 145
 146
 147 ATF_TEST_CASE_WITHOUT_HEAD(delta__addition_and_set);
 148 ATF_TEST_CASE_BODY(delta__addition_and_set)
 149 {
 150     using datetime::delta;
 151
 152     {
 153         delta d;
 154         d += delta(3, 5);
 155         ATF_REQUIRE(delta(3, 5) == d);
 156     }
 157     {
 158         delta d(1, 2);
 159         d += delta(3, 5);
 160         ATF_REQUIRE(delta(4, 7) == d);
 161     }
 162     {
 163         delta d(1, 2);
 164         ATF_REQUIRE(delta(4, 7) == (d += delta(3, 5)));
 165     }
 166 }
 167
 168
 169 ATF_TEST_CASE_WITHOUT_HEAD(delta__output);
 170 ATF_TEST_CASE_BODY(delta__output)
 171 {
 172     {
 173         std::ostringstream str;
 174         str << datetime::delta(15, 8791);
 175         ATF_REQUIRE_EQ("15008791us", str.str());
 176     }
 177     {
 178         std::ostringstream str;
 179         str << datetime::delta(12345678, 0);
 180         ATF_REQUIRE_EQ("12345678000000us", str.str());
 181     }
 182 }
 183
 184
 185 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__copy);
 186 ATF_TEST_CASE_BODY(timestamp__copy)
 187 {
 188     const datetime::timestamp ts1 = datetime::timestamp::from_values(
 189         2011, 2, 16, 19, 15, 30, 0);
 190     {
 191         const datetime::timestamp ts2 = ts1;
 192         const datetime::timestamp ts3 = datetime::timestamp::from_values(
 193             2012, 2, 16, 19, 15, 30, 0);
 194         ATF_REQUIRE_EQ("2011", ts1.strftime("%Y"));
 195         ATF_REQUIRE_EQ("2011", ts2.strftime("%Y"));
 196         ATF_REQUIRE_EQ("2012", ts3.strftime("%Y"));
 197     }
 198     ATF_REQUIRE_EQ("2011", ts1.strftime("%Y"));
 199 }
 200
 201
 202 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__from_microseconds);
 203 ATF_TEST_CASE_BODY(timestamp__from_microseconds)
 204 {
 205     const datetime::timestamp ts = datetime::timestamp::from_microseconds(
 206         1328829351987654LL);
 207     ATF_REQUIRE_EQ("2012-02-09 23:15:51", ts.strftime("%Y-%m-%d %H:%M:%S"));
 208     ATF_REQUIRE_EQ(1328829351987654LL, ts.to_microseconds());
 209     ATF_REQUIRE_EQ(1328829351, ts.to_seconds());
 210 }
 211
 212
 213 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__now__mock);
 214 ATF_TEST_CASE_BODY(timestamp__now__mock)
 215 {
 216     datetime::set_mock_now(2011, 2, 21, 18, 5, 10, 0);
 217     ATF_REQUIRE_EQ("2011-02-21 18:05:10",
 218                    datetime::timestamp::now().strftime("%Y-%m-%d %H:%M:%S"));
 219
 220     datetime::set_mock_now(2012, 3, 22, 19, 6, 11, 54321);
 221     ATF_REQUIRE_EQ("2012-03-22 19:06:11",
 222                    datetime::timestamp::now().strftime("%Y-%m-%d %H:%M:%S"));
 223     ATF_REQUIRE_EQ("2012-03-22 19:06:11",
 224                    datetime::timestamp::now().strftime("%Y-%m-%d %H:%M:%S"));
 225 }
 226
 227
 228 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__now__real);
 229 ATF_TEST_CASE_BODY(timestamp__now__real)
 230 {
 231     // This test is might fail if we happen to run at the crossing of one
 232     // day to the other and the two measures we pick of the current time
 233     // differ.  This is so unlikely that I haven't bothered to do this in any
 234     // other way.
 235
 236     const time_t just_before = ::time(NULL);
 237     const datetime::timestamp now = datetime::timestamp::now();
 238
 239     ::tm data;
 240     char buf[1024];
 241     ATF_REQUIRE(::gmtime_r(&just_before, &data) != 0);
 242     ATF_REQUIRE(::strftime(buf, sizeof(buf), "%Y-%m-%d", &data) != 0);
 243     ATF_REQUIRE_EQ(buf, now.strftime("%Y-%m-%d"));
 244
 245     ATF_REQUIRE(now.strftime("%Z") == "GMT" || now.strftime("%Z") == "UTC");
 246 }
 247
 248
 249 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__now__granularity);
 250 ATF_TEST_CASE_BODY(timestamp__now__granularity)
 251 {
 252     const datetime::timestamp first = datetime::timestamp::now();
 253     ::usleep(1);
 254     const datetime::timestamp second = datetime::timestamp::now();
 255     ATF_REQUIRE(first.to_microseconds() != second.to_microseconds());
 256 }
 257
 258
 259 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__strftime);
 260 ATF_TEST_CASE_BODY(timestamp__strftime)
 261 {
 262     const datetime::timestamp ts1 = datetime::timestamp::from_values(
 263         2010, 12, 10, 8, 45, 50, 0);
 264     ATF_REQUIRE_EQ("2010-12-10", ts1.strftime("%Y-%m-%d"));
 265     ATF_REQUIRE_EQ("08:45:50", ts1.strftime("%H:%M:%S"));
 266
 267     const datetime::timestamp ts2 = datetime::timestamp::from_values(
 268         2011, 2, 16, 19, 15, 30, 0);
 269     ATF_REQUIRE_EQ("2011-02-16T19:15:30", ts2.strftime("%Y-%m-%dT%H:%M:%S"));
 270 }
 271
 272
 273 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__to_microseconds);
 274 ATF_TEST_CASE_BODY(timestamp__to_microseconds)
 275 {
 276     const datetime::timestamp ts1 = datetime::timestamp::from_values(
 277         2010, 12, 10, 8, 45, 50, 123456);
 278     ATF_REQUIRE_EQ(1291970750123456LL, ts1.to_microseconds());
 279 }
 280
 281
 282 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__to_seconds);
 283 ATF_TEST_CASE_BODY(timestamp__to_seconds)
 284 {
 285     const datetime::timestamp ts1 = datetime::timestamp::from_values(
 286         2010, 12, 10, 8, 45, 50, 123456);
 287     ATF_REQUIRE_EQ(1291970750, ts1.to_seconds());
 288 }
 289
 290
 291 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__leap_second);
 292 ATF_TEST_CASE_BODY(timestamp__leap_second)
 293 {
 294     // This is actually a test for from_values(), which is the function that
 295     // includes assertions to validate the input parameters.
 296     const datetime::timestamp ts1 = datetime::timestamp::from_values(
 297         2012, 6, 30, 23, 59, 60, 543);
 298     ATF_REQUIRE_EQ(1341100800, ts1.to_seconds());
 299 }
 300
 301
 302 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__equals);
 303 ATF_TEST_CASE_BODY(timestamp__equals)
 304 {
 305     ATF_REQUIRE(datetime::timestamp::from_microseconds(1291970750123456LL) ==
 306                 datetime::timestamp::from_microseconds(1291970750123456LL));
 307 }
 308
 309
 310 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__differs);
 311 ATF_TEST_CASE_BODY(timestamp__differs)
 312 {
 313     ATF_REQUIRE(datetime::timestamp::from_microseconds(1291970750123456LL) !=
 314                 datetime::timestamp::from_microseconds(1291970750123455LL));
 315 }
 316
 317
 318 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__subtraction);
 319 ATF_TEST_CASE_BODY(timestamp__subtraction)
 320 {
 321     const datetime::timestamp ts1 = datetime::timestamp::from_microseconds(
 322         1291970750123456LL);
 323     const datetime::timestamp ts2 = datetime::timestamp::from_microseconds(
 324         1291970750123468LL);
 325     const datetime::timestamp ts3 = datetime::timestamp::from_microseconds(
 326         1291970850123456LL);
 327
 328     ATF_REQUIRE(datetime::delta(0, 0) == ts1 - ts1);
 329     ATF_REQUIRE(datetime::delta(0, 12) == ts2 - ts1);
 330     ATF_REQUIRE(datetime::delta(100, 0) == ts3 - ts1);
 331     ATF_REQUIRE(datetime::delta(99, 999988) == ts3 - ts2);
 332 }
 333
 334
 335 ATF_TEST_CASE_WITHOUT_HEAD(timestamp__output);
 336 ATF_TEST_CASE_BODY(timestamp__output)
 337 {
 338     {
 339         std::ostringstream str;
 340         str << datetime::timestamp::from_microseconds(1291970750123456LL);
 341         ATF_REQUIRE_EQ("1291970750123456us", str.str());
 342     }
 343     {
 344         std::ostringstream str;
 345         str << datetime::timestamp::from_microseconds(1028309798759812LL);
 346         ATF_REQUIRE_EQ("1028309798759812us", str.str());
 347     }
 348 }
 349
 350
 351 ATF_INIT_TEST_CASES(tcs)
 352 {
 353     ATF_ADD_TEST_CASE(tcs, delta__defaults);
 354     ATF_ADD_TEST_CASE(tcs, delta__overrides);
 355     ATF_ADD_TEST_CASE(tcs, delta__from_microseconds);
 356     ATF_ADD_TEST_CASE(tcs, delta__to_microseconds);
 357     ATF_ADD_TEST_CASE(tcs, delta__equals);
 358     ATF_ADD_TEST_CASE(tcs, delta__differs);
 359     ATF_ADD_TEST_CASE(tcs, delta__addition);
 360     ATF_ADD_TEST_CASE(tcs, delta__addition_and_set);
 361     ATF_ADD_TEST_CASE(tcs, delta__output);
 362
 363     ATF_ADD_TEST_CASE(tcs, timestamp__copy);
 364     ATF_ADD_TEST_CASE(tcs, timestamp__from_microseconds);
 365     ATF_ADD_TEST_CASE(tcs, timestamp__now__mock);
 366     ATF_ADD_TEST_CASE(tcs, timestamp__now__real);
 367     ATF_ADD_TEST_CASE(tcs, timestamp__now__granularity);
 368     ATF_ADD_TEST_CASE(tcs, timestamp__strftime);
 369     ATF_ADD_TEST_CASE(tcs, timestamp__to_microseconds);
 370     ATF_ADD_TEST_CASE(tcs, timestamp__to_seconds);
 371     ATF_ADD_TEST_CASE(tcs, timestamp__leap_second);
 372     ATF_ADD_TEST_CASE(tcs, timestamp__equals);
 373     ATF_ADD_TEST_CASE(tcs, timestamp__differs);
 374     ATF_ADD_TEST_CASE(tcs, timestamp__subtraction);
 375     ATF_ADD_TEST_CASE(tcs, timestamp__output);
 376 }