src/test/test-time.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2013 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include "strv.h"
  23 #include "time-util.h"
  24
  25 static void test_parse_sec(void) {
  26         usec_t u;
  27
  28         assert_se(parse_sec("5s", &u) >= 0);
  29         assert_se(u == 5 * USEC_PER_SEC);
  30         assert_se(parse_sec("5s500ms", &u) >= 0);
  31         assert_se(u == 5 * USEC_PER_SEC + 500 * USEC_PER_MSEC);
  32         assert_se(parse_sec(" 5s 500ms  ", &u) >= 0);
  33         assert_se(u == 5 * USEC_PER_SEC + 500 * USEC_PER_MSEC);
  34         assert_se(parse_sec(" 5.5s  ", &u) >= 0);
  35         assert_se(u == 5 * USEC_PER_SEC + 500 * USEC_PER_MSEC);
  36         assert_se(parse_sec(" 5.5s 0.5ms ", &u) >= 0);
  37         assert_se(u == 5 * USEC_PER_SEC + 500 * USEC_PER_MSEC + 500);
  38         assert_se(parse_sec(" .22s ", &u) >= 0);
  39         assert_se(u == 220 * USEC_PER_MSEC);
  40         assert_se(parse_sec(" .50y ", &u) >= 0);
  41         assert_se(u == USEC_PER_YEAR / 2);
  42         assert_se(parse_sec("2.5", &u) >= 0);
  43         assert_se(u == 2500 * USEC_PER_MSEC);
  44         assert_se(parse_sec(".7", &u) >= 0);
  45         assert_se(u == 700 * USEC_PER_MSEC);
  46         assert_se(parse_sec("infinity", &u) >= 0);
  47         assert_se(u == USEC_INFINITY);
  48         assert_se(parse_sec(" infinity ", &u) >= 0);
  49         assert_se(u == USEC_INFINITY);
  50
  51         assert_se(parse_sec(" xyz ", &u) < 0);
  52         assert_se(parse_sec("", &u) < 0);
  53         assert_se(parse_sec(" . ", &u) < 0);
  54         assert_se(parse_sec(" 5. ", &u) < 0);
  55         assert_se(parse_sec(".s ", &u) < 0);
  56         assert_se(parse_sec(" infinity .7", &u) < 0);
  57         assert_se(parse_sec(".3 infinity", &u) < 0);
  58 }
  59
  60 static void test_parse_time(void) {
  61         usec_t u;
  62
  63         assert_se(parse_time("5", &u, 1) >= 0);
  64         assert_se(u == 5);
  65
  66         assert_se(parse_time("5", &u, USEC_PER_MSEC) >= 0);
  67         assert_se(u == 5 * USEC_PER_MSEC);
  68
  69         assert_se(parse_time("5", &u, USEC_PER_SEC) >= 0);
  70         assert_se(u == 5 * USEC_PER_SEC);
  71
  72         assert_se(parse_time("5s", &u, 1) >= 0);
  73         assert_se(u == 5 * USEC_PER_SEC);
  74
  75         assert_se(parse_time("5s", &u, USEC_PER_SEC) >= 0);
  76         assert_se(u == 5 * USEC_PER_SEC);
  77
  78         assert_se(parse_time("5s", &u, USEC_PER_MSEC) >= 0);
  79         assert_se(u == 5 * USEC_PER_SEC);
  80 }
  81
  82 static void test_parse_nsec(void) {
  83         nsec_t u;
  84
  85         assert_se(parse_nsec("5s", &u) >= 0);
  86         assert_se(u == 5 * NSEC_PER_SEC);
  87         assert_se(parse_nsec("5s500ms", &u) >= 0);
  88         assert_se(u == 5 * NSEC_PER_SEC + 500 * NSEC_PER_MSEC);
  89         assert_se(parse_nsec(" 5s 500ms  ", &u) >= 0);
  90         assert_se(u == 5 * NSEC_PER_SEC + 500 * NSEC_PER_MSEC);
  91         assert_se(parse_nsec(" 5.5s  ", &u) >= 0);
  92         assert_se(u == 5 * NSEC_PER_SEC + 500 * NSEC_PER_MSEC);
  93         assert_se(parse_nsec(" 5.5s 0.5ms ", &u) >= 0);
  94         assert_se(u == 5 * NSEC_PER_SEC + 500 * NSEC_PER_MSEC + 500 * NSEC_PER_USEC);
  95         assert_se(parse_nsec(" .22s ", &u) >= 0);
  96         assert_se(u == 220 * NSEC_PER_MSEC);
  97         assert_se(parse_nsec(" .50y ", &u) >= 0);
  98         assert_se(u == NSEC_PER_YEAR / 2);
  99         assert_se(parse_nsec("2.5", &u) >= 0);
 100         assert_se(u == 2);
 101         assert_se(parse_nsec(".7", &u) >= 0);
 102         assert_se(u == 0);
 103         assert_se(parse_nsec("infinity", &u) >= 0);
 104         assert_se(u == NSEC_INFINITY);
 105         assert_se(parse_nsec(" infinity ", &u) >= 0);
 106         assert_se(u == NSEC_INFINITY);
 107
 108         assert_se(parse_nsec(" xyz ", &u) < 0);
 109         assert_se(parse_nsec("", &u) < 0);
 110         assert_se(parse_nsec(" . ", &u) < 0);
 111         assert_se(parse_nsec(" 5. ", &u) < 0);
 112         assert_se(parse_nsec(".s ", &u) < 0);
 113         assert_se(parse_nsec(" infinity .7", &u) < 0);
 114         assert_se(parse_nsec(".3 infinity", &u) < 0);
 115 }
 116
 117 static void test_format_timespan_one(usec_t x, usec_t accuracy) {
 118         char *r;
 119         char l[FORMAT_TIMESPAN_MAX];
 120         usec_t y;
 121
 122         log_info(USEC_FMT"     (at accuracy "USEC_FMT")", x, accuracy);
 123
 124         r = format_timespan(l, sizeof(l), x, accuracy);
 125         assert_se(r);
 126
 127         log_info(" = <%s>", l);
 128
 129         assert_se(parse_sec(l, &y) >= 0);
 130
 131         log_info(" = "USEC_FMT, y);
 132
 133         if (accuracy <= 0)
 134                 accuracy = 1;
 135
 136         assert_se(x / accuracy == y / accuracy);
 137 }
 138
 139 static void test_format_timespan(usec_t accuracy) {
 140         test_format_timespan_one(0, accuracy);
 141         test_format_timespan_one(1, accuracy);
 142         test_format_timespan_one(1*USEC_PER_SEC, accuracy);
 143         test_format_timespan_one(999*USEC_PER_MSEC, accuracy);
 144         test_format_timespan_one(1234567, accuracy);
 145         test_format_timespan_one(12, accuracy);
 146         test_format_timespan_one(123, accuracy);
 147         test_format_timespan_one(1234, accuracy);
 148         test_format_timespan_one(12345, accuracy);
 149         test_format_timespan_one(123456, accuracy);
 150         test_format_timespan_one(1234567, accuracy);
 151         test_format_timespan_one(12345678, accuracy);
 152         test_format_timespan_one(1200000, accuracy);
 153         test_format_timespan_one(1230000, accuracy);
 154         test_format_timespan_one(1230000, accuracy);
 155         test_format_timespan_one(1234000, accuracy);
 156         test_format_timespan_one(1234500, accuracy);
 157         test_format_timespan_one(1234560, accuracy);
 158         test_format_timespan_one(1234567, accuracy);
 159         test_format_timespan_one(986087, accuracy);
 160         test_format_timespan_one(500 * USEC_PER_MSEC, accuracy);
 161         test_format_timespan_one(9*USEC_PER_YEAR/5 - 23, accuracy);
 162         test_format_timespan_one(USEC_INFINITY, accuracy);
 163 }
 164
 165 static void test_timezone_is_valid(void) {
 166         assert_se(timezone_is_valid("Europe/Berlin"));
 167         assert_se(timezone_is_valid("Australia/Sydney"));
 168         assert_se(!timezone_is_valid("Europe/Do not exist"));
 169 }
 170
 171 static void test_get_timezones(void) {
 172         _cleanup_strv_free_ char **zones = NULL;
 173         int r;
 174         char **zone;
 175
 176         r = get_timezones(&zones);
 177         assert_se(r == 0);
 178
 179         STRV_FOREACH(zone, zones)
 180                 assert_se(timezone_is_valid(*zone));
 181 }
 182
 183 static void test_usec_add(void) {
 184         assert_se(usec_add(0, 0) == 0);
 185         assert_se(usec_add(1, 4) == 5);
 186         assert_se(usec_add(USEC_INFINITY, 5) == USEC_INFINITY);
 187         assert_se(usec_add(5, USEC_INFINITY) == USEC_INFINITY);
 188         assert_se(usec_add(USEC_INFINITY-5, 2) == USEC_INFINITY-3);
 189         assert_se(usec_add(USEC_INFINITY-2, 2) == USEC_INFINITY);
 190         assert_se(usec_add(USEC_INFINITY-1, 2) == USEC_INFINITY);
 191         assert_se(usec_add(USEC_INFINITY, 2) == USEC_INFINITY);
 192 }
 193
 194 int main(int argc, char *argv[]) {
 195         uintmax_t x;
 196
 197         test_parse_sec();
 198         test_parse_time();
 199         test_parse_nsec();
 200         test_format_timespan(1);
 201         test_format_timespan(USEC_PER_MSEC);
 202         test_format_timespan(USEC_PER_SEC);
 203         test_timezone_is_valid();
 204         test_get_timezones();
 205         test_usec_add();
 206
 207         /* Ensure time_t is signed */
 208         assert_cc((time_t) -1 < (time_t) 1);
 209
 210         /* Ensure TIME_T_MAX works correctly */
 211         x = (uintmax_t) TIME_T_MAX;
 212         x ++;
 213         assert((time_t) x < 0);
 214
 215         return 0;
 216 }