LCOV - code coverage report
Current view: top level - tests - t-convert.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 102 201 50.7 %
Date: 2016-09-12 12:23:59 Functions: 4 9 44.4 %

          Line data    Source code
       1             : /* t-convert.c  - Tests for mpi print and scna functions
       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 <stdio.h>
      24             : #include <stdlib.h>
      25             : #include <string.h>
      26             : #include <assert.h>
      27             : #include <stdarg.h>
      28             : 
      29             : #include "../src/gcrypt-int.h"
      30             : 
      31             : #define PGM "t-convert"
      32             : 
      33             : #define DIM(v)               (sizeof(v)/sizeof((v)[0]))
      34             : #define DIMof(type,member)   DIM(((type *)0)->member)
      35             : 
      36             : static const char *wherestr;
      37             : static int verbose;
      38             : static int debug;
      39             : static int error_count;
      40             : 
      41             : 
      42             : #define xmalloc(a)    gcry_xmalloc ((a))
      43             : #define xcalloc(a,b)  gcry_xcalloc ((a),(b))
      44             : #define xfree(a)      gcry_free ((a))
      45             : #define pass() do { ; } while (0)
      46             : 
      47             : static void
      48           1 : show (const char *format, ...)
      49             : {
      50             :   va_list arg_ptr;
      51             : 
      52           1 :   if (!verbose)
      53           2 :     return;
      54           0 :   fprintf (stderr, "%s: ", PGM);
      55           0 :   va_start (arg_ptr, format);
      56           0 :   vfprintf (stderr, format, arg_ptr);
      57           0 :   va_end (arg_ptr);
      58             : }
      59             : 
      60             : static void
      61           0 : showhex (const char *prefix, const void *buffer, size_t buflen)
      62             : {
      63             :   const unsigned char *s;
      64             : 
      65           0 :   if (!verbose)
      66           0 :     return;
      67           0 :   fprintf (stderr, "%s: %s ", PGM, prefix);
      68           0 :   for (s= buffer; buflen; buflen--, s++)
      69           0 :     fprintf (stderr, "%02x", *s);
      70           0 :   putc ('\n', stderr);
      71             : }
      72             : 
      73             : 
      74             : /* Allocate a bit string consisting of '0' and '1' from the MPI A.  Do
      75             :    not return any leading zero bits.  Caller needs to gcry_free the
      76             :    result. */
      77             : static char *
      78           0 : mpi2bitstr_nlz (gcry_mpi_t a)
      79             : {
      80             :   char *p, *buf;
      81           0 :   size_t length = gcry_mpi_get_nbits (a);
      82             : 
      83           0 :   if (!length)
      84             :     {
      85           0 :       buf = p = xmalloc (3);
      86           0 :       *p++ = ' ';
      87           0 :       *p++ = '0';
      88             :     }
      89             :   else
      90             :     {
      91           0 :       buf = p = xmalloc (length + 1 + 1);
      92           0 :       *p++ = gcry_mpi_is_neg (a)? '-':' ';
      93           0 :       while (length-- > 1)
      94           0 :         *p++ = gcry_mpi_test_bit (a, length) ? '1':'0';
      95           0 :       *p++ = gcry_mpi_test_bit (a, 0) ? '1':'0';
      96             :     }
      97           0 :   *p = 0;
      98           0 :   return buf;
      99             : }
     100             : 
     101             : 
     102             : static void
     103           0 : showmpi (const char *prefix, gcry_mpi_t a)
     104             : {
     105             :   char *bitstr;
     106             : 
     107           0 :   if (!verbose)
     108           0 :     return;
     109           0 :   bitstr = mpi2bitstr_nlz (a);
     110           0 :   fprintf (stderr, "%s: %s%s\n", PGM, prefix, bitstr);
     111           0 :   xfree (bitstr);
     112             : }
     113             : 
     114             : 
     115             : static void
     116           0 : fail (const char *format, ...)
     117             : {
     118             :   va_list arg_ptr;
     119             : 
     120           0 :   fflush (stdout);
     121           0 :   fprintf (stderr, "%s: ", PGM);
     122           0 :   if (wherestr)
     123           0 :     fprintf (stderr, "%s: ", wherestr);
     124           0 :   va_start (arg_ptr, format);
     125           0 :   vfprintf (stderr, format, arg_ptr);
     126           0 :   va_end (arg_ptr);
     127           0 :   error_count++;
     128           0 : }
     129             : 
     130             : static void
     131           0 : die (const char *format, ...)
     132             : {
     133             :   va_list arg_ptr;
     134             : 
     135           0 :   fflush (stdout);
     136           0 :   fprintf (stderr, "%s: ", PGM);
     137           0 :   if (wherestr)
     138           0 :     fprintf (stderr, "%s: ", wherestr);
     139           0 :   va_start (arg_ptr, format);
     140           0 :   vfprintf (stderr, format, arg_ptr);
     141           0 :   va_end (arg_ptr);
     142           0 :   exit (1);
     143             : }
     144             : 
     145             : 
     146             : /* Check that mpi_print does not return a negative zero.  */
     147             : static void
     148           1 : negative_zero (void)
     149             : {
     150             :   gpg_error_t err;
     151             :   gcry_mpi_t a;
     152             :   char *buf;
     153           1 :   void *bufaddr = &buf;
     154           1 :   struct { const char *name; enum gcry_mpi_format format; } fmts[] =
     155             :     {
     156             :       { "STD", GCRYMPI_FMT_STD },
     157             :       { "PGP", GCRYMPI_FMT_PGP },
     158             :       { "SSH", GCRYMPI_FMT_SSH },
     159             :       { "HEX", GCRYMPI_FMT_HEX },
     160             :       { "USG", GCRYMPI_FMT_USG },
     161             :       { NULL, 0 }
     162             :     };
     163             :   int i;
     164             : 
     165           1 :   if (debug)
     166           0 :     show ("negative zero printing\n");
     167             : 
     168           1 :   a = gcry_mpi_new (0);
     169           6 :   for (i=0; fmts[i].name; i++)
     170             :     {
     171           5 :       err = gcry_mpi_aprint (fmts[i].format, bufaddr, NULL, a);
     172           5 :       if (err)
     173           0 :         fail ("error printing a zero as %s: %s\n",
     174             :               fmts[i].name,gpg_strerror (err) );
     175             :       else
     176           5 :         gcry_free (buf);
     177             :     }
     178             : 
     179             :   /* With the current version of libgcrypt the next two statements
     180             :      should set a to -0. */
     181           1 :   gcry_mpi_sub_ui (a, a, 1);
     182           1 :   gcry_mpi_add_ui (a, a, 1);
     183             : 
     184           6 :   for (i=0; fmts[i].name; i++)
     185             :     {
     186           5 :       err = gcry_mpi_aprint (fmts[i].format, bufaddr, NULL, a);
     187           5 :       if (err)
     188           0 :         fail ("error printing a negative zero as %s: %s\n",
     189             :               fmts[i].name,gpg_strerror (err) );
     190             :       else
     191           5 :         gcry_free (buf);
     192             :     }
     193             : 
     194           1 :   gcry_mpi_release (a);
     195           1 : }
     196             : 
     197             : 
     198             : static void
     199           1 : check_formats (void)
     200             : {
     201             :   static struct {
     202             :     int value;
     203             :     struct {
     204             :       const char *hex;
     205             :       size_t stdlen;
     206             :       const char *std;
     207             :       size_t sshlen;
     208             :       const char *ssh;
     209             :       size_t usglen;
     210             :       const char *usg;
     211             :       size_t pgplen;
     212             :       const char *pgp;
     213             :     } a;
     214             :   } data[] = {
     215             :     {    0, { "00",
     216             :               0, "",
     217             :               4, "\x00\x00\x00\x00",
     218             :               0, "",
     219             :               2, "\x00\x00"}
     220             :     },
     221             :     {    1, { "01",
     222             :               1, "\x01",
     223             :               5, "\x00\x00\x00\x01\x01",
     224             :               1, "\x01",
     225             :               3, "\x00\x01\x01" }
     226             :     },
     227             :     {    2, { "02",
     228             :               1, "\x02",
     229             :               5, "\x00\x00\x00\x01\x02",
     230             :               1, "\x02",
     231             :               3, "\x00\x02\x02" }
     232             :     },
     233             :     {  127, { "7F",
     234             :               1, "\x7f",
     235             :               5, "\x00\x00\x00\x01\x7f",
     236             :               1, "\x7f",
     237             :               3, "\x00\x07\x7f" }
     238             :     },
     239             :     {  128, { "0080",
     240             :               2, "\x00\x80",
     241             :               6, "\x00\x00\x00\x02\x00\x80",
     242             :               1, "\x80",
     243             :               3, "\x00\x08\x80" }
     244             :     },
     245             :     {  129, { "0081",
     246             :               2, "\x00\x81",
     247             :               6, "\x00\x00\x00\x02\x00\x81",
     248             :               1, "\x81",
     249             :               3, "\x00\x08\x81" }
     250             :     },
     251             :     {  255, { "00FF",
     252             :               2, "\x00\xff",
     253             :               6, "\x00\x00\x00\x02\x00\xff",
     254             :               1, "\xff",
     255             :               3, "\x00\x08\xff" }
     256             :     },
     257             :     {  256, { "0100",
     258             :               2, "\x01\x00",
     259             :               6, "\x00\x00\x00\x02\x01\x00",
     260             :               2, "\x01\x00",
     261             :               4, "\x00\x09\x01\x00" }
     262             :     },
     263             :     {  257, { "0101",
     264             :               2, "\x01\x01",
     265             :               6, "\x00\x00\x00\x02\x01\x01",
     266             :               2, "\x01\x01",
     267             :               4, "\x00\x09\x01\x01" }
     268             :     },
     269             :     {   -1, { "-01",
     270             :               1, "\xff",
     271             :               5, "\x00\x00\x00\x01\xff",
     272             :               1,"\x01" }
     273             :     },
     274             :     {   -2, { "-02",
     275             :               1, "\xfe",
     276             :               5, "\x00\x00\x00\x01\xfe",
     277             :               1, "\x02" }
     278             :     },
     279             :     { -127, { "-7F",
     280             :               1, "\x81",
     281             :               5, "\x00\x00\x00\x01\x81",
     282             :               1, "\x7f" }
     283             :     },
     284             :     { -128, { "-0080",
     285             :               1, "\x80",
     286             :               5, "\x00\x00\x00\x01\x80",
     287             :               1, "\x80" }
     288             :     },
     289             :     { -129, { "-0081",
     290             :               2, "\xff\x7f",
     291             :               6, "\x00\x00\x00\x02\xff\x7f",
     292             :               1, "\x81" }
     293             :     },
     294             :     { -255, { "-00FF",
     295             :               2, "\xff\x01",
     296             :               6, "\x00\x00\x00\x02\xff\x01",
     297             :               1, "\xff" }
     298             :     },
     299             :     { -256, { "-0100",
     300             :               2, "\xff\x00",
     301             :               6, "\x00\x00\x00\x02\xff\x00",
     302             :               2, "\x01\x00" }
     303             :     },
     304             :     { -257, { "-0101",
     305             :               2, "\xfe\xff",
     306             :               6, "\x00\x00\x00\x02\xfe\xff",
     307             :               2, "\x01\x01" }
     308             :     },
     309             :     {  65535, { "00FFFF",
     310             :                 3, "\x00\xff\xff",
     311             :                 7, "\x00\x00\x00\x03\x00\xff\xff",
     312             :                 2, "\xff\xff",
     313             :                 4, "\x00\x10\xff\xff" }
     314             :     },
     315             :     {  65536, { "010000",
     316             :                 3, "\x01\00\x00",
     317             :                 7, "\x00\x00\x00\x03\x01\x00\x00",
     318             :                 3, "\x01\x00\x00",
     319             :                 5, "\x00\x11\x01\x00\x00 "}
     320             :     },
     321             :     {  65537, { "010001",
     322             :                 3, "\x01\00\x01",
     323             :                 7, "\x00\x00\x00\x03\x01\x00\x01",
     324             :                 3, "\x01\x00\x01",
     325             :                 5, "\x00\x11\x01\x00\x01" }
     326             :     },
     327             :     { -65537, { "-010001",
     328             :                 3, "\xfe\xff\xff",
     329             :                 7, "\x00\x00\x00\x03\xfe\xff\xff",
     330             :                 3, "\x01\x00\x01" }
     331             :     },
     332             :     { -65536, { "-010000",
     333             :                 3, "\xff\x00\x00",
     334             :                 7, "\x00\x00\x00\x03\xff\x00\x00",
     335             :                 3, "\x01\x00\x00" }
     336             :     },
     337             :     { -65535, { "-00FFFF",
     338             :                 3, "\xff\x00\x01",
     339             :                 7, "\x00\x00\x00\x03\xff\x00\x01",
     340             :                 2, "\xff\xff" }
     341             :     }
     342             :   };
     343             :   gpg_error_t err;
     344             :   gcry_mpi_t a, b;
     345             :   char *buf;
     346           1 :   void *bufaddr = &buf;
     347             :   int idx;
     348             :   size_t buflen;
     349             : 
     350           1 :   a = gcry_mpi_new (0);
     351          24 :   for (idx=0; idx < DIM(data); idx++)
     352             :     {
     353          23 :       if (debug)
     354           0 :         show ("print test %d\n", data[idx].value);
     355             : 
     356          23 :       if (data[idx].value < 0)
     357             :         {
     358          11 :           gcry_mpi_set_ui (a, -data[idx].value);
     359          11 :           gcry_mpi_neg (a, a);
     360             :         }
     361             :       else
     362          12 :         gcry_mpi_set_ui (a, data[idx].value);
     363             : 
     364          23 :       err = gcry_mpi_aprint (GCRYMPI_FMT_HEX, bufaddr, NULL, a);
     365          23 :       if (err)
     366           0 :         fail ("error printing value %d as %s: %s\n",
     367             :               data[idx].value, "HEX", gpg_strerror (err));
     368             :       else
     369             :         {
     370          23 :           if (strcmp (buf, data[idx].a.hex))
     371             :             {
     372           0 :               fail ("error printing value %d as %s: %s\n",
     373             :                     data[idx].value, "HEX", "wrong result");
     374           0 :               show ("expected: '%s'\n", data[idx].a.hex);
     375           0 :               show ("     got: '%s'\n", buf);
     376             :             }
     377          23 :           gcry_free (buf);
     378             :         }
     379             : 
     380          23 :       err = gcry_mpi_aprint (GCRYMPI_FMT_STD, bufaddr, &buflen, a);
     381          23 :       if (err)
     382           0 :         fail ("error printing value %d as %s: %s\n",
     383             :               data[idx].value, "STD", gpg_strerror (err));
     384             :       else
     385             :         {
     386          23 :           if (buflen != data[idx].a.stdlen
     387          23 :               || memcmp (buf, data[idx].a.std, data[idx].a.stdlen))
     388             :             {
     389           0 :               fail ("error printing value %d as %s: %s\n",
     390             :                     data[idx].value, "STD", "wrong result");
     391           0 :               showhex ("expected:", data[idx].a.std, data[idx].a.stdlen);
     392           0 :               showhex ("     got:", buf, buflen);
     393             :             }
     394          23 :           gcry_free (buf);
     395             :         }
     396             : 
     397          23 :       err = gcry_mpi_aprint (GCRYMPI_FMT_SSH, bufaddr, &buflen, a);
     398          23 :       if (err)
     399           0 :         fail ("error printing value %d as %s: %s\n",
     400             :               data[idx].value, "SSH", gpg_strerror (err));
     401             :       else
     402             :         {
     403          23 :           if (buflen != data[idx].a.sshlen
     404          23 :               || memcmp (buf, data[idx].a.ssh, data[idx].a.sshlen))
     405             :             {
     406           0 :               fail ("error printing value %d as %s: %s\n",
     407             :                     data[idx].value, "SSH", "wrong result");
     408           0 :               showhex ("expected:", data[idx].a.ssh, data[idx].a.sshlen);
     409           0 :               showhex ("     got:", buf, buflen);
     410             :             }
     411          23 :           gcry_free (buf);
     412             :         }
     413             : 
     414          23 :       err = gcry_mpi_aprint (GCRYMPI_FMT_USG, bufaddr, &buflen, a);
     415          23 :       if (err)
     416           0 :         fail ("error printing value %d as %s: %s\n",
     417             :               data[idx].value, "USG", gpg_strerror (err));
     418             :       else
     419             :         {
     420          23 :           if (buflen != data[idx].a.usglen
     421          23 :               || memcmp (buf, data[idx].a.usg, data[idx].a.usglen))
     422             :             {
     423           0 :               fail ("error printing value %d as %s: %s\n",
     424             :                     data[idx].value, "USG", "wrong result");
     425           0 :               showhex ("expected:", data[idx].a.usg, data[idx].a.usglen);
     426           0 :               showhex ("     got:", buf, buflen);
     427             :             }
     428          23 :           gcry_free (buf);
     429             :         }
     430             : 
     431          23 :       err = gcry_mpi_aprint (GCRYMPI_FMT_PGP, bufaddr, &buflen, a);
     432          23 :       if (gcry_mpi_is_neg (a))
     433             :         {
     434          11 :           if (gpg_err_code (err) != GPG_ERR_INV_ARG)
     435           0 :             fail ("error printing value %d as %s: %s\n",
     436             :                   data[idx].value, "PGP", "Expected error not returned");
     437             :         }
     438          12 :       else if (err)
     439           0 :         fail ("error printing value %d as %s: %s\n",
     440             :               data[idx].value, "PGP", gpg_strerror (err));
     441             :       else
     442             :         {
     443          12 :           if (buflen != data[idx].a.pgplen
     444          12 :               || memcmp (buf, data[idx].a.pgp, data[idx].a.pgplen))
     445             :             {
     446           0 :               fail ("error printing value %d as %s: %s\n",
     447             :                     data[idx].value, "PGP", "wrong result");
     448           0 :               showhex ("expected:", data[idx].a.pgp, data[idx].a.pgplen);
     449           0 :               showhex ("     got:", buf, buflen);
     450             :             }
     451          12 :           gcry_free (buf);
     452             :         }
     453             :     }
     454             : 
     455             : 
     456             :   /* Now for the other direction.  */
     457          24 :   for (idx=0; idx < DIM(data); idx++)
     458             :     {
     459          23 :       if (debug)
     460           0 :         show ("scan test %d\n", data[idx].value);
     461             : 
     462          23 :       if (data[idx].value < 0)
     463             :         {
     464          11 :           gcry_mpi_set_ui (a, -data[idx].value);
     465          11 :           gcry_mpi_neg (a, a);
     466             :         }
     467             :       else
     468          12 :         gcry_mpi_set_ui (a, data[idx].value);
     469             : 
     470          23 :       err = gcry_mpi_scan (&b, GCRYMPI_FMT_HEX, data[idx].a.hex, 0, &buflen);
     471          23 :       if (err)
     472           0 :         fail ("error scanning value %d from %s: %s\n",
     473             :               data[idx].value, "HEX", gpg_strerror (err));
     474             :       else
     475             :         {
     476          23 :           if (gcry_mpi_cmp (a, b))
     477             :             {
     478           0 :               fail ("error scanning value %d from %s: %s\n",
     479             :                     data[idx].value, "HEX", "wrong result");
     480           0 :               showmpi ("expected:", a);
     481           0 :               showmpi ("     got:", b);
     482             :             }
     483          23 :           gcry_mpi_release (b);
     484             :         }
     485             : 
     486          46 :       err = gcry_mpi_scan (&b, GCRYMPI_FMT_STD,
     487          23 :                            data[idx].a.std, data[idx].a.stdlen, &buflen);
     488          23 :       if (err)
     489           0 :         fail ("error scanning value %d as %s: %s\n",
     490             :               data[idx].value, "STD", gpg_strerror (err));
     491             :       else
     492             :         {
     493          23 :           if (gcry_mpi_cmp (a, b) || data[idx].a.stdlen != buflen)
     494             :             {
     495           0 :               fail ("error scanning value %d from %s: %s (%u)\n",
     496             :                     data[idx].value, "STD", "wrong result", buflen);
     497           0 :               showmpi ("expected:", a);
     498           0 :               showmpi ("     got:", b);
     499             :             }
     500          23 :           gcry_mpi_release (b);
     501             :         }
     502             : 
     503          46 :       err = gcry_mpi_scan (&b, GCRYMPI_FMT_SSH,
     504          23 :                            data[idx].a.ssh, data[idx].a.sshlen, &buflen);
     505          23 :       if (err)
     506           0 :         fail ("error scanning value %d as %s: %s\n",
     507             :               data[idx].value, "SSH", gpg_strerror (err));
     508             :       else
     509             :         {
     510          23 :           if (gcry_mpi_cmp (a, b) || data[idx].a.sshlen != buflen)
     511             :             {
     512           0 :               fail ("error scanning value %d from %s: %s (%u)\n",
     513             :                     data[idx].value, "SSH", "wrong result", buflen);
     514           0 :               showmpi ("expected:", a);
     515           0 :               showmpi ("     got:", b);
     516             :             }
     517          23 :           gcry_mpi_release (b);
     518             :         }
     519             : 
     520          46 :       err = gcry_mpi_scan (&b, GCRYMPI_FMT_USG,
     521          23 :                            data[idx].a.usg, data[idx].a.usglen, &buflen);
     522          23 :       if (err)
     523           0 :         fail ("error scanning value %d as %s: %s\n",
     524             :               data[idx].value, "USG", gpg_strerror (err));
     525             :       else
     526             :         {
     527          23 :           if (gcry_mpi_is_neg (a))
     528          11 :             gcry_mpi_neg (b, b);
     529          23 :           if (gcry_mpi_cmp (a, b) || data[idx].a.usglen != buflen)
     530             :             {
     531           0 :               fail ("error scanning value %d from %s: %s (%u)\n",
     532             :                     data[idx].value, "USG", "wrong result", buflen);
     533           0 :               showmpi ("expected:", a);
     534           0 :               showmpi ("     got:", b);
     535             :             }
     536          23 :           gcry_mpi_release (b);
     537             :         }
     538             : 
     539             :       /* Negative values are not supported by PGP, thus we don't have
     540             :          an samples.  */
     541          23 :       if (!gcry_mpi_is_neg (a))
     542             :         {
     543          24 :           err = gcry_mpi_scan (&b, GCRYMPI_FMT_PGP,
     544          12 :                                data[idx].a.pgp, data[idx].a.pgplen, &buflen);
     545          12 :           if (err)
     546           0 :             fail ("error scanning value %d as %s: %s\n",
     547             :                   data[idx].value, "PGP", gpg_strerror (err));
     548             :           else
     549             :             {
     550          12 :               if (gcry_mpi_cmp (a, b) || data[idx].a.pgplen != buflen)
     551             :                 {
     552           0 :                   fail ("error scanning value %d from %s: %s (%u)\n",
     553             :                         data[idx].value, "PGP", "wrong result", buflen);
     554           0 :                   showmpi ("expected:", a);
     555           0 :                   showmpi ("     got:", b);
     556             :                 }
     557          12 :               gcry_mpi_release (b);
     558             :             }
     559             :         }
     560             :     }
     561             : 
     562           1 :   gcry_mpi_release (a);
     563           1 : }
     564             : 
     565             : 
     566             : int
     567           1 : main (int argc, char **argv)
     568             : {
     569           1 :   if (argc > 1 && !strcmp (argv[1], "--verbose"))
     570           0 :     verbose = 1;
     571           1 :   else if (argc > 1 && !strcmp (argv[1], "--debug"))
     572           0 :     verbose = debug = 1;
     573             : 
     574           1 :   if (!gcry_check_version (GCRYPT_VERSION))
     575           0 :     die ("version mismatch\n");
     576             : 
     577           1 :   gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
     578           1 :   gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
     579           1 :   if (debug)
     580           0 :     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
     581           1 :   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
     582             : 
     583           1 :   negative_zero ();
     584           1 :   check_formats ();
     585             : 
     586           1 :   show ("All tests completed. Errors: %d\n", error_count);
     587           1 :   return error_count ? 1 : 0;
     588             : }

Generated by: LCOV version 1.11