LCOV - code coverage report
Current view: top level - tests - hashtest.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 32 211 15.2 %
Date: 2016-09-12 12:56:58 Functions: 2 10 20.0 %

          Line data    Source code
       1             : /* hashtest.c - Check the hash fucntions
       2             :  * Copyright (C) 2013 g10 Code GmbH
       3             :  *
       4             :  * This file is part of Libgcrypt.
       5             :  *
       6             :  * Libgcrypt is free software; you can redistribute it and/or modify
       7             :  * it under the terms of the GNU Lesser General Public License as
       8             :  * published by the Free Software Foundation; either version 2.1 of
       9             :  * the License, or (at your option) any later version.
      10             :  *
      11             :  * Libgcrypt 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 Lesser General Public License for more details.
      15             :  *
      16             :  * You should have received a copy of the GNU Lesser General Public
      17             :  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
      18             :  */
      19             : 
      20             : #ifdef HAVE_CONFIG_H
      21             : #include <config.h>
      22             : #endif
      23             : #include <stdarg.h>
      24             : #include <stdio.h>
      25             : #include <ctype.h>
      26             : #include <stdlib.h>
      27             : #include <string.h>
      28             : #include <errno.h>
      29             : 
      30             : #include "../src/gcrypt-int.h"
      31             : 
      32             : #include "stopwatch.h"
      33             : 
      34             : #define PGM "hashtest"
      35             : 
      36             : #define my_isascii(c) (!((c) & 0x80))
      37             : #define digitp(p)   (*(p) >= '0' && *(p) <= '9')
      38             : #define hexdigitp(a) (digitp (a)                     \
      39             :                       || (*(a) >= 'A' && *(a) <= 'F')  \
      40             :                       || (*(a) >= 'a' && *(a) <= 'f'))
      41             : #define xtoi_1(p)   (*(p) <= '9'? (*(p)- '0'): \
      42             :                      *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10))
      43             : #define xtoi_2(p)   ((xtoi_1(p) * 16) + xtoi_1((p)+1))
      44             : #define xmalloc(a)    gcry_xmalloc ((a))
      45             : #define xcalloc(a,b)  gcry_xcalloc ((a),(b))
      46             : #define xstrdup(a)    gcry_xstrdup ((a))
      47             : #define xfree(a)      gcry_free ((a))
      48             : #define pass()        do { ; } while (0)
      49             : 
      50             : static int verbose;
      51             : static int debug;
      52             : static int error_count;
      53             : static int missing_test_vectors;
      54             : 
      55             : static struct {
      56             :   int algo;
      57             :   int gigs;
      58             :   int bytes;
      59             :   const char *hex;
      60             : } testvectors[] = {
      61             :   { GCRY_MD_SHA1, 256, -64, "92fc51850c7b750e6e774b75f294f6979d4059f0" },
      62             :   { GCRY_MD_SHA1, 256,  -1, "4bddeeb4c08683f02d4944d93dbcb02ebab50134" },
      63             :   { GCRY_MD_SHA1, 256,  -0, "71b923afde1c8c040884c723a2e3335b333e64c6" },
      64             :   { GCRY_MD_SHA1, 256,   1, "2d99f9b5b86e9c9c937104f4242bd6b8bc0927ef" },
      65             :   { GCRY_MD_SHA1, 256,  64, "a60dabe8d749f798b7ec3a684cc3eab487451482" },
      66             : 
      67             :   { GCRY_MD_SHA224, 256, -64,
      68             :     "b5672b54d2480a5688a2dc727a1ad4db7a81ef31ce8999e0bbaeffdc" },
      69             :   { GCRY_MD_SHA224, 256,  -1,
      70             :     "814ea7159473e6ffc1c64b90026a542e13ac6980f7f3ca3c4582a9b8" },
      71             :   { GCRY_MD_SHA224, 256,   0,
      72             :     "9ec0e1829455db8650ec7a8b06912196f97a7358bc3a73c79911cd4e" },
      73             :   { GCRY_MD_SHA224, 256,   1,
      74             :     "e578d5d523320876565bbbc892511a485427caee6dd754d57e3e58c2" },
      75             :   { GCRY_MD_SHA224, 256,  64,
      76             :     "ff0464df248cd298b63765bc4f87f21e25c93c657fdf3656d3c878e5" },
      77             : 
      78             :   { GCRY_MD_SHA256, 256, -64,
      79             :     "87a9828d3de78d55d252341db2a622908c4e0ceaee9961ecf9768700fc799ec8" },
      80             :   { GCRY_MD_SHA256, 256,  -1,
      81             :     "823bf95f64ef04a4a77579c38760b1d401b56bf3a8e664bdf56ca15afb468a03" },
      82             :   { GCRY_MD_SHA256, 256,   0,
      83             :     "2d0723878cb2c3d5c59dfad910cdb857f4430a6ba2a7d687938d7a20e63dde47" },
      84             :   { GCRY_MD_SHA256, 256,   1,
      85             :     "5a2e21b1e79cd866acf53a2a18ca76bd4e02c4b01bf4627354171824c812d95f" },
      86             :   { GCRY_MD_SHA256, 256,  64,
      87             :     "34444808af8e9d995e67f9e155ed94bf55f195a51dc1d8a989e6bcf95511c8a2" },
      88             : 
      89             :   { GCRY_MD_SHA512, 256, -64,
      90             :     "e01bf8140874bf240e8426cb2bcbc377cbed2e6037334116637149e1cd8cd462"
      91             :     "96828b71f32b9f002771d4cb51172ce578b73b7939221e4df655ecd08601e655" },
      92             :   { GCRY_MD_SHA512, 256,  -1,
      93             :     "4917ff94514b1757705c289fdc3e7d6ffcce5771b20ae237ebc03d2ec9eb435f"
      94             :     "b7ce9f0e27272be8cced77a5edae1a01a0ad62b0a44169d88bbee45474a17734" },
      95             :   { GCRY_MD_SHA512, 256,   0,
      96             :     "1e28e8b3c79f2f47da11f3c0b7da4e7981e7d932db6d17d528a31e191922edda"
      97             :     "8fc4bb2df10ea876232db5a1c606bc41886e8b2c570a3e721221f60c8c7dc4ab" },
      98             :   { GCRY_MD_SHA512, 256,   1,
      99             :     "027d3324dd1cf127770ceb53681f4c70937c9bca4e3acd5fd76cb266c7d4527d"
     100             :     "58140290a1822e8d60c4d3ae9725fb923183230d6dfd2d7d73c0d74a4757f34a" },
     101             :   { GCRY_MD_SHA512, 256,  64,
     102             :     "49920704ea9d6ee19f0742d6c868110fa3eda8ac09f026e9ef22cc731af53020"
     103             :     "de40eedef66cb1afd94c61e285fa9327e01336e804903740a9145ab1f065c2d5" },
     104             : 
     105             :   { GCRY_MD_SHA3_512, 256, -64,
     106             :     "c6e082b3db996dbe5f2c5709818a7f325ef4febd883d7e9c545c06bfa7225198"
     107             :     "1ecf40103788913cd5a5bdf13246b952ded6651043684b24197eb23544882a97" },
     108             :   { GCRY_MD_SHA3_512, 256,  -1,
     109             :     "d7bf28e8216bf7d3d0d3969e34078e94b98598e17b6f21f256379389e4eba8ee"
     110             :     "74eb288774797263fec00bdfd357d132cea9e408be36b982f5a60ab56ad01613" },
     111             :   { GCRY_MD_SHA3_512, 256,  +0,
     112             :     "c1270852ba7b1e1a3eaa777969b8a65be28c3894537c61eb8cd22b1df6af703d"
     113             :     "b59939f6adadeb64317faece8167d4817e73daf73e28a5ccd26bebee0a35c322" },
     114             :   { GCRY_MD_SHA3_512, 256,  +1,
     115             :     "8bdfeb3a1a9a1cdcef21172cbc5bb3b87c0d8f7111df0aaf7f1bc03ad4775bd6"
     116             :     "a03e0a875c4e7d02d2230c213562c6a57be28d92eaf6e4bea4bc24690454c8ef" },
     117             :   { GCRY_MD_SHA3_512, 256, +64,
     118             :     "0c91b91665ceaf7af5102e0ed31aa4f050668ab3c57b1f4763946d567efe66b3"
     119             :     "ab9a2016cf238dee5b44eae9f0cdfbf7b7a6eb1e759986273243dc35894706b6" },
     120             : 
     121             :   { 0 }
     122             : };
     123             : 
     124             : 
     125             : 
     126             : static void
     127           0 : die (const char *format, ...)
     128             : {
     129             :   va_list arg_ptr ;
     130             : 
     131           0 :   fflush (stdout);
     132           0 :   fprintf (stderr, "%s: ", PGM);
     133           0 :   va_start( arg_ptr, format ) ;
     134           0 :   vfprintf (stderr, format, arg_ptr );
     135           0 :   va_end(arg_ptr);
     136           0 :   if (*format && format[strlen(format)-1] != '\n')
     137           0 :     putc ('\n', stderr);
     138           0 :   exit (1);
     139             : }
     140             : 
     141             : static void
     142           0 : fail (const char *format, ...)
     143             : {
     144             :   va_list arg_ptr;
     145             : 
     146           0 :   fflush (stdout);
     147           0 :   fprintf (stderr, "%s: ", PGM);
     148             :   /* if (wherestr) */
     149             :   /*   fprintf (stderr, "%s: ", wherestr); */
     150           0 :   va_start (arg_ptr, format);
     151           0 :   vfprintf (stderr, format, arg_ptr);
     152           0 :   va_end (arg_ptr);
     153           0 :   if (*format && format[strlen(format)-1] != '\n')
     154           0 :     putc ('\n', stderr);
     155           0 :   error_count++;
     156           0 :   if (error_count >= 50)
     157           0 :     die ("stopped after 50 errors.");
     158           0 : }
     159             : 
     160             : static void
     161           0 : show (const char *format, ...)
     162             : {
     163             :   va_list arg_ptr;
     164             : 
     165           0 :   fprintf (stderr, "%s: ", PGM);
     166           0 :   va_start (arg_ptr, format);
     167           0 :   vfprintf (stderr, format, arg_ptr);
     168           0 :   if (*format && format[strlen(format)-1] != '\n')
     169           0 :     putc ('\n', stderr);
     170           0 :   va_end (arg_ptr);
     171           0 : }
     172             : 
     173             : 
     174             : static void
     175           0 : showhex (const void *buffer, size_t buflen, const char *format, ...)
     176             : {
     177             :   va_list arg_ptr;
     178             :   const unsigned char *s;
     179             : 
     180           0 :   fprintf (stderr, "%s: ", PGM);
     181           0 :   va_start (arg_ptr, format);
     182           0 :   vfprintf (stderr, format, arg_ptr);
     183           0 :   va_end (arg_ptr);
     184             : 
     185           0 :   for (s=buffer; buflen; buflen--, s++)
     186           0 :     fprintf (stderr, "%02x", *s);
     187           0 :   putc ('\n', stderr);
     188           0 : }
     189             : 
     190             : 
     191             : static void
     192           0 : show_note (const char *format, ...)
     193             : {
     194             :   va_list arg_ptr;
     195             : 
     196           0 :   if (!verbose && getenv ("srcdir"))
     197           0 :     fputs ("      ", stderr);  /* To align above "PASS: ".  */
     198             :   else
     199           0 :     fprintf (stderr, "%s: ", PGM);
     200           0 :   va_start (arg_ptr, format);
     201           0 :   vfprintf (stderr, format, arg_ptr);
     202           0 :   if (*format && format[strlen(format)-1] != '\n')
     203           0 :     putc ('\n', stderr);
     204           0 :   va_end (arg_ptr);
     205           0 : }
     206             : 
     207             : /* Convert STRING consisting of hex characters into its binary
     208             :    representation and return it as an allocated buffer. The valid
     209             :    length of the buffer is returned at R_LENGTH.  The string is
     210             :    delimited by end of string.  The function returns NULL on
     211             :    error.  */
     212             : static void *
     213           0 : hex2buffer (const char *string, size_t *r_length)
     214             : {
     215             :   const char *s;
     216             :   unsigned char *buffer;
     217             :   size_t length;
     218             : 
     219           0 :   buffer = xmalloc (strlen(string)/2+1);
     220           0 :   length = 0;
     221           0 :   for (s=string; *s; s +=2 )
     222             :     {
     223           0 :       if (!hexdigitp (s) || !hexdigitp (s+1))
     224           0 :         return NULL;           /* Invalid hex digits. */
     225           0 :       ((unsigned char*)buffer)[length++] = xtoi_2 (s);
     226             :     }
     227           0 :   *r_length = length;
     228           0 :   return buffer;
     229             : }
     230             : 
     231             : 
     232             : static void
     233          25 : run_selftest (int algo)
     234             : {
     235             :   gpg_error_t err;
     236             :   size_t n;
     237             : 
     238          25 :   n = 1;
     239          25 :   err = gcry_md_algo_info (algo, GCRYCTL_SELFTEST, NULL, &n);
     240          25 :   if (err && gpg_err_code (err) != GPG_ERR_NOT_IMPLEMENTED)
     241           0 :     fail ("extended selftest for %s (%d) failed: %s",
     242             :           gcry_md_algo_name (algo), algo, gpg_strerror (err));
     243          25 :   else if (err && verbose)
     244           0 :     show ("extended selftest for %s (%d) not implemented",
     245             :           gcry_md_algo_name (algo), algo);
     246          25 :   else if (verbose)
     247           0 :     show ("extended selftest for %s (%d) passed",
     248             :           gcry_md_algo_name (algo), algo);
     249          25 : }
     250             : 
     251             : /* Compare DIGEST of length DIGESTLEN generated using ALGO and GIGS
     252             :    plus BYTES with the test vector and print an error message if the
     253             :    don't match.  Return 0 on match.  */
     254             : static int
     255           0 : cmp_digest (const unsigned char *digest, size_t digestlen,
     256             :             int algo, int gigs, int bytes)
     257             : {
     258             :   int idx;
     259             :   unsigned char *tv_digest;
     260           0 :   size_t tv_digestlen = 0;
     261             : 
     262           0 :   for (idx=0; testvectors[idx].algo; idx++)
     263             :     {
     264           0 :       if (testvectors[idx].algo == algo
     265           0 :           && testvectors[idx].gigs == gigs
     266           0 :           && testvectors[idx].bytes == bytes)
     267           0 :         break;
     268             :     }
     269           0 :   if (!testvectors[idx].algo)
     270             :     {
     271           0 :       show ("%d GiB %+3d %-10s warning: %s",
     272             :             gigs, bytes, gcry_md_algo_name (algo), "no test vector");
     273           0 :       missing_test_vectors++;
     274           0 :       return 1;
     275             :     }
     276             : 
     277           0 :   tv_digest = hex2buffer (testvectors[idx].hex, &tv_digestlen);
     278           0 :   if (tv_digestlen != digestlen) /* Ooops.  */
     279             :     {
     280           0 :       fail ("%d GiB %+3d %-10s error: %s",
     281             :             gigs, bytes, gcry_md_algo_name (algo), "digest length mismatch");
     282           0 :       xfree (tv_digest);
     283           0 :       return 1;
     284             :     }
     285           0 :   if (memcmp (tv_digest, digest, tv_digestlen))
     286             :     {
     287           0 :       fail ("%d GiB %+3d %-10s error: %s",
     288             :             gigs, bytes, gcry_md_algo_name (algo), "mismatch");
     289           0 :       xfree (tv_digest);
     290           0 :       return 1;
     291             :     }
     292           0 :   xfree (tv_digest);
     293             : 
     294           0 :   return 0;
     295             : }
     296             : 
     297             : 
     298             : static void
     299           0 : run_longtest (int algo, int gigs)
     300             : {
     301             :   gpg_error_t err;
     302             :   gcry_md_hd_t hd;
     303           0 :   gcry_md_hd_t hd_pre = NULL;
     304           0 :   gcry_md_hd_t hd_pre2 = NULL;
     305           0 :   gcry_md_hd_t hd_post = NULL;
     306           0 :   gcry_md_hd_t hd_post2 = NULL;
     307             :   char pattern[1024];
     308             :   int i, g;
     309             :   const unsigned char *digest;
     310             :   unsigned int digestlen;
     311             : 
     312           0 :   memset (pattern, 'a', sizeof pattern);
     313             : 
     314           0 :   err = gcry_md_open (&hd, algo, 0);
     315           0 :   if (err)
     316             :     {
     317           0 :       fail ("gcry_md_open failed for %s (%d): %s",
     318             :             gcry_md_algo_name (algo), algo, gpg_strerror (err));
     319           0 :       return;
     320             :     }
     321             : 
     322           0 :   digestlen = gcry_md_get_algo_dlen (algo);
     323             : 
     324             : 
     325           0 :   for (g=0; g < gigs; g++)
     326             :     {
     327           0 :       if (g == gigs - 1)
     328             :         {
     329           0 :           for (i = 0; i < 1024*1023; i++)
     330           0 :             gcry_md_write (hd, pattern, sizeof pattern);
     331           0 :           for (i = 0; i < 1023; i++)
     332           0 :             gcry_md_write (hd, pattern, sizeof pattern);
     333           0 :           err = gcry_md_copy (&hd_pre, hd);
     334           0 :           if (!err)
     335           0 :             err = gcry_md_copy (&hd_pre2, hd);
     336           0 :           if (err)
     337           0 :             die ("gcry_md_copy failed for %s (%d): %s",
     338             :                  gcry_md_algo_name (algo), algo, gpg_strerror (err));
     339           0 :           gcry_md_write (hd, pattern, sizeof pattern);
     340             :         }
     341             :       else
     342             :         {
     343           0 :           for (i = 0; i < 1024*1024; i++)
     344           0 :             gcry_md_write (hd, pattern, sizeof pattern);
     345             :         }
     346           0 :       if (g && !(g % 16))
     347           0 :         show_note ("%d GiB so far hashed with %s", g, gcry_md_algo_name (algo));
     348             :     }
     349           0 :   if (g >= 16)
     350           0 :     show_note ("%d GiB hashed with %s", g, gcry_md_algo_name (algo));
     351             : 
     352           0 :   err = gcry_md_copy (&hd_post, hd);
     353           0 :   if (err)
     354           0 :     die ("gcry_md_copy failed for %s (%d): %s",
     355             :          gcry_md_algo_name (algo), algo, gpg_strerror (err));
     356           0 :   err = gcry_md_copy (&hd_post2, hd);
     357           0 :   if (err)
     358           0 :     die ("gcry_md_copy failed for %s (%d): %s",
     359             :          gcry_md_algo_name (algo), algo, gpg_strerror (err));
     360             : 
     361           0 :   gcry_md_write (hd_pre2, pattern, sizeof pattern - 64);
     362           0 :   gcry_md_write (hd_pre, pattern, sizeof pattern - 1);
     363           0 :   gcry_md_write (hd_post, pattern, 1);
     364           0 :   gcry_md_write (hd_post2, pattern, 64);
     365             : 
     366           0 :   digest = gcry_md_read (hd_pre2, algo);
     367           0 :   if (cmp_digest (digest, digestlen, algo, gigs, -64) || verbose)
     368           0 :     showhex (digest, digestlen, "%d GiB %+3d %-10s ",
     369             :              gigs, -64, gcry_md_algo_name (algo));
     370           0 :   digest = gcry_md_read (hd_pre, algo);
     371           0 :   if (cmp_digest (digest, digestlen, algo, gigs, -1) || verbose)
     372           0 :     showhex (digest, digestlen, "%d GiB %+3d %-10s ",
     373             :              gigs, -1, gcry_md_algo_name (algo));
     374           0 :   digest = gcry_md_read (hd, algo);
     375           0 :   if (cmp_digest (digest, digestlen, algo, gigs, 0) || verbose)
     376           0 :     showhex (digest, digestlen, "%d GiB %+3d %-10s ",
     377             :              gigs, 0, gcry_md_algo_name (algo));
     378           0 :   digest = gcry_md_read (hd_post, algo);
     379           0 :   if (cmp_digest (digest, digestlen, algo, gigs, 1) || verbose)
     380           0 :     showhex (digest, digestlen, "%d GiB %+3d %-10s ",
     381             :              gigs, 1, gcry_md_algo_name (algo));
     382           0 :   digest = gcry_md_read (hd_post2, algo);
     383           0 :   if (cmp_digest (digest, digestlen, algo, gigs, 64) || verbose)
     384           0 :     showhex (digest, digestlen, "%d GiB %+3d %-10s ",
     385             :              gigs, 64, gcry_md_algo_name (algo));
     386             : 
     387           0 :   gcry_md_close (hd);
     388           0 :   gcry_md_close (hd_pre);
     389           0 :   gcry_md_close (hd_pre2);
     390           0 :   gcry_md_close (hd_post);
     391           0 :   gcry_md_close (hd_post2);
     392             : }
     393             : 
     394             : 
     395             : int
     396           1 : main (int argc, char **argv)
     397             : {
     398           1 :   int last_argc = -1;
     399           1 :   int gigs = 0;
     400           1 :   int algo = 0;
     401             :   int idx;
     402             : 
     403           1 :   if (argc)
     404           1 :     { argc--; argv++; }
     405             : 
     406           2 :   while (argc && last_argc != argc )
     407             :     {
     408           0 :       last_argc = argc;
     409           0 :       if (!strcmp (*argv, "--"))
     410             :         {
     411           0 :           argc--; argv++;
     412           0 :           break;
     413             :         }
     414           0 :       else if (!strcmp (*argv, "--help"))
     415             :         {
     416           0 :           fputs ("usage: " PGM " [options] [algos]\n"
     417             :                  "Options:\n"
     418             :                  "  --verbose       print timings etc.\n"
     419             :                  "  --debug         flyswatter\n"
     420             :                  "  --gigs N        Run a test on N GiB\n",
     421             :                  stdout);
     422           0 :           exit (0);
     423             :         }
     424           0 :       else if (!strcmp (*argv, "--verbose"))
     425             :         {
     426           0 :           verbose++;
     427           0 :           argc--; argv++;
     428             :         }
     429           0 :       else if (!strcmp (*argv, "--debug"))
     430             :         {
     431           0 :           verbose += 2;
     432           0 :           debug++;
     433           0 :           argc--; argv++;
     434             :         }
     435           0 :       else if (!strcmp (*argv, "--gigs"))
     436             :         {
     437           0 :           argc--; argv++;
     438           0 :           if (argc)
     439             :             {
     440           0 :               gigs = atoi (*argv);
     441           0 :               argc--; argv++;
     442             :             }
     443             :         }
     444           0 :       else if (!strncmp (*argv, "--", 2))
     445           0 :         die ("unknown option '%s'", *argv);
     446             :     }
     447             : 
     448           1 :   if (gigs < 0 || gigs > 1024*1024)
     449           0 :     die ("value for --gigs must be in the range 0 to %d", 1024*1024);
     450             : 
     451           1 :   gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
     452           1 :   if (!gcry_check_version (GCRYPT_VERSION))
     453           0 :     die ("version mismatch\n");
     454           1 :   if (debug)
     455           0 :     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u , 0);
     456           1 :   gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
     457           1 :   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
     458             : 
     459             :   /* A quick check that all given algorithms are valid.  */
     460           1 :   for (idx=0; idx < argc; idx++)
     461             :     {
     462           0 :       algo = gcry_md_map_name (argv[idx]);
     463           0 :       if (!algo)
     464           0 :         fail ("invalid algorithm '%s'", argv[idx]);
     465             :     }
     466           1 :   if (error_count)
     467           0 :     exit (1);
     468             : 
     469             :   /* Start checking.  */
     470           1 :   start_timer ();
     471           1 :   if (!argc)
     472             :     {
     473         400 :       for (algo=1; algo < 400; algo++)
     474         399 :         if (!gcry_md_test_algo (algo))
     475             :           {
     476          25 :             if (!gigs)
     477          25 :               run_selftest (algo);
     478             :             else
     479           0 :               run_longtest (algo, gigs);
     480             :           }
     481             :      }
     482             :   else
     483             :     {
     484           0 :       for (idx=0; idx < argc; idx++)
     485             :         {
     486           0 :           algo = gcry_md_map_name (argv[idx]);
     487           0 :           if (!algo)
     488           0 :             die ("invalid algorithm '%s'", argv[idx]);
     489             : 
     490           0 :           if (!gigs)
     491           0 :             run_selftest (algo);
     492             :           else
     493           0 :             run_longtest (algo, gigs);
     494             :         }
     495             :     }
     496           1 :   stop_timer ();
     497             : 
     498           1 :   if (missing_test_vectors)
     499           0 :     fail ("Some test vectors are missing");
     500             : 
     501           1 :   if (verbose)
     502           0 :     show ("All tests completed in %s.  Errors: %d\n",
     503             :           elapsed_time (1), error_count);
     504           1 :   return !!error_count;
     505             : }

Generated by: LCOV version 1.11