2003-05-04 Marcus Brinkmann <marcus@g10code.de>
authorMarcus Brinkmann <mb@g10code.com>
Sun, 4 May 2003 16:43:24 +0000 (16:43 +0000)
committerMarcus Brinkmann <mb@g10code.com>
Sun, 4 May 2003 16:43:24 +0000 (16:43 +0000)
* gpg/Makefile.am (TESTS): Add t-keylist-sig.
* gpg/t-keylist-sig.c: New file.

tests/ChangeLog
tests/gpg/Makefile.am
tests/gpg/t-keylist-sig.c [new file with mode: 0644]

index 8daf141..e2d3fc7 100644 (file)
@@ -1,3 +1,8 @@
+2003-05-04  Marcus Brinkmann  <marcus@g10code.de>
+
+       * gpg/Makefile.am (TESTS): Add t-keylist-sig.
+       * gpg/t-keylist-sig.c: New file.
+
 2003-04-30  Marcus Brinkmann  <marcus@g10code.de>
 
        * gpg/t-eventloop.c (main): Do not call print_op_info.
index f969046..9120785 100644 (file)
@@ -24,8 +24,8 @@ GPG = @GPG@
 TESTS_ENVIRONMENT = GNUPGHOME=. GPG_AGENT_INFO=
 
 TESTS = t-encrypt t-encrypt-sym t-encrypt-sign t-sign t-signers        \
-       t-decrypt t-verify t-decrypt-verify t-keylist t-export  \
-       t-import t-trustlist t-eventloop t-edit
+       t-decrypt t-verify t-decrypt-verify t-keylist t-keylist-sig \
+       t-export t-import t-trustlist t-eventloop t-edit
 
 CLEANFILES = secring.gpg pubring.gpg trustdb.gpg
 DISTCLEANFILES = pubring.gpg~ random_seed
diff --git a/tests/gpg/t-keylist-sig.c b/tests/gpg/t-keylist-sig.c
new file mode 100644 (file)
index 0000000..d51c434
--- /dev/null
@@ -0,0 +1,653 @@
+/* t-keylist-sig.c - Regression test.
+   Copyright (C) 2000 Werner Koch (dd9jn)
+   Copyright (C) 2001, 2003 g10 Code GmbH
+
+   This file is part of GPGME.
+   GPGME is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   GPGME is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+   You should have received a copy of the GNU General Public License
+   along with GPGME; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <gpgme.h>
+
+\f
+#define fail_if_err(err)                                       \
+  do                                                           \
+    {                                                          \
+      if (err)                                                 \
+        {                                                      \
+          fprintf (stderr, "%s:%d: GpgmeError %s\n",           \
+                   __FILE__, __LINE__, gpgme_strerror (err));   \
+          exit (1);                                            \
+        }                                                      \
+    }                                                          \
+  while (0)
+
+
+struct
+{
+  char *fpr;
+  char *sec_keyid;
+  struct
+  {
+    char *name;
+    char *comment;
+    char *email;
+    struct
+    {
+      GpgmePubKeyAlgo algo;
+      char *keyid;
+      int timestamp;
+      char *name;
+      char *comment;
+      char *email;
+      int class;
+      int exportable;
+    } sig;
+  } uid[3];  
+}
+keys[] =
+  {
+    { "A0FF4590BB6122EDEF6E3C542D727CC768697734", "6AE6D7EE46A871F8",
+      { { "Alpha Test", "demo key", "alpha@example.net",
+          { GPGME_PK_DSA, "2D727CC768697734", 1052065447,
+           "Alpha Test", "demo key", "alpha@example.net", 19, 1 } },
+       { "Alice", "demo key", NULL,
+          { GPGME_PK_DSA, "2D727CC768697734", 1052065447,
+           "Alpha Test", "demo key", "alpha@example.net", 19, 1 } },
+       { "Alfa Test", "demo key", "alfa@example.net",
+          { GPGME_PK_DSA, "2D727CC768697734", 1052065447,
+           "Alpha Test", "demo key", "alpha@example.net", 19, 1 } } } },
+    { NULL }
+  };
+
+int 
+main (int argc, char **argv)
+{
+  GpgmeError err;
+  GpgmeCtx ctx;
+  GpgmeKey key;
+  GpgmeKeyListResult result;
+  int mode;
+  int i = 0;
+
+  err = gpgme_engine_check_version (GPGME_PROTOCOL_OpenPGP);
+  fail_if_err (err);
+
+  err = gpgme_new (&ctx);
+  fail_if_err (err);
+
+  mode  = gpgme_get_keylist_mode (ctx);
+  mode |= GPGME_KEYLIST_MODE_SIGS;
+  err = gpgme_set_keylist_mode (ctx, mode);
+  fail_if_err (err);
+
+  err = gpgme_op_keylist_start (ctx, "Alpha", 0);
+  fail_if_err (err);
+    
+  while (!(err = gpgme_op_keylist_next (ctx, &key)))
+    {
+      if (!keys[i].fpr)
+       {
+         fprintf (stderr, "More keys returned than expected\n");
+         exit (1);
+       }
+
+      /* Global key flags.  */
+      if (key->revoked)
+       {
+         fprintf (stderr, "Key unexpectedly revoked\n");
+         exit (1);
+       }
+      if (key->expired)
+       {
+         fprintf (stderr, "Key unexpectedly expired\n");
+         exit (1);
+       }
+      if (key->disabled)
+       {
+         fprintf (stderr, "Key unexpectedly disabled\n");
+         exit (1);
+       }
+      if (key->invalid)
+       {
+         fprintf (stderr, "Key unexpectedly invalid\n");
+         exit (1);
+       }
+      if (!key->can_encrypt)
+       {
+         fprintf (stderr, "Key unexpectedly unusable for encryption\n");
+         exit (1);
+       }
+      if (!key->can_sign)
+       {
+         fprintf (stderr, "Key unexpectedly unusable for signing\n");
+         exit (1);
+       }
+      if (!key->can_certify)
+       {
+         fprintf (stderr, "Key unexpectedly unusable for certifications\n");
+         exit (1);
+       }
+      if (key->secret)
+       {
+         fprintf (stderr, "Key unexpectedly secret\n");
+         exit (1);
+       }
+      if (key->protocol != GPGME_PROTOCOL_OpenPGP)
+       {
+         fprintf (stderr, "Key has unexpected protocol: %s\n",
+                  gpgme_get_protocol_name (key->protocol));
+         exit (1);
+       }
+      if (key->issuer_serial)
+       {
+         fprintf (stderr, "Key unexpectedly carries issuer serial: %s\n",
+                  key->issuer_serial);
+         exit (1);
+       }
+      if (key->issuer_name)
+       {
+         fprintf (stderr, "Key unexpectedly carries issuer name: %s\n",
+                  key->issuer_name);
+         exit (1);
+       }
+      if (key->chain_id)
+       {
+         fprintf (stderr, "Key unexpectedly carries chain ID: %s\n",
+                  key->chain_id);
+         exit (1);
+       }
+      if (key->owner_trust != GPGME_VALIDITY_UNKNOWN)
+       {
+         fprintf (stderr, "Key has unexpected owner trust: %i\n",
+                  key->owner_trust);
+         exit (1);
+       }
+      if (!key->subkeys || !key->subkeys->next || key->subkeys->next->next)
+       {
+         fprintf (stderr, "Key has unexpected number of subkeys\n");
+         exit (1);
+       }
+
+      /* Primary key.  */
+      if (key->subkeys->revoked)
+       {
+         fprintf (stderr, "Primary key unexpectedly revoked\n");
+         exit (1);
+       }
+      if (key->subkeys->expired)
+       {
+         fprintf (stderr, "Primary key unexpectedly expired\n");
+         exit (1);
+       }
+      if (key->subkeys->disabled)
+       {
+         fprintf (stderr, "Primary key unexpectedly disabled\n");
+         exit (1);
+       }
+      if (key->subkeys->invalid)
+       {
+         fprintf (stderr, "Primary key unexpectedly invalid\n");
+         exit (1);
+       }
+      if (key->subkeys->can_encrypt)
+       {
+         fprintf (stderr, "Primary key unexpectedly usable for encryption\n");
+         exit (1);
+       }
+      if (!key->subkeys->can_sign)
+       {
+         fprintf (stderr, "Primary key unexpectedly unusable for signing\n");
+         exit (1);
+       }
+      if (!key->subkeys->can_certify)
+       {
+         fprintf (stderr, "Primary key unexpectedly unusable for certifications\n");
+         exit (1);
+       }
+      if (key->subkeys->secret)
+       {
+         fprintf (stderr, "Primary key unexpectedly secret\n");
+         exit (1);
+       }
+      if (key->subkeys->pubkey_algo != GPGME_PK_DSA)
+       {
+         fprintf (stderr, "Primary key has unexpected public key algo: %s\n",
+                  gpgme_pubkey_algo_name (key->subkeys->pubkey_algo));
+         exit (1);
+       }
+      if (key->subkeys->length != 1024)
+       {
+         fprintf (stderr, "Primary key has unexpected length: %i\n",
+                  key->subkeys->length);
+         exit (1);
+       }
+      if (strcmp (key->subkeys->keyid, &keys[i].fpr[40 - 16]))
+       {
+         fprintf (stderr, "Primary key has unexpected key ID: %s\n",
+                  key->subkeys->keyid);
+         exit (1);
+       }
+      if (strcmp (key->subkeys->fpr, keys[i].fpr))
+       {
+         fprintf (stderr, "Primary key has unexpected fingerprint: %s\n",
+                  key->subkeys->fpr);
+         exit (1);
+       }
+      if (key->subkeys->expires)
+       {
+         fprintf (stderr, "Primary key unexpectedly expires: %lu\n",
+                  key->subkeys->expires);
+         exit (1);
+       }
+
+      /* Secondary key.  */
+      if (key->subkeys->next->revoked)
+       {
+         fprintf (stderr, "Secondary key unexpectedly revoked\n");
+         exit (1);
+       }
+      if (key->subkeys->next->expired)
+       {
+         fprintf (stderr, "Secondary key unexpectedly expired\n");
+         exit (1);
+       }
+      if (key->subkeys->next->disabled)
+       {
+         fprintf (stderr, "Secondary key unexpectedly disabled\n");
+         exit (1);
+       }
+      if (key->subkeys->next->invalid)
+       {
+         fprintf (stderr, "Secondary key unexpectedly invalid\n");
+         exit (1);
+       }
+      if (!key->subkeys->next->can_encrypt)
+       {
+         fprintf (stderr, "Secondary key unexpectedly unusable for encryption\n");
+         exit (1);
+       }
+      if (key->subkeys->next->can_sign)
+       {
+         fprintf (stderr, "Secondary key unexpectedly usable for signing\n");
+         exit (1);
+       }
+      if (key->subkeys->next->can_certify)
+       {
+         fprintf (stderr, "Secondary key unexpectedly usable for certifications\n");
+         exit (1);
+       }
+      if (key->subkeys->next->secret)
+       {
+         fprintf (stderr, "Secondary key unexpectedly secret\n");
+         exit (1);
+       }
+      if (key->subkeys->next->pubkey_algo != GPGME_PK_ELG_E)
+       {
+         fprintf (stderr, "Secondary key has unexpected public key algo: %s\n",
+                  gpgme_pubkey_algo_name (key->subkeys->next->pubkey_algo));
+         exit (1);
+       }
+      if (key->subkeys->next->length != 1024)
+       {
+         fprintf (stderr, "Secondary key has unexpected length: %i\n",
+                  key->subkeys->next->length);
+         exit (1);
+       }
+      if (strcmp (key->subkeys->next->keyid, keys[i].sec_keyid))
+       {
+         fprintf (stderr, "Secondary key has unexpected key ID: %s\n",
+                  key->subkeys->next->keyid);
+         exit (1);
+       }
+      if (key->subkeys->next->fpr)
+       {
+         fprintf (stderr, "Secondary key has unexpectedly a fingerprint: %s\n",
+                  key->subkeys->next->fpr);
+         exit (1);
+       }
+      if (key->subkeys->next->expires)
+       {
+         fprintf (stderr, "Secondary key unexpectedly expires: %lu\n",
+                  key->subkeys->next->expires);
+         exit (1);
+       }
+
+      /* FIXME: The below test will crash if we want to check for a
+        name, comment or email that doesn't exist in the key's user
+        IDs.  */
+      if (!((!keys[i].uid[0].name && !key->uids)
+           || (keys[i].uid[0].name && !keys[i].uid[1].name
+               && key->uids && !key->uids->next)
+           || (keys[i].uid[0].name && keys[i].uid[1].name
+               && !keys[i].uid[2].name
+               && key->uids && key->uids->next && !key->uids->next->next)
+           || (keys[i].uid[0].name && keys[i].uid[1].name
+               && keys[i].uid[2].name
+               && key->uids && key->uids->next && key->uids->next->next
+               && !key->uids->next->next->next)))
+         {
+           fprintf (stderr, "Key has unexpected number of user IDs\n");
+           exit (1);
+         }
+      if (key->uids && key->uids->revoked)
+       {
+         fprintf (stderr, "First user ID unexpectedly revoked\n");
+         exit (1);
+       }
+      if (key->uids && key->uids->invalid)
+       {
+         fprintf (stderr, "First user ID unexpectedly invalid\n");
+         exit (1);
+       }
+      if (key->uids && key->uids->validity != GPGME_VALIDITY_UNKNOWN)
+       {
+         fprintf (stderr, "First user ID has unexpectedly validity: %i\n",
+                  key->uids->validity);
+         exit (1);
+       }
+      if (keys[i].uid[0].name
+         && strcmp (keys[i].uid[0].name, key->uids->name))
+       {
+         fprintf (stderr, "Unexpected name in first user ID: %s\n",
+                  key->uids->name);
+         exit (1);
+       }
+      if (keys[i].uid[0].comment
+         && strcmp (keys[i].uid[0].comment, key->uids->comment))
+       {
+         fprintf (stderr, "Unexpected comment in first user ID: %s\n",
+                  key->uids->comment);
+         exit (1);
+       }
+      if (keys[i].uid[0].email
+         && strcmp (keys[i].uid[0].email, key->uids->email))
+       {
+         fprintf (stderr, "Unexpected email in first user ID: %s\n",
+                  key->uids->email);
+         exit (1);
+       }
+      if (key->uids && (!key->uids->signatures || key->uids->signatures->next))
+       {
+         fprintf (stderr, "First user ID unexpected number of signatures\n");
+         exit (1);
+       }
+      if (keys[i].uid[0].sig.algo != key->uids->signatures->pubkey_algo)
+       {
+         fprintf (stderr, "Unexpected algorithm in first user ID sig: %s\n",
+                  gpgme_pubkey_algo_name (key->uids->signatures->pubkey_algo));
+         exit (1);
+       }
+      if (strcmp (keys[i].uid[0].sig.keyid, key->uids->signatures->keyid))
+       {
+         fprintf (stderr, "Unexpected key ID in first user ID sig: %s\n",
+                  key->uids->signatures->keyid);
+         exit (1);
+       }
+      if (keys[i].uid[0].sig.timestamp != key->uids->signatures->timestamp)
+       {
+         fprintf (stderr, "Unexpected timestamp in first user ID sig: %li\n",
+                  key->uids->signatures->timestamp);
+         exit (1);
+       }
+      if (strcmp (keys[i].uid[0].sig.name, key->uids->signatures->name))
+       {
+         fprintf (stderr, "Unexpected name in first user ID sig: %s\n",
+                  key->uids->signatures->name);
+         exit (1);
+       }
+      if (strcmp (keys[i].uid[0].sig.comment, key->uids->signatures->comment))
+       {
+         fprintf (stderr, "Unexpected comment in first user ID sig: %s\n",
+                  key->uids->signatures->comment);
+         exit (1);
+       }
+      if (strcmp (keys[i].uid[0].sig.email, key->uids->signatures->email))
+       {
+         fprintf (stderr, "Unexpected email in first user ID sig: %s\n",
+                  key->uids->signatures->email);
+         exit (1);
+       }
+      if (keys[i].uid[0].sig.class != key->uids->signatures->class)
+       {
+         fprintf (stderr, "Unexpected class in first user ID sig: %i\n",
+                  key->uids->signatures->class);
+         exit (1);
+       }
+      if (keys[i].uid[0].sig.exportable != key->uids->signatures->exportable)
+       {
+         fprintf (stderr, "Unexpected exportable stat in first user ID sig: %i\n",
+                  key->uids->signatures->exportable);
+         exit (1);
+       }
+
+      if (key->uids && key->uids->next && key->uids->next->revoked)
+       {
+         fprintf (stderr, "Second user ID unexpectedly revoked\n");
+         exit (1);
+       }
+      if (key->uids && key->uids->next && key->uids->next->invalid)
+       {
+         fprintf (stderr, "Second user ID unexpectedly invalid\n");
+         exit (1);
+       }
+      if (key->uids && key->uids->next
+         && key->uids->next->validity != GPGME_VALIDITY_UNKNOWN)
+       {
+         fprintf (stderr, "Second user ID has unexpectedly validity: %i\n",
+                  key->uids->next->validity);
+         exit (1);
+       }
+      if (keys[i].uid[1].name
+         && strcmp (keys[i].uid[1].name, key->uids->next->name))
+       {
+         fprintf (stderr, "Unexpected name in second user ID: %s\n",
+                  key->uids->next->name);
+         exit (1);
+       }
+      if (keys[i].uid[1].comment
+         && strcmp (keys[i].uid[1].comment, key->uids->next->comment))
+       {
+         fprintf (stderr, "Unexpected comment in second user ID: %s\n",
+                  key->uids->next->comment);
+         exit (1);
+       }
+      if (keys[i].uid[1].email
+         && strcmp (keys[i].uid[1].email, key->uids->next->email))
+       {
+         fprintf (stderr, "Unexpected email in second user ID: %s\n",
+                  key->uids->next->email);
+         exit (1);
+       }
+      if (key->uids && (!key->uids->next->signatures || key->uids->next->signatures->next))
+       {
+         fprintf (stderr, "Second user ID unexpected number of signatures\n");
+         exit (1);
+       }
+      if (keys[i].uid[1].sig.algo != key->uids->next->signatures->pubkey_algo)
+       {
+         fprintf (stderr, "Unexpected algorithm in second user ID sig: %s\n",
+                  gpgme_pubkey_algo_name (key->uids->next->signatures->pubkey_algo));
+         exit (1);
+       }
+      if (strcmp (keys[i].uid[1].sig.keyid, key->uids->next->signatures->keyid))
+       {
+         fprintf (stderr, "Unexpected key ID in second user ID sig: %s\n",
+                  key->uids->next->signatures->keyid);
+         exit (1);
+       }
+      if (keys[i].uid[1].sig.timestamp != key->uids->next->signatures->timestamp)
+       {
+         fprintf (stderr, "Unexpected timestamp in second user ID sig: %li\n",
+                  key->uids->next->signatures->timestamp);
+         exit (1);
+       }
+      if (strcmp (keys[i].uid[1].sig.name, key->uids->next->signatures->name))
+       {
+         fprintf (stderr, "Unexpected name in second user ID sig: %s\n",
+                  key->uids->next->signatures->name);
+         exit (1);
+       }
+      if (strcmp (keys[i].uid[1].sig.comment, key->uids->next->signatures->comment))
+       {
+         fprintf (stderr, "Unexpected comment in second user ID sig: %s\n",
+                  key->uids->next->signatures->comment);
+         exit (1);
+       }
+      if (strcmp (keys[i].uid[1].sig.email, key->uids->next->signatures->email))
+       {
+         fprintf (stderr, "Unexpected email in second user ID sig: %s\n",
+                  key->uids->next->signatures->email);
+         exit (1);
+       }
+      if (keys[i].uid[1].sig.class != key->uids->next->signatures->class)
+       {
+         fprintf (stderr, "Unexpected class in second user ID sig: %i\n",
+                  key->uids->next->signatures->class);
+         exit (1);
+       }
+      if (keys[i].uid[1].sig.exportable != key->uids->next->signatures->exportable)
+       {
+         fprintf (stderr, "Unexpected exportable stat in second user ID sig: %i\n",
+                  key->uids->next->signatures->exportable);
+         exit (1);
+       }
+
+      if (key->uids && key->uids->next && key->uids->next->next
+         && key->uids->next->next->revoked)
+       {
+         fprintf (stderr, "Third user ID unexpectedly revoked\n");
+         exit (1);
+       }
+      if (key->uids && key->uids->next && key->uids->next->next
+         && key->uids->next->next->invalid)
+       {
+         fprintf (stderr, "Third user ID unexpectedly invalid\n");
+         exit (1);
+       }
+      if (key->uids && key->uids->next && key->uids->next->next
+         && key->uids->next->next->validity != GPGME_VALIDITY_UNKNOWN)
+       {
+         fprintf (stderr, "Third user ID has unexpectedly validity: %i\n",
+                  key->uids->next->next->validity);
+         exit (1);
+       }
+      if (keys[i].uid[2].name
+         && strcmp (keys[i].uid[2].name, key->uids->next->next->name))
+       {
+         fprintf (stderr, "Unexpected name in third user ID: %s\n",
+                  key->uids->next->next->name);
+         exit (1);
+       }
+      if (keys[i].uid[2].comment
+         && strcmp (keys[i].uid[2].comment, key->uids->next->next->comment))
+       {
+         fprintf (stderr, "Unexpected comment in third user ID: %s\n",
+                  key->uids->next->next->comment);
+         exit (1);
+       }
+      if (keys[i].uid[2].email
+         && strcmp (keys[i].uid[2].email, key->uids->next->next->email))
+       {
+         fprintf (stderr, "Unexpected email in third user ID: %s\n",
+                  key->uids->next->next->email);
+         exit (1);
+       }
+      if (key->uids && (!key->uids->next->next->signatures
+                       || key->uids->next->next->signatures->next))
+       {
+         fprintf (stderr, "Third user ID unexpected number of signatures\n");
+         exit (1);
+       }
+      if (keys[i].uid[2].sig.algo != key->uids->next->next->signatures->pubkey_algo)
+       {
+         fprintf (stderr, "Unexpected algorithm in third user ID sig: %s\n",
+                  gpgme_pubkey_algo_name (key->uids->next->next->signatures->pubkey_algo));
+         exit (1);
+       }
+      if (strcmp (keys[i].uid[2].sig.keyid, key->uids->next->next->signatures->keyid))
+       {
+         fprintf (stderr, "Unexpected key ID in third user ID sig: %s\n",
+                  key->uids->next->next->signatures->keyid);
+         exit (1);
+       }
+      if (keys[i].uid[2].sig.timestamp != key->uids->next->next->signatures->timestamp)
+       {
+         fprintf (stderr, "Unexpected timestamp in third user ID sig: %li\n",
+                  key->uids->next->next->signatures->timestamp);
+         exit (1);
+       }
+      if (strcmp (keys[i].uid[2].sig.name, key->uids->next->next->signatures->name))
+       {
+         fprintf (stderr, "Unexpected name in third user ID sig: %s\n",
+                  key->uids->next->next->signatures->name);
+         exit (1);
+       }
+      if (strcmp (keys[i].uid[2].sig.comment, key->uids->next->next->signatures->comment))
+       {
+         fprintf (stderr, "Unexpected comment in third user ID sig: %s\n",
+                  key->uids->next->next->signatures->comment);
+         exit (1);
+       }
+      if (strcmp (keys[i].uid[2].sig.email, key->uids->next->next->signatures->email))
+       {
+         fprintf (stderr, "Unexpected email in third user ID sig: %s\n",
+                  key->uids->next->next->signatures->email);
+         exit (1);
+       }
+      if (keys[i].uid[2].sig.class != key->uids->next->next->signatures->class)
+       {
+         fprintf (stderr, "Unexpected class in third user ID sig: %i\n",
+                  key->uids->next->next->signatures->class);
+         exit (1);
+       }
+      if (keys[i].uid[2].sig.exportable != key->uids->next->next->signatures->exportable)
+       {
+         fprintf (stderr, "Unexpected exportable stat in third user ID sig: %i\n",
+                  key->uids->next->next->signatures->exportable);
+         exit (1);
+       }
+
+
+
+
+
+      gpgme_key_unref (key);
+      i++;
+    }
+  if (err != GPGME_EOF)
+    fail_if_err (err);
+  err = gpgme_op_keylist_end (ctx);
+  fail_if_err (err);
+
+  result = gpgme_op_keylist_result (ctx);
+  if (result->truncated)
+    {
+      fprintf (stderr, "Key listing unexpectedly truncated\n");
+      exit (1);
+    }
+
+  if (keys[i].fpr)
+    {
+      fprintf (stderr, "Less keys returned than expected\n");
+      exit (1);
+    }
+
+  gpgme_release (ctx);
+  return 0;
+}