time/tst-strptime2.c: test full input range +/- 0-9999

strptime's %z specifier parses a string consisting of a sign ('+'
or '-'), two hours digits, and optionally two minutes digits, into a
tm.tm_gmtoff field containing the signed number of seconds the time
zone is offset from UTC time.

The time/tst-strptime2.c program passes a short list of strings through
strptime, validating that either the gmtoff value returned matches an
expected value, or that strptime returns an expected NULL for invalid
strings (for example, when the minutes portion of the string is outside
of the range 00 to 59, or the sign is missing before the hours digits).

In review of strptime fixes, Carlos O'Donell expressed a wish that
the test function iterate through the entire range of all possible
numeric strings (-9999 to +9999) which could be passed to strptime %z,
and validate the correct response.

Specifically, the test will look for a NULL response from strptime
when:

  * sign ('+' or '-') is not present before the first digit (invalid
    format).
  * A sign and no digits are found (invalid format).
  * A sign and one digit are found (invalid format).
  * A sign and three digits are found (invalid format).
  * A sign and four digits (-9999 to +9999) are found but the last
    two digits (minutes) are in the range 60 to 99.

The test will look for a success response from strptime with
tm.tm_gmtoff matching the calculated tm_gmtoff value when:

  * A sign and four digits are found (-9999 to +9999), and the last
    two digits (minutes) are in the range 00 to 59.
  * A sign and two digit strings are found (-99 to +99).

The test's iteration over the possible digit values results in 22223
test strings prepared, tested, and passed by strptime.

The test supports a --verbose command line option which will show
the test results of every test input, and a final summary of all
tests. Here is some sample output:

  PASS: input "1113472456  1030", expected: invalid, return value NULL
  PASS: input "1113472456 +", expected: invalid, return value NULL
  PASS: input "1113472456 -", expected: invalid, return value NULL
  PASS: input "1113472456 +0", expected: invalid, return value NULL
  PASS: input "1113472456 -0", expected: invalid, return value NULL
  PASS: input "1113472456 +1", expected: invalid, return value NULL
  ...
  PASS: input "1113472456 +9", expected: invalid, return value NULL
  PASS: input "1113472456 -9", expected: invalid, return value NULL
  PASS: input "1113472456 +00", expected: valid, tm.tm_gmtoff 0
  PASS: input "1113472456 -00", expected: valid, tm.tm_gmtoff 0
  PASS: input "1113472456 +01", expected: valid, tm.tm_gmtoff 3600
  PASS: input "1113472456 -01", expected: valid, tm.tm_gmtoff -3600
  PASS: input "1113472456 +02", expected: valid, tm.tm_gmtoff 7200
  ...
  PASS: input "1113472456 +99", expected: valid, tm.tm_gmtoff 356400
  PASS: input "1113472456 -99", expected: valid, tm.tm_gmtoff -356400
  PASS: input "1113472456 +000", expected: invalid, return value NULL
  PASS: input "1113472456 -000", expected: invalid, return value NULL
  PASS: input "1113472456 +001", expected: invalid, return value NULL
  ...
  PASS: input "1113472456 +999", expected: invalid, return value NULL
  PASS: input "1113472456 -999", expected: invalid, return value NULL
  PASS: input "1113472456 +0000", expected: valid, tm.tm_gmtoff 0
  PASS: input "1113472456 -0000", expected: valid, tm.tm_gmtoff 0
  PASS: input "1113472456 +0001", expected: valid, tm.tm_gmtoff 60
  PASS: input "1113472456 -0001", expected: valid, tm.tm_gmtoff -60
  ...
  PASS: input "1113472456 +0059", expected: valid, tm.tm_gmtoff 3540
  PASS: input "1113472456 -0059", expected: valid, tm.tm_gmtoff -3540
  PASS: input "1113472456 +0060", expected: invalid, return value NULL
  PASS: input "1113472456 -0060", expected: invalid, return value NULL
  ...
  PASS: input "1113472456 +0099", expected: invalid, return value NULL
  PASS: input "1113472456 -0099", expected: invalid, return value NULL
  PASS: input "1113472456 +0100", expected: valid, tm.tm_gmtoff 3600
  PASS: input "1113472456 -0100", expected: valid, tm.tm_gmtoff -3600
  PASS: input "1113472456 +0101", expected: valid, tm.tm_gmtoff 3660
  ...
  PASS: input "1113472456 +9999", expected: invalid, return value NULL
  PASS: input "1113472456 -9999", expected: invalid, return value NULL
  PASS: 22223 input strings: 0 fail, 22223 pass

Any failing test will result in printing the failed line to stdout, and
will trigger the printing of the summary line at the of all tests. For
example:

  FAIL: input "1113472456  1030", expected: invalid, return value NULL,
    got: valid, tm.tm_gmtoff 37800
  FAIL: 22223 input strings: 1 fail, 22222 pass

1 files changed, 178 insertions, 53 deletions

diff --git a/time/tst-strptime2.c b/time/tst-strptime2.c
index 4db8321..5b06a63 100644
--- a/time/tst-strptime2.c
+++ b/time/tst-strptime2.c
@@ -1,76 +1,201 @@
+/* tst-strptime2 - Test strptime %z timezone offset specifier.  */
+
 #include <limits.h>
+#include <stdbool.h>
 #include <stdio.h>
 #include <time.h>
 
+/* Dummy string is used to match strptime's %s specifier.  */
+
+static const char dummy_string[] = "1113472456";
+
+/* buffer_size contains the maximum test string length, including
+   trailing NUL.  */
+
+enum
+{
+  buffer_size = 20,
+};
+
+/* Verbose execution, set with --verbose command line option.  */
+
+static bool verbose;
+
+
+/* mkbuf - Write a test string for strptime with the specified time
+   value and number of digits into the supplied buffer, and return
+   the expected strptime test result.
+
+   The test string, buf, is written with the following content:
+     a dummy string matching strptime "%s" format specifier,
+     whitespace matching strptime " " format specifier, and
+     timezone string matching strptime "%z" format specifier.
+
+   Note that a valid timezone string contains the following fields:
+     Sign field consisting of a '+' or '-' sign,
+     Hours field in two decimal digits, and
+     optional Minutes field in two decimal digits.
+
+   This function may write test strings with minutes values outside
+   the valid range 00-59.  These are invalid strings and useful for
+   testing strptime's rejection of invalid strings.
+
+   The ndigits parameter is used to limit the number of timezone
+   string digits to be written and may range from 0 to 4.  Note that
+   only 2 and 4 digit strings are valid input to strptime; strings
+   with 0, 1 or 3 digits are invalid and useful for testing strptime's
+   rejection of invalid strings.
+
+   This function returns the behavior expected of strptime resulting
+   from parsing the the test string.  For valid strings, the function
+   returns the expected tm_gmtoff value.  For invalid strings,
+   LONG_MAX is returned.  LONG_MAX indicates the expectation that
+   strptime will return NULL; for example, if the number of digits
+   are not correct, or minutes part of the time is outside the valid
+   range of 00 to 59.  */
 
-static const struct
+static long int
+mkbuf (char *buf, bool neg, unsigned int hhmm, size_t ndigits)
 {
-  const char *fmt;
-  long int gmtoff;
-} tests[] =
-  {
-    { "1113472456 +1000", 36000 },
-    { "1113472456 -1000", -36000 },
-    { "1113472456 +10", 36000 },
-    { "1113472456 -10", -36000 },
-    { "1113472456 +1030", 37800 },
-    { "1113472456 -1030", -37800 },
-    { "1113472456 +0030", 1800 },
-    { "1113472456 -0030", -1800 },
-    { "1113472456 +1157", 43020 },
-    { "1113472456 +1158", 43080 },
-    { "1113472456 +1159", 43140 },
-    { "1113472456 +1200", 43200 },
-    { "1113472456 -1200", -43200 },
-    { "1113472456 +1201", 43260 },
-    { "1113472456 -1201", -43260 },
-    { "1113472456 +1330", 48600 },
-    { "1113472456 -1330", -48600 },
-    { "1113472456 +1400", 50400 },
-    { "1113472456 +1401", 50460 },
-    { "1113472456 -2459", -89940 },
-    { "1113472456 -2500", -90000 },
-    { "1113472456 +2559", 93540 },
-    { "1113472456 +2600", 93600 },
-    { "1113472456 -99", -356400 },
-    { "1113472456 +99", 356400 },
-    { "1113472456 -9959", -359940 },
-    { "1113472456 +9959", 359940 },
-    { "1113472456 -1060", LONG_MAX },
-    { "1113472456 +1060", LONG_MAX },
-    { "1113472456  1030", LONG_MAX },
-  };
-#define ntests (sizeof (tests) / sizeof (tests[0]))
+  const int mm_max = 59;
+  char sign = neg ? '-' : '+';
+  int i;
+  unsigned int hh = hhmm / 100;
+  unsigned int mm = hhmm % 100;
+  long int expect = LONG_MAX;
 
+  i = sprintf (buf, "%s %c", dummy_string, sign);
+  snprintf (buf + i, ndigits + 1, "%04u", hhmm);
+
+  if (mm <= mm_max && (ndigits == 2 || ndigits == 4))
+    {
+      long int tm_gmtoff = hh * 3600 + mm * 60;
+
+      expect = neg ? -tm_gmtoff : tm_gmtoff;
+    }
+
+  return expect;
+}
+
+
+/* Write a description of expected or actual test result to stdout.  */
+
+static void
+describe (bool string_valid, long int tm_gmtoff)
+{
+  if (string_valid)
+    printf ("valid, tm.tm_gmtoff %ld", tm_gmtoff);
+  else
+    printf ("invalid, return value NULL");
+}
+
+
+/* Using buffer buf, run strptime.  Compare results against expect,
+  the expected result.  Report failures and verbose results to stdout.
+  Update the result counts.  Return 1 if test failed, 0 if passed.  */
 
 static int
-do_test (void)
+compare (const char *buf, long int expect, unsigned int *nresult)
 {
-  int result = 0;
+  struct tm tm;
+  char *p;
+  bool test_string_valid;
+  long int test_result;
+  bool fail;
+  int result;
+
+  p = strptime (buf, "%s %z", &tm);
+  test_string_valid = p != NULL;
+  test_result = test_string_valid ? tm.tm_gmtoff : LONG_MAX;
+  fail = test_result != expect;
 
-  for (int i = 0; i < ntests; ++i)
+  if (fail || verbose)
     {
-      struct tm tm;
+      bool expect_string_valid = expect != LONG_MAX;
 
-      if (strptime (tests[i].fmt, "%s %z", &tm) == NULL)
-	{
-	  if (tests[i].gmtoff != LONG_MAX)
-	    {
-	      printf ("round %d: strptime unexpectedly failed\n", i);
-	      result = 1;
-	    }
-	  continue;
-	}
+      printf ("%s: input \"%s\", expected: ", fail ? "FAIL" : "PASS", buf);
+      describe (expect_string_valid, expect);
 
-      if (tm.tm_gmtoff != tests[i].gmtoff)
+      if (fail)
 	{
-	  printf ("round %d: tm_gmtoff is %ld\n", i, (long int) tm.tm_gmtoff);
-	  result = 1;
+	  printf (", got: ");
+	  describe (test_string_valid, test_result);
 	}
+
+      printf ("\n");
     }
 
+  result = fail ? 1 : 0;
+  nresult[result]++;
+
+  return result;
+}
+
+
+static int
+do_test (void)
+{
+  char buf[buffer_size];
+  long int expect;
+  int result = 0;
+  /* Number of tests run with passing (index==0) and failing (index==1)
+     results.  */
+  unsigned int nresult[2];
+  unsigned int ndigits;
+  unsigned int step;
+  unsigned int hhmm;
+
+  nresult[0] = 0;
+  nresult[1] = 0;
+
+  /* Create and test input string with no sign and four digits input
+     (invalid format).  */
+
+  sprintf (buf, "%s  1030", dummy_string);
+  expect = LONG_MAX;
+  result |= compare (buf, expect, nresult);
+
+  /* Create and test input strings with sign and digits:
+     0 digits (invalid format),
+     1 digit (invalid format),
+     2 digits (valid format),
+     3 digits (invalid format),
+     4 digits (valid format if and only if minutes is in range 00-59,
+	       otherwise invalid).
+     If format is valid, the returned tm_gmtoff is checked.  */
+
+  for (ndigits = 0, step = 10000; ndigits <= 4; ndigits++, step /= 10)
+    for (hhmm = 0; hhmm <= 9999; hhmm += step)
+      {
+	/* Test both positive and negative signs.  */
+
+	expect = mkbuf (buf, false, hhmm, ndigits);
+	result |= compare (buf, expect, nresult);
+
+	expect = mkbuf (buf, true, hhmm, ndigits);
+	result |= compare (buf, expect, nresult);
+      }
+
+  if (result > 0 || verbose)
+    printf ("%s: %u input strings: %u fail, %u pass\n",
+	    result > 0 ? "FAIL" : "PASS",
+	    nresult[1] + nresult[0], nresult[1], nresult[0]);
+
   return result;
 }
 
+
+/* Add a "--verbose" command line option to test-skeleton.c.  */
+
+#define OPT_VERBOSE 10000
+
+#define CMDLINE_OPTIONS \
+  { "verbose", no_argument, NULL, OPT_VERBOSE, },
+
+#define CMDLINE_PROCESS \
+  case OPT_VERBOSE: \
+    verbose = true; \
+    break;
+
 #define TEST_FUNCTION do_test ()
 #include "../test-skeleton.c"