LCOV - code coverage report
Current view: top level - common - t-gettime.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 36 64 56.2 %
Date: 2016-09-12 12:29:17 Functions: 4 4 100.0 %

          Line data    Source code
       1             : /* t-gettime.c - Module test for gettime.c
       2             :  *      Copyright (C) 2007, 2011 Free Software Foundation, Inc.
       3             :  *
       4             :  * This file is part of GnuPG.
       5             :  *
       6             :  * GnuPG is free software; you can redistribute it and/or modify
       7             :  * it under the terms of the GNU General Public License as published by
       8             :  * the Free Software Foundation; either version 3 of the License, or
       9             :  * (at your option) any later version.
      10             :  *
      11             :  * GnuPG is distributed in the hope that it will be useful,
      12             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      13             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14             :  * GNU General Public License for more details.
      15             :  *
      16             :  * You should have received a copy of the GNU General Public License
      17             :  * along with this program; if not, see <http://www.gnu.org/licenses/>.
      18             :  */
      19             : 
      20             : #include <config.h>
      21             : #include <stdio.h>
      22             : #include <stdlib.h>
      23             : 
      24             : #include "util.h"
      25             : 
      26             : #define pass()  do { ; } while(0)
      27             : #define fail(a)  do { fprintf (stderr, "%s:%d: test %d failed\n",\
      28             :                                __FILE__,__LINE__, (a));          \
      29             :                      errcount++;                                 \
      30             :                    } while(0)
      31             : 
      32             : static int verbose;
      33             : static int errcount;
      34             : #define INVALID ((time_t)(-1))
      35             : 
      36             : 
      37             : static void
      38           1 : test_isotime2epoch (void)
      39             : {
      40           1 :   struct { const char *string; time_t expected; } array [] = {
      41             :     { "19700101T000001",  1 },
      42             :     { "19700101T235959",  86399 },
      43             :     { "19980815T143712",  903191832 },
      44             :     { "19700101T000000",  0 },
      45             :     { "19691231T235959",  INVALID },
      46             :     { "19000101T000000",  INVALID },
      47             :     { "",                 INVALID },
      48             :     { "19000101T00000",   INVALID },
      49             :     { "20010101t123456",  INVALID },
      50             :     { "20010101T123456",  978352496 },
      51             :     { "20070629T160000",  1183132800 },
      52             :     { "20070629T160000:",  1183132800 },
      53             :     { "20070629T160000,",  1183132800 },
      54             :     { "20070629T160000 ",  1183132800 },
      55             :     { "20070629T160000\n", 1183132800 },
      56             :     { "20070629T160000.",  INVALID },
      57             : #if SIZEOF_TIME_T > 4
      58             :     { "21060207T062815", (time_t)0x0ffffffff },
      59             :     { "21060207T062816", (time_t)0x100000000 },
      60             :     { "21060207T062817", (time_t)0x100000001 },
      61             :     { "21060711T120001", (time_t)4308292801  },
      62             : #endif /*SIZEOF_TIME_T > 4*/
      63             :     { NULL, 0 }
      64             :   };
      65             :   int idx;
      66             :   time_t val;
      67             :   gnupg_isotime_t tbuf;
      68             : 
      69          21 :   for (idx=0; array[idx].string; idx++)
      70             :     {
      71          20 :       val = isotime2epoch (array[idx].string);
      72          20 :       if (val != array[idx].expected )
      73             :         {
      74           0 :           fail (idx);
      75           0 :           if (verbose)
      76           0 :             fprintf (stderr, "string '%s' exp: %ld got: %ld\n",
      77             :                      array[idx].string, (long)array[idx].expected,
      78             :                      (long)val);
      79             :         }
      80          20 :       if (array[idx].expected != INVALID)
      81             :         {
      82          14 :           epoch2isotime (tbuf, val);
      83          14 :           if (strlen (tbuf) != 15)
      84             :             {
      85           0 :               if (verbose)
      86           0 :                 fprintf (stderr, "string '%s', time-t %ld, revert: '%s'\n",
      87             :                          array[idx].string, (long)val, tbuf);
      88           0 :               fail (idx);
      89             :             }
      90          14 :           if (strncmp (array[idx].string, tbuf, 15))
      91           0 :             fail (idx);
      92             :         }
      93             :     }
      94           1 : }
      95             : 
      96             : 
      97             : 
      98             : static void
      99           1 : test_string2isotime (void)
     100             : {
     101             :   struct {
     102             :     const char *string;
     103             :     size_t result;
     104             :     const char *expected;
     105           1 :   } array [] = {
     106             :     { "19700101T000001",      15, "19700101T000001" },
     107             :     { "19700101T235959",      15, "19700101T235959" },
     108             :     { "19980815T143712",      15, "19980815T143712" },
     109             :     { "19700101T000000",      15, "19700101T000000" },
     110             :     { "19691231T235959",      15, "19691231T235959" },
     111             :     { "19000101T000000",      15, "19000101T000000" },
     112             :     { "",                      0, ""                },
     113             :     { "19000101T00000",        0, ""                },
     114             :     { "20010101t123456",       0, ""                },
     115             :     { "20010101T123456",      15, "20010101T123456" },
     116             :     { "20070629T160000",      15, "20070629T160000" },
     117             :     { "20070629T160000:",     15, "20070629T160000" },
     118             :     { "20070629T160000,",     15, "20070629T160000" },
     119             :     { "20070629T160000 ",     15, "20070629T160000" },
     120             :     { "20070629T160000\n",    15,"20070629T160000"  },
     121             :     { "20070629T160000.",      0, ""                },
     122             :     { "1066-03-20",           10, "10660320T000000" },
     123             :     { "1066-03-20,",          10, "10660320T000000" },
     124             :     { "1066-03-20:",           0, ""                },
     125             :     { "1066-03-20 00",        13, "10660320T000000" },
     126             :     { "1066-03-20 01",        13, "10660320T010000" },
     127             :     { "1066-03-20 23",        13, "10660320T230000" },
     128             :     { "1066-03-20 24",         0, ""                },
     129             :     { "1066-03-20 00:",        0, ""                },
     130             :     { "1066-03-20 00:3",       0, ""                },
     131             :     { "1066-03-20 00:31",     16, "10660320T003100" },
     132             :     { "1066-03-20 00:31:47",  19, "10660320T003147" },
     133             :     { "1066-03-20 00:31:47 ", 19, "10660320T003147" },
     134             :     { "1066-03-20 00:31:47,", 19, "10660320T003147" },
     135             :     { "1066-03-20 00:31:47:",  0, ""                },
     136             :     { "1-03-20 00:31:47:",     0, ""                },
     137             :     { "10-03-20 00:31:47:",    0, ""                },
     138             :     { "106-03-20 00:31:47:",   0, ""                },
     139             :     { "1066-23-20 00:31:47:",  0, ""                },
     140             :     { "1066-00-20 00:31:47:",  0, ""                },
     141             :     { "1066-0-20 00:31:47:",   0, ""                },
     142             :     { "1066-01-2 00:31:47:",   0, ""                },
     143             :     { "1066-01-2  00:31:47:",  0, ""                },
     144             :     { "1066-01-32 00:31:47:",  0, ""                },
     145             :     { "1066-01-00 00:31:47:",  0, ""                },
     146             :     { "1066-03-20  00:31:47:",11, "10660320T000000" },
     147             :     { "1066-03-2000:31:47:",   0, ""                },
     148             :     { "10666-03-20 00:31:47:", 0, ""                },
     149             :     { NULL, 0 }
     150             :   };
     151             :   int idx;
     152             :   size_t result;
     153             :   gnupg_isotime_t tbuf;
     154             : 
     155          44 :   for (idx=0; array[idx].string; idx++)
     156             :     {
     157          43 :       result = string2isotime (tbuf, array[idx].string);
     158          43 :       if (result != array[idx].result)
     159             :         {
     160           0 :           fail (idx);
     161           0 :           if (verbose)
     162           0 :             fprintf (stderr, "string '%s' expected: %d, got: %d\n",
     163           0 :                      array[idx].string, (int)array[idx].result, (int)result);
     164             :         }
     165          43 :       else if (result && strlen (tbuf) != 15)
     166             :         {
     167           0 :           fail (idx);
     168           0 :           if (verbose)
     169           0 :             fprintf (stderr, "string '%s' invalid isotime returned\n",
     170             :                      array[idx].string);
     171             :         }
     172          43 :       else if (result && strcmp (array[idx].expected, tbuf))
     173             :         {
     174           0 :           fail (idx);
     175           0 :           if (verbose)
     176           0 :             fprintf (stderr, "string '%s' bad isotime '%s' returned\n",
     177             :                      array[idx].string, tbuf);
     178             :         }
     179             :     }
     180           1 : }
     181             : 
     182             : 
     183             : static void
     184           1 : test_isodate_human_to_tm (void)
     185             : {
     186             :   struct {
     187             :     const char *string;
     188             :     int okay;
     189             :     int year, mon, mday;
     190           1 :   } array [] = {
     191             :     { "1970-01-01",      1, 1970,  1,  1 },
     192             :     { "1970-02-01",      1, 1970,  2,  1 },
     193             :     { "1970-12-31",      1, 1970, 12, 31 },
     194             :     { "1971-01-01",      1, 1971,  1,  1 },
     195             :     { "1998-08-15",      1, 1998,  8, 15 },
     196             :     { "2015-04-10",      1, 2015,  4, 10 },
     197             :     { "2015-04-10 11:30",1, 2015,  4, 10 },
     198             :     { "1969-12-31",      0,    0,  0,  0 },
     199             :     { "1900-01-01",      0,    0,  0,  0 },
     200             :     { "",                0,    0,  0,  0 },
     201             :     { "1970-12-32",      0,    0,  0,  0 },
     202             :     { "1970-13-01",      0,    0,  0,  0 },
     203             :     { "1970-01-00",      0,    0,  0,  0 },
     204             :     { "1970-00-01",      0,    0,  0,  0 },
     205             :     { "1970-00-01",      0,    0,  0,  0 },
     206             :     { "1970",            0,    0,  0,  0 },
     207             :     { "1970-01",         0,    0,  0,  0 },
     208             :     { "1970-01-1",       0,    0,  0,  0 },
     209             :     { "1970-1--01",      0,    0,  0,  0 },
     210             :     { "1970-01-01,",     1, 1970,  1,  1 },
     211             :     { "1970-01-01 ",     1, 1970,  1,  1 },
     212             :     { "1970-01-01\t",    1, 1970,  1,  1 },
     213             :     { "1970-01-01;",     0,    0,  0,  0 },
     214             :     { "1970-01-01:",     0,    0,  0,  0 },
     215             :     { "1970_01-01",      0,    0,  0,  0 },
     216             :     { "1970-01_01",      0,    0,  0,  0 },
     217             :     { NULL, 0 }
     218             :   };
     219             :   int idx;
     220             :   int okay;
     221             :   struct tm tmbuf;
     222             : 
     223          27 :   for (idx=0; array[idx].string; idx++)
     224             :     {
     225          26 :       okay = !isodate_human_to_tm (array[idx].string, &tmbuf);
     226          26 :       if (okay != array[idx].okay)
     227             :         {
     228           0 :           fail (idx);
     229           0 :           if (verbose)
     230           0 :             fprintf (stderr, "string '%s' expected: %d, got: %d\n",
     231             :                      array[idx].string, (int)array[idx].okay, okay);
     232             :         }
     233          26 :       else if (!okay)
     234             :         ;
     235          10 :       else if (tmbuf.tm_year + 1900 != array[idx].year
     236          10 :                || tmbuf.tm_mon +1   != array[idx].mon
     237          10 :                || tmbuf.tm_mday     != array[idx].mday)
     238             :         {
     239           0 :           fail (idx);
     240           0 :           if (verbose)
     241           0 :             fprintf (stderr, "string '%s' returned %04d-%02d-%02d\n",
     242             :                      array[idx].string,
     243           0 :                      tmbuf.tm_year + 1900, tmbuf.tm_mon + 1, tmbuf.tm_mday);
     244             :         }
     245          10 :       else if (tmbuf.tm_sec || tmbuf.tm_min || tmbuf.tm_hour
     246          10 :                || tmbuf.tm_isdst != -1)
     247             :         {
     248           0 :           fail (idx);
     249           0 :           if (verbose)
     250           0 :             fprintf (stderr, "string '%s' returned bad time part\n",
     251             :                      array[idx].string);
     252             :         }
     253             :     }
     254           1 : }
     255             : 
     256             : 
     257             : int
     258           1 : main (int argc, char **argv)
     259             : {
     260           1 :   if (argc > 1 && !strcmp (argv[1], "--verbose"))
     261           0 :     verbose = 1;
     262             : 
     263           1 :   test_isotime2epoch ();
     264           1 :   test_string2isotime ();
     265           1 :   test_isodate_human_to_tm ();
     266             : 
     267           1 :   return !!errcount;
     268             : }

Generated by: LCOV version 1.11