support/tst-timespec.c

   1 /* Test for support_timespec_check_in_range function.
   2    Copyright (C) 2020-2024 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #include <support/timespec.h>
  20 #include <support/check.h>
  21 #include <limits.h>
  22 #include <intprops.h>
  23
  24 #define TIMESPEC_HZ 1000000000
  25
  26 struct timespec_ns_test_case
  27 {
  28   struct timespec time;
  29   time_t time_ns;
  30 };
  31
  32 struct timespec_norm_test_case
  33 {
  34   struct timespec time;
  35   struct timespec norm;
  36 };
  37
  38 struct timespec_test_case
  39 {
  40   struct timespec expected;
  41   struct timespec observed;
  42   double upper_bound;
  43   double lower_bound;
  44   int result;
  45 };
  46
  47 #define TIME_T_MIN TYPE_MINIMUM (time_t)
  48 #define TIME_T_MAX TYPE_MAXIMUM (time_t)
  49
  50 /* Test cases for timespec_ns */
  51 struct timespec_ns_test_case ns_cases[] = {
  52   {.time = {.tv_sec = 0, .tv_nsec = 0},
  53    .time_ns = 0,
  54   },
  55   {.time = {.tv_sec = 0, .tv_nsec = 1},
  56    .time_ns = 1,
  57   },
  58   {.time = {.tv_sec = 1, .tv_nsec = 0},
  59    .time_ns = TIMESPEC_HZ,
  60   },
  61   {.time = {.tv_sec = 1, .tv_nsec = 1},
  62    .time_ns = TIMESPEC_HZ + 1,
  63   },
  64   {.time = {.tv_sec = 0, .tv_nsec = -1},
  65    .time_ns = -1,
  66   },
  67   {.time = {.tv_sec = -1, .tv_nsec = 0},
  68    .time_ns = -TIMESPEC_HZ,
  69   },
  70   {.time = {.tv_sec = -1, .tv_nsec = -1},
  71    .time_ns = -TIMESPEC_HZ - 1,
  72   },
  73   {.time = {.tv_sec = 1, .tv_nsec = -1},
  74    .time_ns = TIMESPEC_HZ - 1,
  75   },
  76   {.time = {.tv_sec = -1, .tv_nsec = 1},
  77    .time_ns = -TIMESPEC_HZ + 1,
  78   },
  79   /* Overflow boundary by 2  */
  80   {.time = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ,
  81             .tv_nsec = TIME_T_MAX % TIMESPEC_HZ - 1},
  82    .time_ns = TIME_T_MAX - 1,
  83   },
  84   /* Overflow boundary  */
  85   {.time = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ,
  86             .tv_nsec = TIME_T_MAX % TIMESPEC_HZ},
  87    .time_ns = TIME_T_MAX,
  88   },
  89   /* Underflow boundary by 1  */
  90   {.time = {.tv_sec = TIME_T_MIN / TIMESPEC_HZ,
  91             .tv_nsec = TIME_T_MIN % TIMESPEC_HZ + 1},
  92    .time_ns = TIME_T_MIN + 1,
  93   },
  94   /* Underflow boundary  */
  95   {.time = {.tv_sec = TIME_T_MIN / TIMESPEC_HZ,
  96             .tv_nsec = TIME_T_MIN % TIMESPEC_HZ},
  97    .time_ns = TIME_T_MIN,
  98   },
  99   /* Multiplication overflow  */
 100   {.time = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ + 1, .tv_nsec = 1},
 101    .time_ns = TIME_T_MAX,
 102   },
 103   /* Multiplication underflow  */
 104   {.time = {.tv_sec = TIME_T_MIN / TIMESPEC_HZ - 1, .tv_nsec = -1},
 105    .time_ns = TIME_T_MIN,
 106   },
 107   /* Sum overflows  */
 108   {.time = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ,
 109             .tv_nsec = TIME_T_MAX % TIMESPEC_HZ + 1},
 110    .time_ns = TIME_T_MAX,
 111   },
 112   /* Sum underflow  */
 113   {.time = {.tv_sec = TIME_T_MIN / TIMESPEC_HZ,
 114             .tv_nsec = TIME_T_MIN % TIMESPEC_HZ - 1},
 115    .time_ns = TIME_T_MIN,
 116   }
 117 };
 118
 119 /* Test cases for timespec_norm */
 120 struct timespec_norm_test_case norm_cases[] = {
 121   /* Positive cases  */
 122   {.time = {.tv_sec = 0, .tv_nsec = 0},
 123    .norm = {.tv_sec = 0, .tv_nsec = 0}
 124   },
 125   {.time = {.tv_sec = 1, .tv_nsec = 0},
 126    .norm = {.tv_sec = 1, .tv_nsec = 0}
 127   },
 128   {.time = {.tv_sec = 0, .tv_nsec = 1},
 129    .norm = {.tv_sec = 0, .tv_nsec = 1}
 130   },
 131   {.time = {.tv_sec = 0, .tv_nsec = TIMESPEC_HZ},
 132    .norm = {.tv_sec = 1, .tv_nsec = 0}
 133   },
 134   {.time = {.tv_sec = 0, .tv_nsec = TIMESPEC_HZ + 1},
 135    .norm = {.tv_sec = 1, .tv_nsec = 1}
 136   },
 137   {.time = {.tv_sec = 1, .tv_nsec = TIMESPEC_HZ},
 138    .norm = {.tv_sec = 2, .tv_nsec = 0}
 139   },
 140   {.time = {.tv_sec = 1, .tv_nsec = TIMESPEC_HZ + 1},
 141    .norm = {.tv_sec = 2, .tv_nsec = 1}
 142   },
 143   /* Negative cases  */
 144   {.time = {.tv_sec = 0, .tv_nsec = -TIMESPEC_HZ},
 145    .norm = {.tv_sec = -1, .tv_nsec = 0}
 146   },
 147   {.time = {.tv_sec = 0, .tv_nsec = -TIMESPEC_HZ - 1},
 148    .norm = {.tv_sec = -1, .tv_nsec = -1}
 149   },
 150   {.time = {.tv_sec = -1, .tv_nsec = -TIMESPEC_HZ},
 151    .norm = {.tv_sec = -2, .tv_nsec = 0}
 152   },
 153   {.time = {.tv_sec = -1, .tv_nsec = -TIMESPEC_HZ - 1},
 154    .norm = {.tv_sec = -2, .tv_nsec = -1}
 155   },
 156   /* Overflow boundary by 2  */
 157   {.time = {.tv_sec = TIME_T_MAX - 2, .tv_nsec = TIMESPEC_HZ + 1},
 158    .norm = {.tv_sec = TIME_T_MAX - 1, 1},
 159   },
 160   /* Overflow boundary by 1  */
 161   {.time = {.tv_sec = TIME_T_MAX - 1, .tv_nsec = TIMESPEC_HZ + 1},
 162    .norm = {.tv_sec = TIME_T_MAX, .tv_nsec = 1},
 163   },
 164   /* Underflow boundary by 2  */
 165   {.time = {.tv_sec = TIME_T_MIN + 2, .tv_nsec = -TIMESPEC_HZ - 1},
 166    .norm = {.tv_sec = TIME_T_MIN + 1, -1},
 167   },
 168   /* Underflow boundary by 1  */
 169   {.time = {.tv_sec = TIME_T_MIN + 1, .tv_nsec = -TIMESPEC_HZ - 1},
 170    .norm = {.tv_sec = TIME_T_MIN, .tv_nsec = -1},
 171   },
 172   /* SUM overflow  */
 173   {.time = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ},
 174    .norm = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ - 1},
 175   },
 176   /* SUM underflow  */
 177   {.time = {.tv_sec = TIME_T_MIN, .tv_nsec = -TIMESPEC_HZ},
 178    .norm = {.tv_sec = TIME_T_MIN, .tv_nsec = -1 * (TIMESPEC_HZ - 1)},
 179   }
 180 };
 181
 182 /* Test cases for timespec_check_in_range  */
 183 struct timespec_test_case check_cases[] = {
 184   /* 0 - In range  */
 185   {.expected = {.tv_sec = 1, .tv_nsec = 0},
 186    .observed = {.tv_sec = 1, .tv_nsec = 0},
 187    .upper_bound = 1, .lower_bound = 1, .result = 1,
 188   },
 189   /* 1 - Out of range  */
 190   {.expected = {.tv_sec = 1, .tv_nsec = 0},
 191    .observed = {.tv_sec = 2, .tv_nsec = 0},
 192    .upper_bound = 1, .lower_bound = 1, .result = 0,
 193   },
 194   /* 2 - Upper Bound  */
 195   {.expected = {.tv_sec = 1, .tv_nsec = 0},
 196    .observed = {.tv_sec = 2, .tv_nsec = 0},
 197    .upper_bound = 2, .lower_bound = 1, .result = 1,
 198   },
 199   /* 3 - Lower Bound  */
 200   {.expected = {.tv_sec = 1, .tv_nsec = 0},
 201    .observed = {.tv_sec = 0, .tv_nsec = 0},
 202    .upper_bound = 1, .lower_bound = 0, .result = 1,
 203   },
 204   /* 4 - Out of range by nanosecs  */
 205   {.expected = {.tv_sec = 1, .tv_nsec = 0},
 206    .observed = {.tv_sec = 1, .tv_nsec = 500},
 207    .upper_bound = 1, .lower_bound = 1, .result = 0,
 208   },
 209   /* 5 - In range by nanosecs  */
 210   {.expected = {.tv_sec = 1, .tv_nsec = 0},
 211    .observed = {.tv_sec = 1, .tv_nsec = 50000},
 212    .upper_bound = 1.3, .lower_bound = 1, .result = 1,
 213   },
 214   /* 6 - Big nanosecs  */
 215   {.expected = {.tv_sec = 1, .tv_nsec = 0},
 216    .observed = {.tv_sec = 0, .tv_nsec = 4000000},
 217    .upper_bound = 1, .lower_bound = .001, .result = 1,
 218   },
 219   /* 7 - In range Negative values  */
 220   {.expected = {.tv_sec = -1, .tv_nsec = 0},
 221    .observed = {.tv_sec = -1, .tv_nsec = 0},
 222    .upper_bound = 1, .lower_bound = 1, .result = 1,
 223   },
 224   /* 8 - Out of range Negative values  */
 225   {.expected = {.tv_sec = -1, .tv_nsec = 0},
 226    .observed = {.tv_sec = -1, .tv_nsec = 0},
 227    .upper_bound = -1, .lower_bound = -1, .result = 0,
 228   },
 229   /* 9 - Negative values with negative nanosecs  */
 230   {.expected = {.tv_sec = -1, .tv_nsec = 0},
 231    .observed = {.tv_sec = -1, .tv_nsec = -2000},
 232    .upper_bound = 1, .lower_bound = 1, .result = 0,
 233   },
 234   /* 10 - Strict bounds  */
 235   {.expected = {.tv_sec = -1, .tv_nsec = 0},
 236    .observed = {.tv_sec = -1, .tv_nsec = -20000},
 237    .upper_bound = 1.00002, .lower_bound = 1.0000191, .result = 1,
 238   },
 239   /* 11 - Strict bounds with loose upper bound  */
 240   {.expected = {.tv_sec = 1, .tv_nsec = 20000},
 241    .observed = {.tv_sec = 1, .tv_nsec = 30000},
 242    .upper_bound = 1.0000100000, .lower_bound = 1.0000099998, .result = 1,
 243   },
 244   /* 12 - Strict bounds with loose lower bound  */
 245   {.expected = {.tv_sec = 1, .tv_nsec = 20000},
 246    .observed = {.tv_sec = 1, .tv_nsec = 30000},
 247    .upper_bound = 1.0000099999, .lower_bound = 1.00000999979, .result = 1,
 248   },
 249   /* 13 - Strict bounds highest precision  */
 250   {.expected = {.tv_sec = 1, .tv_nsec = 20000},
 251    .observed = {.tv_sec = 1, .tv_nsec = 30000},
 252    .upper_bound = 1.00000999980001, .lower_bound = 1.00000999979999, .result = 1,
 253   },
 254   /* Maximum/Minimum long values  */
 255   /* 14  */
 256   {.expected = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ - 1},
 257    .observed = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ - 2},
 258    .upper_bound = 1, .lower_bound = .9, .result = 1,
 259   },
 260   /* 15 - support_timespec_ns overflow  */
 261   {.expected = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ},
 262    .observed = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ},
 263    .upper_bound = 1, .lower_bound = 1, .result = 1,
 264   },
 265   /* 16 - support_timespec_ns overflow + underflow  */
 266   {.expected = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ},
 267    .observed = {.tv_sec = TIME_T_MIN, .tv_nsec = -TIMESPEC_HZ},
 268    .upper_bound = 1, .lower_bound = 1, .result = 0,
 269   },
 270   /* 17 - support_timespec_ns underflow  */
 271   {.expected = {.tv_sec = TIME_T_MIN, .tv_nsec = -TIMESPEC_HZ},
 272    .observed = {.tv_sec = TIME_T_MIN, .tv_nsec = -TIMESPEC_HZ},
 273    .upper_bound = 1, .lower_bound = 1, .result = 1,
 274   },
 275   /* 18 - support_timespec_ns underflow + overflow  */
 276   {.expected = {.tv_sec = TIME_T_MIN, .tv_nsec = -TIMESPEC_HZ},
 277    .observed = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ},
 278    .upper_bound = 1, .lower_bound = 1, .result = 0,
 279   },
 280   /* 19 - Biggest division  */
 281   {.expected = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ,
 282                 .tv_nsec = TIMESPEC_HZ - 1},
 283    .observed = {.tv_sec = 0, .tv_nsec = 1},
 284    .upper_bound = 1, .lower_bound = 1.0842021724855044e-19, .result = 1,
 285   },
 286   /* 20 - Lowest division  */
 287   {.expected = {.tv_sec = 0, .tv_nsec = 1},
 288    .observed = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ,
 289                 .tv_nsec = TIMESPEC_HZ - 1},
 290    .upper_bound = TIME_T_MAX, .lower_bound = 1, .result = 1,
 291   },
 292 };
 293
 294 static int
 295 do_test (void)
 296 {
 297   int i = 0;
 298   int ntests = sizeof (ns_cases) / sizeof (ns_cases[0]);
 299
 300   printf("Testing support_timespec_ns\n");
 301   for (i = 0; i < ntests; i++)
 302     {
 303       printf("Test case %d\n", i);
 304       TEST_COMPARE (support_timespec_ns (ns_cases[i].time),
 305                     ns_cases[i].time_ns);
 306     }
 307
 308   ntests = sizeof (norm_cases) / sizeof (norm_cases[0]);
 309   struct timespec result;
 310   printf("Testing support_timespec_normalize\n");
 311   for (i = 0; i < ntests; i++)
 312     {
 313       printf("Test case %d\n", i);
 314       result = support_timespec_normalize (norm_cases[i].time);
 315       TEST_COMPARE (norm_cases[i].norm.tv_sec, result.tv_sec);
 316       TEST_COMPARE (norm_cases[i].norm.tv_nsec, result.tv_nsec);
 317     }
 318
 319   ntests = sizeof (check_cases) / sizeof (check_cases[0]);
 320   printf("Testing support_timespec_check_in_range\n");
 321   for (i = 0; i < ntests; i++)
 322     {
 323       /* Its hard to find which test failed with just the TEST_COMPARE report.
 324          So here we print every running testcase as well.  */
 325       printf("Test case %d\n", i);
 326       TEST_COMPARE (support_timespec_check_in_range
 327                     (check_cases[i].expected, check_cases[i].observed,
 328                      check_cases[i].lower_bound,
 329                      check_cases[i].upper_bound), check_cases[i].result);
 330     }
 331   return 0;
 332 }
 333
 334 #include <support/test-driver.c>