xf.li | bdd93d5 | 2023-05-12 07:10:14 -0700 | [diff] [blame] | 1 | /* tst-strptime2 - Test strptime %z timezone offset specifier. */ |
| 2 | |
| 3 | #include <limits.h> |
| 4 | #include <stdbool.h> |
| 5 | #include <stdio.h> |
| 6 | #include <time.h> |
| 7 | |
| 8 | /* Dummy string is used to match strptime's %s specifier. */ |
| 9 | |
| 10 | static const char dummy_string[] = "1113472456"; |
| 11 | |
| 12 | /* buffer_size contains the maximum test string length, including |
| 13 | trailing NUL. */ |
| 14 | |
| 15 | enum |
| 16 | { |
| 17 | buffer_size = 20, |
| 18 | }; |
| 19 | |
| 20 | /* Verbose execution, set with --verbose command line option. */ |
| 21 | |
| 22 | static bool verbose; |
| 23 | |
| 24 | |
| 25 | /* mkbuf - Write a test string for strptime with the specified time |
| 26 | value and number of digits into the supplied buffer, and return |
| 27 | the expected strptime test result. |
| 28 | |
| 29 | The test string, buf, is written with the following content: |
| 30 | a dummy string matching strptime "%s" format specifier, |
| 31 | whitespace matching strptime " " format specifier, and |
| 32 | timezone string matching strptime "%z" format specifier. |
| 33 | |
| 34 | Note that a valid timezone string is either "Z" or contains the |
| 35 | following fields: |
| 36 | Sign field consisting of a '+' or '-' sign, |
| 37 | Hours field in two decimal digits, and |
| 38 | optional Minutes field in two decimal digits. Optionally, |
| 39 | a ':' is used to seperate hours and minutes. |
| 40 | |
| 41 | This function may write test strings with minutes values outside |
| 42 | the valid range 00-59. These are invalid strings and useful for |
| 43 | testing strptime's rejection of invalid strings. |
| 44 | |
| 45 | The ndigits parameter is used to limit the number of timezone |
| 46 | string digits to be written and may range from 0 to 4. Note that |
| 47 | only 2 and 4 digit strings are valid input to strptime; strings |
| 48 | with 0, 1 or 3 digits are invalid and useful for testing strptime's |
| 49 | rejection of invalid strings. |
| 50 | |
| 51 | This function returns the behavior expected of strptime resulting |
| 52 | from parsing the the test string. For valid strings, the function |
| 53 | returns the expected tm_gmtoff value. For invalid strings, |
| 54 | LONG_MAX is returned. LONG_MAX indicates the expectation that |
| 55 | strptime will return NULL; for example, if the number of digits |
| 56 | are not correct, or minutes part of the time is outside the valid |
| 57 | range of 00 to 59. */ |
| 58 | |
| 59 | static long int |
| 60 | mkbuf (char *buf, bool neg, bool colon, unsigned int hhmm, size_t ndigits) |
| 61 | { |
| 62 | const int mm_max = 59; |
| 63 | char sign = neg ? '-' : '+'; |
| 64 | int i; |
| 65 | unsigned int hh = hhmm / 100; |
| 66 | unsigned int mm = hhmm % 100; |
| 67 | long int expect = LONG_MAX; |
| 68 | |
| 69 | i = sprintf (buf, "%s %c", dummy_string, sign); |
| 70 | if (colon) |
| 71 | snprintf (buf + i, ndigits + 2, "%02u:%02u", hh, mm); |
| 72 | else |
| 73 | snprintf (buf + i, ndigits + 1, "%04u", hhmm); |
| 74 | |
| 75 | if (mm <= mm_max && (ndigits == 2 || ndigits == 4)) |
| 76 | { |
| 77 | long int tm_gmtoff = hh * 3600 + mm * 60; |
| 78 | |
| 79 | expect = neg ? -tm_gmtoff : tm_gmtoff; |
| 80 | } |
| 81 | |
| 82 | return expect; |
| 83 | } |
| 84 | |
| 85 | |
| 86 | /* Write a description of expected or actual test result to stdout. */ |
| 87 | |
| 88 | static void |
| 89 | describe (bool string_valid, long int tm_gmtoff) |
| 90 | { |
| 91 | if (string_valid) |
| 92 | printf ("valid, tm.tm_gmtoff %ld", tm_gmtoff); |
| 93 | else |
| 94 | printf ("invalid, return value NULL"); |
| 95 | } |
| 96 | |
| 97 | |
| 98 | /* Using buffer buf, run strptime. Compare results against expect, |
| 99 | the expected result. Report failures and verbose results to stdout. |
| 100 | Update the result counts. Return 1 if test failed, 0 if passed. */ |
| 101 | |
| 102 | static int |
| 103 | compare (const char *buf, long int expect, unsigned int *nresult) |
| 104 | { |
| 105 | struct tm tm; |
| 106 | char *p; |
| 107 | bool test_string_valid; |
| 108 | long int test_result; |
| 109 | bool fail; |
| 110 | int result; |
| 111 | |
| 112 | p = strptime (buf, "%s %z", &tm); |
| 113 | test_string_valid = p != NULL; |
| 114 | test_result = test_string_valid ? tm.tm_gmtoff : LONG_MAX; |
| 115 | fail = test_result != expect; |
| 116 | |
| 117 | if (fail || verbose) |
| 118 | { |
| 119 | bool expect_string_valid = expect != LONG_MAX; |
| 120 | |
| 121 | printf ("%s: input \"%s\", expected: ", fail ? "FAIL" : "PASS", buf); |
| 122 | describe (expect_string_valid, expect); |
| 123 | |
| 124 | if (fail) |
| 125 | { |
| 126 | printf (", got: "); |
| 127 | describe (test_string_valid, test_result); |
| 128 | } |
| 129 | |
| 130 | printf ("\n"); |
| 131 | } |
| 132 | |
| 133 | result = fail ? 1 : 0; |
| 134 | nresult[result]++; |
| 135 | |
| 136 | return result; |
| 137 | } |
| 138 | |
| 139 | |
| 140 | static int |
| 141 | do_test (void) |
| 142 | { |
| 143 | char buf[buffer_size]; |
| 144 | long int expect; |
| 145 | int result = 0; |
| 146 | /* Number of tests run with passing (index==0) and failing (index==1) |
| 147 | results. */ |
| 148 | unsigned int nresult[2]; |
| 149 | unsigned int ndigits; |
| 150 | unsigned int step; |
| 151 | unsigned int hhmm; |
| 152 | |
| 153 | nresult[0] = 0; |
| 154 | nresult[1] = 0; |
| 155 | |
| 156 | /* Create and test input string with no sign and four digits input |
| 157 | (invalid format). */ |
| 158 | |
| 159 | sprintf (buf, "%s 1030", dummy_string); |
| 160 | expect = LONG_MAX; |
| 161 | result |= compare (buf, expect, nresult); |
| 162 | |
| 163 | /* Create and test input string with "Z" input (valid format). |
| 164 | Expect tm_gmtoff of 0. */ |
| 165 | |
| 166 | sprintf (buf, "%s Z", dummy_string); |
| 167 | expect = 0; |
| 168 | result |= compare (buf, expect, nresult); |
| 169 | |
| 170 | /* Create and test input strings with sign and digits: |
| 171 | 0 digits (invalid format), |
| 172 | 1 digit (invalid format), |
| 173 | 2 digits (valid format), |
| 174 | 3 digits (invalid format), |
| 175 | 4 digits (valid format if and only if minutes is in range 00-59, |
| 176 | otherwise invalid). |
| 177 | If format is valid, the returned tm_gmtoff is checked. */ |
| 178 | |
| 179 | for (ndigits = 0, step = 10000; ndigits <= 4; ndigits++, step /= 10) |
| 180 | for (hhmm = 0; hhmm <= 9999; hhmm += step) |
| 181 | { |
| 182 | /* Test both positive and negative signs. */ |
| 183 | |
| 184 | expect = mkbuf (buf, false, false, hhmm, ndigits); |
| 185 | result |= compare (buf, expect, nresult); |
| 186 | |
| 187 | expect = mkbuf (buf, true, false, hhmm, ndigits); |
| 188 | result |= compare (buf, expect, nresult); |
| 189 | |
| 190 | /* Test with colon as well. */ |
| 191 | |
| 192 | if (ndigits >= 3) |
| 193 | { |
| 194 | expect = mkbuf (buf, false, true, hhmm, ndigits); |
| 195 | result |= compare (buf, expect, nresult); |
| 196 | |
| 197 | expect = mkbuf (buf, true, true, hhmm, ndigits); |
| 198 | result |= compare (buf, expect, nresult); |
| 199 | } |
| 200 | } |
| 201 | |
| 202 | if (result > 0 || verbose) |
| 203 | printf ("%s: %u input strings: %u fail, %u pass\n", |
| 204 | result > 0 ? "FAIL" : "PASS", |
| 205 | nresult[1] + nresult[0], nresult[1], nresult[0]); |
| 206 | |
| 207 | return result; |
| 208 | } |
| 209 | |
| 210 | |
| 211 | /* Add a "--verbose" command line option to test-skeleton.c. */ |
| 212 | |
| 213 | #define OPT_VERBOSE 10000 |
| 214 | |
| 215 | #define CMDLINE_OPTIONS \ |
| 216 | { "verbose", no_argument, NULL, OPT_VERBOSE, }, |
| 217 | |
| 218 | #define CMDLINE_PROCESS \ |
| 219 | case OPT_VERBOSE: \ |
| 220 | verbose = true; \ |
| 221 | break; |
| 222 | |
| 223 | #define TEST_FUNCTION do_test () |
| 224 | #include "../test-skeleton.c" |