LCOV - code coverage report
Current view: top level - tests/gpg - t-support.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 24 58 41.4 %
Date: 2018-11-14 16:53:58 Functions: 3 7 42.9 %

          Line data    Source code
       1             : /* t-support.h - Helper routines for regression tests.
       2             :    Copyright (C) 2000 Werner Koch (dd9jn)
       3             :    Copyright (C) 2001, 2002, 2003, 2004 g10 Code GmbH
       4             : 
       5             :    This file is part of GPGME.
       6             : 
       7             :    GPGME is free software; you can redistribute it and/or modify it
       8             :    under the terms of the GNU Lesser General Public License as
       9             :    published by the Free Software Foundation; either version 2.1 of
      10             :    the License, or (at your option) any later version.
      11             : 
      12             :    GPGME is distributed in the hope that it will be useful, but
      13             :    WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15             :    Lesser General Public License for more details.
      16             : 
      17             :    You should have received a copy of the GNU Lesser General Public
      18             :    License along with this program; if not, write to the Free Software
      19             :    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
      20             :    02111-1307, USA.  */
      21             : 
      22             : #include <unistd.h>
      23             : #include <errno.h>
      24             : #include <stdlib.h>
      25             : #include <locale.h>
      26             : 
      27             : #ifdef HAVE_W32_SYSTEM
      28             : #include <windows.h>
      29             : #endif
      30             : 
      31             : #include <gpgme.h>
      32             : 
      33             : #ifndef DIM
      34             : #define DIM(v)               (sizeof(v)/sizeof((v)[0]))
      35             : #endif
      36             : 
      37             : #define fail_if_err(err)                                        \
      38             :   do                                                            \
      39             :     {                                                           \
      40             :       if (err)                                                  \
      41             :         {                                                       \
      42             :           fprintf (stderr, "%s:%d: %s: %s\n",                 \
      43             :                    __FILE__, __LINE__, gpgme_strsource (err),   \
      44             :                    gpgme_strerror (err));                       \
      45             :           exit (1);                                             \
      46             :         }                                                       \
      47             :     }                                                           \
      48             :   while (0)
      49             : 
      50             : 
      51             : #ifdef GPGRT_HAVE_MACRO_FUNCTION
      52             : void GPGRT_ATTR_NORETURN
      53           0 : _test (const char *expr, const char *file, int line,
      54             :        const char *func)
      55             : {
      56           0 :   fprintf (stderr, "Test \"%s\" in %s failed (%s:%d)\n",
      57             :            expr, func, file, line);
      58           0 :   exit (1);
      59             : }
      60             : # define test(expr)                                             \
      61             :   ((expr)                                                       \
      62             :    ? (void) 0                                                   \
      63             :    : _test (#expr, __FILE__, __LINE__, __FUNCTION__))
      64             : #else /*!GPGRT_HAVE_MACRO_FUNCTION*/
      65             : void
      66             : _test (const char *expr, const char *file, int line)
      67             : {
      68             :   fprintf (stderr, "Test \"%s\" failed (%s:%d)\n",
      69             :            expr, file, line);
      70             :   exit (1);
      71             : }
      72             : # define test(expr)                                             \
      73             :   ((expr)                                                       \
      74             :    ? (void) 0                                                   \
      75             :    : _test (#expr, __FILE__, __LINE__))
      76             : #endif /*!GPGRT_HAVE_MACRO_FUNCTION*/
      77             : 
      78             : 
      79             : static const char *
      80           0 : nonnull (const char *s)
      81             : {
      82           0 :   return s? s :"[none]";
      83             : }
      84             : 
      85             : 
      86             : void
      87          18 : print_data (gpgme_data_t dh)
      88             : {
      89             : #define BUF_SIZE 512
      90             :   char buf[BUF_SIZE + 1];
      91             :   int ret;
      92             : 
      93          18 :   ret = gpgme_data_seek (dh, 0, SEEK_SET);
      94          18 :   if (ret)
      95           0 :     fail_if_err (gpgme_err_code_from_errno (errno));
      96          71 :   while ((ret = gpgme_data_read (dh, buf, BUF_SIZE)) > 0)
      97          35 :     fwrite (buf, ret, 1, stdout);
      98          18 :   if (ret < 0)
      99           0 :     fail_if_err (gpgme_err_code_from_errno (errno));
     100          18 : }
     101             : 
     102             : 
     103             : gpgme_error_t
     104           0 : passphrase_cb (void *opaque, const char *uid_hint, const char *passphrase_info,
     105             :                int last_was_bad, int fd)
     106             : {
     107             :   int res;
     108           0 :   char pass[] = "abc\n";
     109           0 :   int passlen = strlen (pass);
     110           0 :   int off = 0;
     111             : 
     112             :   (void)opaque;
     113             :   (void)uid_hint;
     114             :   (void)passphrase_info;
     115             :   (void)last_was_bad;
     116             : 
     117             :   do
     118             :     {
     119           0 :       res = gpgme_io_write (fd, &pass[off], passlen - off);
     120           0 :       if (res > 0)
     121           0 :         off += res;
     122             :     }
     123           0 :   while (res > 0 && off != passlen);
     124             : 
     125           0 :   return off == passlen ? 0 : gpgme_error_from_errno (errno);
     126             : }
     127             : 
     128             : 
     129             : char *
     130           5 : make_filename (const char *fname)
     131             : {
     132           5 :   const char *srcdir = getenv ("srcdir");
     133             :   char *buf;
     134             : 
     135           5 :   if (!srcdir)
     136           0 :     srcdir = ".";
     137           5 :   buf = malloc (strlen(srcdir) + strlen(fname) + 2);
     138           5 :   if (!buf)
     139           0 :     exit (8);
     140           5 :   strcpy (buf, srcdir);
     141           5 :   strcat (buf, "/");
     142           5 :   strcat (buf, fname);
     143           5 :   return buf;
     144             : }
     145             : 
     146             : 
     147             : void
     148          44 : init_gpgme (gpgme_protocol_t proto)
     149             : {
     150             :   gpgme_error_t err;
     151             : 
     152          44 :   gpgme_check_version (NULL);
     153          44 :   setlocale (LC_ALL, "");
     154          44 :   gpgme_set_locale (NULL, LC_CTYPE, setlocale (LC_CTYPE, NULL));
     155             : #ifndef HAVE_W32_SYSTEM
     156          44 :   gpgme_set_locale (NULL, LC_MESSAGES, setlocale (LC_MESSAGES, NULL));
     157             : #endif
     158             : 
     159          44 :   err = gpgme_engine_check_version (proto);
     160          44 :   fail_if_err (err);
     161          44 : }
     162             : 
     163             : 
     164             : void
     165           0 : print_import_result (gpgme_import_result_t r)
     166             : {
     167             :   gpgme_import_status_t st;
     168             : 
     169           0 :   for (st=r->imports; st; st = st->next)
     170             :     {
     171           0 :       printf ("  fpr: %s err: %d (%s) status:", nonnull (st->fpr),
     172             :               st->result, gpgme_strerror (st->result));
     173           0 :       if (st->status & GPGME_IMPORT_NEW)
     174           0 :         fputs (" new", stdout);
     175           0 :       if (st->status & GPGME_IMPORT_UID)
     176           0 :         fputs (" uid", stdout);
     177           0 :       if (st->status & GPGME_IMPORT_SIG)
     178           0 :         fputs (" sig", stdout);
     179           0 :       if (st->status & GPGME_IMPORT_SUBKEY)
     180           0 :         fputs (" subkey", stdout);
     181           0 :       if (st->status & GPGME_IMPORT_SECRET)
     182           0 :         fputs (" secret", stdout);
     183           0 :       putchar ('\n');
     184             :     }
     185           0 :   printf ("key import summary:\n"
     186             :           "        considered: %d\n"
     187             :           "        no user id: %d\n"
     188             :           "          imported: %d\n"
     189             :           "      imported_rsa: %d\n"
     190             :           "         unchanged: %d\n"
     191             :           "      new user ids: %d\n"
     192             :           "       new subkeys: %d\n"
     193             :           "    new signatures: %d\n"
     194             :           "   new revocations: %d\n"
     195             :           "       secret read: %d\n"
     196             :           "   secret imported: %d\n"
     197             :           "  secret unchanged: %d\n"
     198             :           "  skipped new keys: %d\n"
     199             :           "      not imported: %d\n"
     200             :           "   skipped v3 keys: %d\n",
     201             :           r->considered,
     202             :           r->no_user_id,
     203             :           r->imported,
     204             :           r->imported_rsa,
     205             :           r->unchanged,
     206             :           r->new_user_ids,
     207             :           r->new_sub_keys,
     208             :           r->new_signatures,
     209             :           r->new_revocations,
     210             :           r->secret_read,
     211             :           r->secret_imported,
     212             :           r->secret_unchanged,
     213             :           r->skipped_new_keys,
     214             :           r->not_imported,
     215             :           r->skipped_v3_keys);
     216           0 : }
     217             : 

Generated by: LCOV version 1.13