Convert of evp_test to framework
[openssl.git] / test / evp_test.c
index e7396f7..0d5de4d 100644 (file)
 #include <openssl/pkcs12.h>
 #include <openssl/kdf.h>
 #include "internal/numbers.h"
+#include "testutil.h"
 
-/* Remove spaces from beginning and end of a string */
-
+/*
+ * Remove spaces from beginning and end of a string
+ */
 static void remove_space(char **pval)
 {
     unsigned char *p = (unsigned char *)*pval, *beginning;
@@ -40,43 +42,31 @@ static void remove_space(char **pval)
 /*
  * Given a line of the form:
  *      name = value # comment
- * extract name and value. NB: modifies passed buffer.
+ * extract name and value. NB: modifies |linebuf|.
  */
-
 static int parse_line(char **pkw, char **pval, char *linebuf)
 {
-    char *p;
-
-    p = linebuf + strlen(linebuf) - 1;
+    char *p = linebuf + strlen(linebuf) - 1;
 
     if (*p != '\n') {
-        fprintf(stderr, "FATAL: missing EOL\n");
-        exit(1);
+        TEST_error("FATAL: missing EOL");
+        return 0;
     }
 
     /* Look for # */
-
     p = strchr(linebuf, '#');
-
-    if (p)
+    if (p != NULL)
         *p = '\0';
 
     /* Look for = sign */
-    p = strchr(linebuf, '=');
-
-    /* If no '=' exit */
-    if (!p)
+    if ((p = strchr(linebuf, '=')) == NULL)
         return 0;
-
     *p++ = '\0';
 
     *pkw = linebuf;
     *pval = p;
-
-    /* Remove spaces from keyword and value */
     remove_space(pkw);
     remove_space(pval);
-
     return 1;
 }
 
@@ -92,6 +82,7 @@ static unsigned char* unescape(const char *input, size_t input_len,
 {
     unsigned char *ret, *p;
     size_t i;
+
     if (input_len == 0) {
         *out_len = 0;
         return OPENSSL_zalloc(1);
@@ -166,10 +157,9 @@ static int test_bin(const char *value, unsigned char **buf, size_t *buflen)
     }
 
     /* Otherwise assume as hex literal and convert it to binary buffer */
-    *buf = OPENSSL_hexstr2buf(value, &len);
-    if (!*buf) {
-        fprintf(stderr, "Value=%s\n", value);
-        ERR_print_errors_fp(stderr);
+    if (!TEST_ptr(*buf = OPENSSL_hexstr2buf(value, &len))) {
+        TEST_info("Cannot convert %s", value);
+        ERR_print_errors(bio_err);
         return -1;
     }
     /* Size of input buffer means we'll never overflow */
@@ -182,19 +172,20 @@ static int test_bin(const char *value, unsigned char **buf, size_t *buflen)
 static int test_uint64(const char *value, uint64_t *pr)
 {
     const char *p = value;
-    if (!*p) {
-        fprintf(stderr, "Invalid empty integer value\n");
+
+    if (!TEST_true(*p)) {
+        TEST_info("Invalid empty integer value");
         return -1;
     }
     *pr = 0;
     while (*p) {
-        if (*pr > UINT64_MAX/10) {
-            fprintf(stderr, "Integer string overflow value=%s\n", value);
+        if (*pr > UINT64_MAX / 10) {
+            TEST_error("Integer overflow in string %s", value);
             return -1;
         }
         *pr *= 10;
-        if (*p < '0' || *p > '9') {
-            fprintf(stderr, "Invalid integer string value=%s\n", value);
+        if (!TEST_true(isdigit(*p))) {
+            TEST_error("Invalid character in string %s", value);
             return -1;
         }
         *pr += *p - '0';
@@ -204,17 +195,16 @@ static int test_uint64(const char *value, uint64_t *pr)
 }
 #endif
 
+typedef struct evp_test_method_st EVP_TEST_METHOD;
+
 /* Structure holding test information */
-struct evp_test {
+typedef struct evp_test_st {
     /* file being read */
     BIO *in;
     /* temp memory BIO for reading in keys */
     BIO *key;
-    /* List of public and private keys */
-    struct key_list *private;
-    struct key_list *public;
     /* method for this test */
-    const struct evp_test_method *meth;
+    const EVP_TEST_METHOD *meth;
     /* current line being processed */
     unsigned int line;
     /* start line of current test */
@@ -242,40 +232,49 @@ struct evp_test {
     void *data;
     /* Current test should be skipped */
     int skip;
-};
+} EVP_TEST;
 
-struct key_list {
+/*
+ * Linked list of named keys.
+ */
+typedef struct key_list_st {
     char *name;
     EVP_PKEY *key;
-    struct key_list *next;
-};
+    struct key_list_st *next;
+} KEY_LIST;
+
+/* List of public and private keys */
+static KEY_LIST *private_keys;
+static KEY_LIST *public_keys;
 
-/* Test method structure */
-struct evp_test_method {
+/*
+ * Test method structure
+ */
+struct evp_test_method_st {
     /* Name of test as it appears in file */
     const char *name;
     /* Initialise test for "alg" */
-    int (*init) (struct evp_test * t, const char *alg);
+    int (*init) (EVP_TEST * t, const char *alg);
     /* Clean up method */
-    void (*cleanup) (struct evp_test * t);
+    void (*cleanup) (EVP_TEST * t);
     /* Test specific name value pair processing */
-    int (*parse) (struct evp_test * t, const char *name, const char *value);
+    int (*parse) (EVP_TEST * t, const char *name, const char *value);
     /* Run the test itself */
-    int (*run_test) (struct evp_test * t);
+    int (*run_test) (EVP_TEST * t);
 };
 
-static const struct evp_test_method digest_test_method, cipher_test_method;
-static const struct evp_test_method mac_test_method;
-static const struct evp_test_method psign_test_method, pverify_test_method;
-static const struct evp_test_method pdecrypt_test_method;
-static const struct evp_test_method pverify_recover_test_method;
-static const struct evp_test_method pderive_test_method;
-static const struct evp_test_method pbe_test_method;
-static const struct evp_test_method encode_test_method;
-static const struct evp_test_method kdf_test_method;
-static const struct evp_test_method keypair_test_method;
-
-static const struct evp_test_method *evp_test_list[] = {
+static const EVP_TEST_METHOD digest_test_method, cipher_test_method;
+static const EVP_TEST_METHOD mac_test_method;
+static const EVP_TEST_METHOD psign_test_method, pverify_test_method;
+static const EVP_TEST_METHOD pdecrypt_test_method;
+static const EVP_TEST_METHOD pverify_recover_test_method;
+static const EVP_TEST_METHOD pderive_test_method;
+static const EVP_TEST_METHOD pbe_test_method;
+static const EVP_TEST_METHOD encode_test_method;
+static const EVP_TEST_METHOD kdf_test_method;
+static const EVP_TEST_METHOD keypair_test_method;
+
+static const EVP_TEST_METHOD *evp_test_list[] = {
     &digest_test_method,
     &cipher_test_method,
     &mac_test_method,
@@ -291,9 +290,9 @@ static const struct evp_test_method *evp_test_list[] = {
     NULL
 };
 
-static const struct evp_test_method *evp_find_test(const char *name)
+static const EVP_TEST_METHOD *evp_find_test(const char *name)
 {
-    const struct evp_test_method **tt;
+    const EVP_TEST_METHOD **tt;
 
     for (tt = evp_test_list; *tt; tt++) {
         if (strcmp(name, (*tt)->name) == 0)
@@ -305,13 +304,14 @@ static const struct evp_test_method *evp_find_test(const char *name)
 static void hex_print(const char *name, const unsigned char *buf, size_t len)
 {
     size_t i;
+
     fprintf(stderr, "%s ", name);
     for (i = 0; i < len; i++)
         fprintf(stderr, "%02X", buf[i]);
     fputs("\n", stderr);
 }
 
-static void free_expected(struct evp_test *t)
+static void clear_test(EVP_TEST *t)
 {
     OPENSSL_free(t->expected_err);
     t->expected_err = NULL;
@@ -320,51 +320,55 @@ static void free_expected(struct evp_test *t)
     OPENSSL_free(t->reason);
     t->reason = NULL;
     OPENSSL_free(t->out_expected);
-    OPENSSL_free(t->out_received);
     t->out_expected = NULL;
-    t->out_received = NULL;
     t->out_expected_len = 0;
+    OPENSSL_free(t->out_received);
+    t->out_received = NULL;
     t->out_received_len = 0;
     /* Literals. */
     t->err = NULL;
 }
 
-static void print_expected(struct evp_test *t)
+static void print_expected(EVP_TEST *t)
 {
     if (t->out_expected == NULL && t->out_received == NULL)
         return;
     hex_print("Expected:", t->out_expected, t->out_expected_len);
     hex_print("Got:     ", t->out_received, t->out_received_len);
-    free_expected(t);
+    clear_test(t);
 }
 
-static int check_test_error(struct evp_test *t)
+/*
+ * Check for errors in the test structure; return 1 if okay, else 0.
+ */
+static int check_test_error(EVP_TEST *t)
 {
     unsigned long err;
     const char *func;
     const char *reason;
-    if (!t->err && !t->expected_err)
+
+    if (t->err == NULL && t->expected_err == NULL)
         return 1;
-    if (t->err && !t->expected_err) {
+    if (t->err != NULL && t->expected_err == NULL) {
         if (t->aux_err != NULL) {
-            fprintf(stderr, "Test line %d(%s): unexpected error %s\n",
-                    t->start_line, t->aux_err, t->err);
+            TEST_info("Test line %d(%s): unexpected error %s",
+                      t->start_line, t->aux_err, t->err);
         } else {
-            fprintf(stderr, "Test line %d: unexpected error %s\n",
-                    t->start_line, t->err);
+            TEST_info("Test line %d: unexpected error %s",
+                      t->start_line, t->err);
         }
         print_expected(t);
         return 0;
     }
-    if (!t->err && t->expected_err) {
-        fprintf(stderr, "Test line %d: succeeded expecting %s\n",
-                t->start_line, t->expected_err);
+    if (t->err == NULL && t->expected_err != NULL) {
+        TEST_info("Test line %d: succeeded expecting %s",
+                  t->start_line, t->expected_err);
         return 0;
     }
 
     if (strcmp(t->err, t->expected_err) != 0) {
-        fprintf(stderr, "Test line %d: expecting %s got %s\n",
-                t->start_line, t->expected_err, t->err);
+        TEST_info("Test line %d: expecting %s got %s",
+                  t->start_line, t->expected_err, t->err);
         return 0;
     }
 
@@ -372,50 +376,52 @@ static int check_test_error(struct evp_test *t)
         return 1;
 
     if (t->func == NULL || t->reason == NULL) {
-        fprintf(stderr, "Test line %d: missing function or reason code\n",
-                t->start_line);
+        TEST_info("Test line %d: missing function or reason code",
+                  t->start_line);
         return 0;
     }
 
     err = ERR_peek_error();
     if (err == 0) {
-        fprintf(stderr, "Test line %d, expected error \"%s:%s\" not set\n",
-                t->start_line, t->func, t->reason);
+        TEST_info("Test line %d, expected error \"%s:%s\" not set",
+                  t->start_line, t->func, t->reason);
         return 0;
     }
 
     func = ERR_func_error_string(err);
     reason = ERR_reason_error_string(err);
-
     if (func == NULL && reason == NULL) {
-        fprintf(stderr, "Test line %d: expected error \"%s:%s\", no strings available.  Skipping...\n",
-                t->start_line, t->func, t->reason);
+        TEST_info("Test line %d: expected error \"%s:%s\","
+                  " no strings available.  Skipping...\n",
+                  t->start_line, t->func, t->reason);
         return 1;
     }
 
     if (strcmp(func, t->func) == 0 && strcmp(reason, t->reason) == 0)
         return 1;
 
-    fprintf(stderr, "Test line %d: expected error \"%s:%s\", got \"%s:%s\"\n",
-            t->start_line, t->func, t->reason, func, reason);
+    TEST_info("Test line %d: expected error \"%s:%s\", got \"%s:%s\"",
+              t->start_line, t->func, t->reason, func, reason);
 
     return 0;
 }
 
-/* Setup a new test, run any existing test */
-
-static int setup_test(struct evp_test *t, const struct evp_test_method *tmeth)
+/*
+ * Setup a new test, run any existing test. Log a message and return 0
+ * on error.
+ */
+static int run_and_get_next(EVP_TEST *t, const EVP_TEST_METHOD *tmeth)
 {
     /* If we already have a test set up run it */
     if (t->meth) {
         t->ntests++;
         if (t->skip) {
+            TEST_info("Line %d skipped %s test", t->start_line, t->meth->name);
             t->nskip++;
         } else {
             /* run the test */
             if (t->err == NULL && t->meth->run_test(t) != 1) {
-                fprintf(stderr, "%s test error line %d\n",
-                        t->meth->name, t->start_line);
+                TEST_info("Line %d error %s", t->start_line, t->meth->name);
                 return 0;
             }
             if (!check_test_error(t)) {
@@ -431,15 +437,13 @@ static int setup_test(struct evp_test *t, const struct evp_test_method *tmeth)
             OPENSSL_free(t->data);
             t->data = NULL;
         }
-        OPENSSL_free(t->expected_err);
-        t->expected_err = NULL;
-        free_expected(t);
+        clear_test(t);
     }
     t->meth = tmeth;
     return 1;
 }
 
-static int find_key(EVP_PKEY **ppk, const char *name, struct key_list *lst)
+static int find_key(EVP_PKEY **ppk, const char *name, KEY_LIST *lst)
 {
     for (; lst; lst = lst->next) {
         if (strcmp(lst->name, name) == 0) {
@@ -451,10 +455,11 @@ static int find_key(EVP_PKEY **ppk, const char *name, struct key_list *lst)
     return 0;
 }
 
-static void free_key_list(struct key_list *lst)
+static void free_key_list(KEY_LIST *lst)
 {
     while (lst != NULL) {
-        struct key_list *ltmp;
+        KEY_LIST *ltmp;
+
         EVP_PKEY_free(lst->key);
         OPENSSL_free(lst->name);
         ltmp = lst->next;
@@ -466,8 +471,9 @@ static void free_key_list(struct key_list *lst)
 static int check_unsupported()
 {
     long err = ERR_peek_error();
+
     if (ERR_GET_LIB(err) == ERR_LIB_EVP
-        && ERR_GET_REASON(err) == EVP_R_UNSUPPORTED_ALGORITHM) {
+            && ERR_GET_REASON(err) == EVP_R_UNSUPPORTED_ALGORITHM) {
         ERR_clear_error();
         return 1;
     }
@@ -487,40 +493,40 @@ static int check_unsupported()
 }
 
 
-static int read_key(struct evp_test *t)
+static int read_key(EVP_TEST *t)
 {
     char tmpbuf[80];
-    if (t->key == NULL)
-        t->key = BIO_new(BIO_s_mem());
-    else if (BIO_reset(t->key) <= 0)
-        return 0;
+
     if (t->key == NULL) {
-        fprintf(stderr, "Error allocating key memory BIO\n");
+        if (!TEST_ptr(t->key = BIO_new(BIO_s_mem())))
+            return 0;
+    } else if (!TEST_int_gt(BIO_reset(t->key), 0)) {
         return 0;
     }
+
     /* Read to PEM end line and place content in memory BIO */
     while (BIO_gets(t->in, tmpbuf, sizeof(tmpbuf))) {
         t->line++;
-        if (BIO_puts(t->key, tmpbuf) <= 0) {
-            fprintf(stderr, "Error writing to key memory BIO\n");
+        if (!TEST_int_gt(BIO_puts(t->key, tmpbuf), 0))
             return 0;
-        }
         if (strncmp(tmpbuf, "-----END", 8) == 0)
             return 1;
     }
-    fprintf(stderr, "Can't find key end\n");
+    TEST_error("Can't find key end");
     return 0;
 }
 
-static int process_test(struct evp_test *t, char *buf, int verbose)
+/*
+ * Parse a line into the current test |t|.  Return 0 on error.
+ */
+static int parse_test_line(EVP_TEST *t, char *buf)
 {
     char *keyword = NULL, *value = NULL;
-    int rv = 0, add_key = 0;
-    struct key_list **lst = NULL, *key = NULL;
+    int add_key = 0;
+    KEY_LIST **lst = NULL, *key = NULL;
     EVP_PKEY *pk = NULL;
-    const struct evp_test_method *tmeth = NULL;
-    if (verbose)
-        fputs(buf, stdout);
+    const EVP_TEST_METHOD *tmeth = NULL;
+
     if (!parse_line(&keyword, &value, buf))
         return 1;
     if (strcmp(keyword, "PrivateKey") == 0) {
@@ -528,11 +534,11 @@ static int process_test(struct evp_test *t, char *buf, int verbose)
             return 0;
         pk = PEM_read_bio_PrivateKey(t->key, NULL, 0, NULL);
         if (pk == NULL && !check_unsupported()) {
-            fprintf(stderr, "Error reading private key %s\n", value);
+            TEST_info("Error reading private key %s", value);
             ERR_print_errors_fp(stderr);
             return 0;
         }
-        lst = &t->private;
+        lst = &private_keys;
         add_key = 1;
     }
     if (strcmp(keyword, "PublicKey") == 0) {
@@ -540,23 +546,22 @@ static int process_test(struct evp_test *t, char *buf, int verbose)
             return 0;
         pk = PEM_read_bio_PUBKEY(t->key, NULL, 0, NULL);
         if (pk == NULL && !check_unsupported()) {
-            fprintf(stderr, "Error reading public key %s\n", value);
+            TEST_info("Error reading public key %s", value);
             ERR_print_errors_fp(stderr);
             return 0;
         }
-        lst = &t->public;
+        lst = &public_keys;
         add_key = 1;
     }
     /* If we have a key add to list */
     if (add_key) {
         if (find_key(NULL, value, *lst)) {
-            fprintf(stderr, "Duplicate key %s\n", value);
+            TEST_info("Duplicate key %s", value);
             return 0;
         }
-        key = OPENSSL_malloc(sizeof(*key));
-        if (!key)
+        if (!TEST_ptr(key = OPENSSL_malloc(sizeof(*key)))
+                || !TEST_ptr(key->name = OPENSSL_strdup(value)))
             return 0;
-        key->name = OPENSSL_strdup(value);
         key->key = pk;
         key->next = *lst;
         *lst = key;
@@ -564,146 +569,60 @@ static int process_test(struct evp_test *t, char *buf, int verbose)
     }
 
     /* See if keyword corresponds to a test start */
-    tmeth = evp_find_test(keyword);
-    if (tmeth) {
-        if (!setup_test(t, tmeth))
+    if ((tmeth = evp_find_test(keyword)) != NULL) {
+        if (!run_and_get_next(t, tmeth))
             return 0;
         t->start_line = t->line;
         t->skip = 0;
         if (!tmeth->init(t, value)) {
-            fprintf(stderr, "Unknown %s: %s\n", keyword, value);
+            TEST_info("Unknown %s: %s", keyword, value);
             return 0;
         }
         return 1;
-    } else if (t->skip) {
+    }
+    if (t->skip)
         return 1;
-    } else if (strcmp(keyword, "Result") == 0) {
+    if (strcmp(keyword, "Result") == 0) {
         if (t->expected_err) {
-            fprintf(stderr, "Line %d: multiple result lines\n", t->line);
+            TEST_info("Line %d: multiple result lines", t->line);
             return 0;
         }
-        t->expected_err = OPENSSL_strdup(value);
-        if (t->expected_err == NULL)
+        if (!TEST_ptr(t->expected_err = OPENSSL_strdup(value)))
             return 0;
     } else if (strcmp(keyword, "Function") == 0) {
         if (t->func != NULL) {
-            fprintf(stderr, "Line %d: multiple function lines\n", t->line);
+            TEST_info("Line %d: multiple function lines\n", t->line);
             return 0;
         }
-        t->func = OPENSSL_strdup(value);
-        if (t->func == NULL)
+        if (!TEST_ptr(t->func = OPENSSL_strdup(value)))
             return 0;
     } else if (strcmp(keyword, "Reason") == 0) {
         if (t->reason != NULL) {
-            fprintf(stderr, "Line %d: multiple reason lines\n", t->line);
+            TEST_info("Line %d: multiple reason lines", t->line);
             return 0;
         }
-        t->reason = OPENSSL_strdup(value);
-        if (t->reason == NULL)
+        if (!TEST_ptr(t->reason = OPENSSL_strdup(value)))
             return 0;
     } else {
         /* Must be test specific line: try to parse it */
-        if (t->meth)
-            rv = t->meth->parse(t, keyword, value);
+        int rv = t->meth == NULL ? 0 : t->meth->parse(t, keyword, value);
 
-        if (rv == 0)
-            fprintf(stderr, "line %d: unexpected keyword %s\n",
-                    t->line, keyword);
-
-        if (rv < 0)
-            fprintf(stderr, "line %d: error processing keyword %s\n",
-                    t->line, keyword);
-        if (rv <= 0)
+        if (rv == 0) {
+            TEST_info("Line %d: unknown keyword %s", t->line, keyword);
             return 0;
+        }
+        if (rv < 0) {
+            TEST_info("Line %d: error processing keyword %s\n",
+                      t->line, keyword);
+            return 0;
+        }
     }
     return 1;
 }
 
-static int check_var_length_output(struct evp_test *t,
-                                   const unsigned char *expected,
-                                   size_t expected_len,
-                                   const unsigned char *received,
-                                   size_t received_len)
-{
-    if (expected_len == received_len &&
-        memcmp(expected, received, expected_len) == 0) {
-        return 0;
-    }
-
-    /* The result printing code expects a non-NULL buffer. */
-    t->out_expected = OPENSSL_memdup(expected, expected_len ? expected_len : 1);
-    t->out_expected_len = expected_len;
-    t->out_received = OPENSSL_memdup(received, received_len ? received_len : 1);
-    t->out_received_len = received_len;
-    if (t->out_expected == NULL || t->out_received == NULL) {
-        fprintf(stderr, "Memory allocation error!\n");
-        exit(1);
-    }
-    return 1;
-}
-
-static int check_output(struct evp_test *t,
-                        const unsigned char *expected,
-                        const unsigned char *received,
-                        size_t len)
-{
-    return check_var_length_output(t, expected, len, received, len);
-}
-
-int main(int argc, char **argv)
-{
-    BIO *in = NULL;
-    char buf[10240];
-    struct evp_test t;
-
-    if (argc != 2) {
-        fprintf(stderr, "usage: evp_test testfile.txt\n");
-        return 1;
-    }
-
-    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
-
-    memset(&t, 0, sizeof(t));
-    t.start_line = -1;
-    in = BIO_new_file(argv[1], "rb");
-    if (in == NULL) {
-        fprintf(stderr, "Can't open %s for reading\n", argv[1]);
-        return 1;
-    }
-    t.in = in;
-    t.err = NULL;
-    while (BIO_gets(in, buf, sizeof(buf))) {
-        t.line++;
-        if (!process_test(&t, buf, 0))
-            exit(1);
-    }
-    /* Run any final test we have */
-    if (!setup_test(&t, NULL))
-        exit(1);
-    fprintf(stderr, "%d tests completed with %d errors, %d skipped\n",
-            t.ntests, t.errors, t.nskip);
-    free_key_list(t.public);
-    free_key_list(t.private);
-    BIO_free(t.key);
-    BIO_free(in);
-
-#ifndef OPENSSL_NO_CRYPTO_MDEBUG
-    if (CRYPTO_mem_leaks_fp(stderr) <= 0)
-        return 1;
-#endif
-    if (t.errors)
-        return 1;
-    return 0;
-}
-
-static void test_free(void *d)
-{
-    OPENSSL_free(d);
-}
-
 /* Message digest tests */
 
-struct digest_data {
+typedef struct digest_data_st {
     /* Digest this test is for */
     const EVP_MD *digest;
     /* Input to digest */
@@ -714,12 +633,13 @@ struct digest_data {
     /* Expected output */
     unsigned char *output;
     size_t output_len;
-};
+} DIGEST_DATA;
 
-static int digest_test_init(struct evp_test *t, const char *alg)
+static int digest_test_init(EVP_TEST *t, const char *alg)
 {
     const EVP_MD *digest;
-    struct digest_data *mdat;
+    DIGEST_DATA *mdat;
+
     digest = EVP_get_digestbyname(alg);
     if (!digest) {
         /* If alg has an OID assume disabled algorithm */
@@ -729,26 +649,26 @@ static int digest_test_init(struct evp_test *t, const char *alg)
         }
         return 0;
     }
-    mdat = OPENSSL_malloc(sizeof(*mdat));
+    mdat = OPENSSL_zalloc(sizeof(*mdat));
     mdat->digest = digest;
-    mdat->input = NULL;
-    mdat->output = NULL;
     mdat->nrpt = 1;
     t->data = mdat;
     return 1;
 }
 
-static void digest_test_cleanup(struct evp_test *t)
+static void digest_test_cleanup(EVP_TEST *t)
 {
-    struct digest_data *mdat = t->data;
-    test_free(mdat->input);
-    test_free(mdat->output);
+    DIGEST_DATA *mdat = t->data;
+
+    OPENSSL_free(mdat->input);
+    OPENSSL_free(mdat->output);
 }
 
-static int digest_test_parse(struct evp_test *t,
+static int digest_test_parse(EVP_TEST *t,
                              const char *keyword, const char *value)
 {
-    struct digest_data *mdata = t->data;
+    DIGEST_DATA *mdata = t->data;
+
     if (strcmp(keyword, "Input") == 0)
         return test_bin(value, &mdata->input, &mdata->input_len);
     if (strcmp(keyword, "Output") == 0)
@@ -763,42 +683,47 @@ static int digest_test_parse(struct evp_test *t,
     return 0;
 }
 
-static int digest_test_run(struct evp_test *t)
+static int digest_test_run(EVP_TEST *t)
 {
-    struct digest_data *mdata = t->data;
+    DIGEST_DATA *mdata = t->data;
     size_t i;
-    const char *err = "INTERNAL_ERROR";
     EVP_MD_CTX *mctx;
     unsigned char md[EVP_MAX_MD_SIZE];
     unsigned int md_len;
-    mctx = EVP_MD_CTX_new();
-    if (!mctx)
+
+    t->err = "TEST_FAILURE";
+    if (!TEST_ptr(mctx = EVP_MD_CTX_new()))
         goto err;
-    err = "DIGESTINIT_ERROR";
-    if (!EVP_DigestInit_ex(mctx, mdata->digest, NULL))
+
+    if (!EVP_DigestInit_ex(mctx, mdata->digest, NULL)) {
+        t->err = "DIGESTINIT_ERROR";
         goto err;
-    err = "DIGESTUPDATE_ERROR";
-    for (i = 0; i < mdata->nrpt; i++) {
-        if (!EVP_DigestUpdate(mctx, mdata->input, mdata->input_len))
-            goto err;
     }
-    err = "DIGESTFINAL_ERROR";
-    if (!EVP_DigestFinal(mctx, md, &md_len))
+    for (i = 0; i < mdata->nrpt; i++)
+        if (!EVP_DigestUpdate(mctx, mdata->input, mdata->input_len)) {
+            t->err = "DIGESTUPDATE_ERROR";
+            goto err;
+        }
+    if (!EVP_DigestFinal(mctx, md, &md_len)) {
+        t->err = "DIGESTFINAL_ERROR";
         goto err;
-    err = "DIGEST_LENGTH_MISMATCH";
-    if (md_len != mdata->output_len)
+    }
+    if (md_len != mdata->output_len) {
+        t->err = "DIGEST_LENGTH_MISMATCH";
         goto err;
-    err = "DIGEST_MISMATCH";
-    if (check_output(t, mdata->output, md, md_len))
+    }
+    if (!TEST_mem_eq(mdata->output, mdata->output_len, md, md_len)) {
+        t->err = "DIGEST_MISMATCH";
         goto err;
-    err = NULL;
+    }
+    t->err = NULL;
+
  err:
     EVP_MD_CTX_free(mctx);
-    t->err = err;
     return 1;
 }
 
-static const struct evp_test_method digest_test_method = {
+static const EVP_TEST_METHOD digest_test_method = {
     "Digest",
     digest_test_init,
     digest_test_cleanup,
@@ -807,7 +732,7 @@ static const struct evp_test_method digest_test_method = {
 };
 
 /* Cipher tests */
-struct cipher_data {
+typedef struct cipher_data_st {
     const EVP_CIPHER *cipher;
     int enc;
     /* EVP_CIPH_GCM_MODE, EVP_CIPH_CCM_MODE or EVP_CIPH_OCB_MODE if AEAD */
@@ -825,12 +750,13 @@ struct cipher_data {
     size_t aad_len;
     unsigned char *tag;
     size_t tag_len;
-};
+} CIPHER_DATA;
 
-static int cipher_test_init(struct evp_test *t, const char *alg)
+static int cipher_test_init(EVP_TEST *t, const char *alg)
 {
     const EVP_CIPHER *cipher;
-    struct cipher_data *cdat = t->data;
+    CIPHER_DATA *cdat = t->data;
+
     cipher = EVP_get_cipherbyname(alg);
     if (!cipher) {
         /* If alg has an OID assume disabled algorithm */
@@ -862,21 +788,23 @@ static int cipher_test_init(struct evp_test *t, const char *alg)
     return 1;
 }
 
-static void cipher_test_cleanup(struct evp_test *t)
+static void cipher_test_cleanup(EVP_TEST *t)
 {
-    struct cipher_data *cdat = t->data;
-    test_free(cdat->key);
-    test_free(cdat->iv);
-    test_free(cdat->ciphertext);
-    test_free(cdat->plaintext);
-    test_free(cdat->aad);
-    test_free(cdat->tag);
+    CIPHER_DATA *cdat = t->data;
+
+    OPENSSL_free(cdat->key);
+    OPENSSL_free(cdat->iv);
+    OPENSSL_free(cdat->ciphertext);
+    OPENSSL_free(cdat->plaintext);
+    OPENSSL_free(cdat->aad);
+    OPENSSL_free(cdat->tag);
 }
 
-static int cipher_test_parse(struct evp_test *t, const char *keyword,
+static int cipher_test_parse(EVP_TEST *t, const char *keyword,
                              const char *value)
 {
-    struct cipher_data *cdat = t->data;
+    CIPHER_DATA *cdat = t->data;
+
     if (strcmp(keyword, "Key") == 0)
         return test_bin(value, &cdat->key, &cdat->key_len);
     if (strcmp(keyword, "IV") == 0)
@@ -904,18 +832,17 @@ static int cipher_test_parse(struct evp_test *t, const char *keyword,
     return 0;
 }
 
-static int cipher_test_enc(struct evp_test *t, int enc,
+static int cipher_test_enc(EVP_TEST *t, int enc,
                            size_t out_misalign, size_t inp_misalign, int frag)
 {
-    struct cipher_data *cdat = t->data;
+    CIPHER_DATA *cdat = t->data;
     unsigned char *in, *out, *tmp = NULL;
     size_t in_len, out_len, donelen = 0;
-    int tmplen, chunklen, tmpflen;
+    int ok = 0, tmplen, chunklen, tmpflen;
     EVP_CIPHER_CTX *ctx = NULL;
-    const char *err;
-    err = "INTERNAL_ERROR";
-    ctx = EVP_CIPHER_CTX_new();
-    if (!ctx)
+
+    t->err = "TEST_FAILURE";
+    if (!TEST_ptr(ctx = EVP_CIPHER_CTX_new()))
         goto err;
     EVP_CIPHER_CTX_set_flags(ctx, EVP_CIPHER_CTX_FLAG_WRAP_ALLOW);
     if (enc) {
@@ -954,17 +881,21 @@ static int cipher_test_enc(struct evp_test *t, int enc,
         in = memcpy(tmp + out_misalign + in_len + 2 * EVP_MAX_BLOCK_LENGTH +
                     inp_misalign, in, in_len);
     }
-    err = "CIPHERINIT_ERROR";
-    if (!EVP_CipherInit_ex(ctx, cdat->cipher, NULL, NULL, NULL, enc))
+    if (!EVP_CipherInit_ex(ctx, cdat->cipher, NULL, NULL, NULL, enc)) {
+        t->err = "CIPHERINIT_ERROR";
         goto err;
-    err = "INVALID_IV_LENGTH";
+    }
     if (cdat->iv) {
         if (cdat->aead) {
             if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN,
-                                     cdat->iv_len, 0))
+                                     cdat->iv_len, 0)) {
+                t->err = "INVALID_IV_LENGTH";
                 goto err;
-        } else if (cdat->iv_len != (size_t)EVP_CIPHER_CTX_iv_length(ctx))
+            }
+        } else if (cdat->iv_len != (size_t)EVP_CIPHER_CTX_iv_length(ctx)) {
+            t->err = "INVALID_IV_LENGTH";
             goto err;
+        }
     }
     if (cdat->aead) {
         unsigned char *tag;
@@ -973,10 +904,10 @@ static int cipher_test_enc(struct evp_test *t, int enc,
          * set tag length and value.
          */
         if (enc || cdat->aead == EVP_CIPH_OCB_MODE) {
-            err = "TAG_LENGTH_SET_ERROR";
+            t->err = "TAG_LENGTH_SET_ERROR";
             tag = NULL;
         } else {
-            err = "TAG_SET_ERROR";
+            t->err = "TAG_SET_ERROR";
             tag = cdat->tag;
         }
         if (tag || cdat->aead != EVP_CIPH_GCM_MODE) {
@@ -986,29 +917,31 @@ static int cipher_test_enc(struct evp_test *t, int enc,
         }
     }
 
-    err = "INVALID_KEY_LENGTH";
-    if (!EVP_CIPHER_CTX_set_key_length(ctx, cdat->key_len))
+    if (!EVP_CIPHER_CTX_set_key_length(ctx, cdat->key_len)) {
+        t->err = "INVALID_KEY_LENGTH";
         goto err;
-    err = "KEY_SET_ERROR";
-    if (!EVP_CipherInit_ex(ctx, NULL, NULL, cdat->key, cdat->iv, -1))
+    }
+    if (!EVP_CipherInit_ex(ctx, NULL, NULL, cdat->key, cdat->iv, -1)) {
+        t->err = "KEY_SET_ERROR";
         goto err;
+    }
 
     if (!enc && cdat->aead == EVP_CIPH_OCB_MODE) {
         if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG,
                                  cdat->tag_len, cdat->tag)) {
-            err = "TAG_SET_ERROR";
+            t->err = "TAG_SET_ERROR";
             goto err;
         }
     }
 
     if (cdat->aead == EVP_CIPH_CCM_MODE) {
         if (!EVP_CipherUpdate(ctx, NULL, &tmplen, NULL, out_len)) {
-            err = "CCM_PLAINTEXT_LENGTH_SET_ERROR";
+            t->err = "CCM_PLAINTEXT_LENGTH_SET_ERROR";
             goto err;
         }
     }
     if (cdat->aad) {
-        err = "AAD_SET_ERROR";
+        t->err = "AAD_SET_ERROR";
         if (!frag) {
             if (!EVP_CipherUpdate(ctx, NULL, &chunklen, cdat->aad,
                                   cdat->aad_len))
@@ -1035,7 +968,7 @@ static int cipher_test_enc(struct evp_test *t, int enc,
         }
     }
     EVP_CIPHER_CTX_set_padding(ctx, 0);
-    err = "CIPHERUPDATE_ERROR";
+    t->err = "CIPHERUPDATE_ERROR";
     tmplen = 0;
     if (!frag) {
         /* We supply the data all in one go */
@@ -1065,42 +998,42 @@ static int cipher_test_enc(struct evp_test *t, int enc,
             tmplen += chunklen;
         }
     }
-    err = "CIPHERFINAL_ERROR";
-    if (!EVP_CipherFinal_ex(ctx, tmp + out_misalign + tmplen, &tmpflen))
+    if (!EVP_CipherFinal_ex(ctx, tmp + out_misalign + tmplen, &tmpflen)) {
+        t->err = "CIPHERFINAL_ERROR";
         goto err;
-    err = "LENGTH_MISMATCH";
-    if (out_len != (size_t)(tmplen + tmpflen))
-        goto err;
-    err = "VALUE_MISMATCH";
-    if (check_output(t, out, tmp + out_misalign, out_len))
+    }
+    if (!TEST_mem_eq(out, out_len, tmp + out_misalign, tmplen + tmpflen)) {
+        t->err = "VALUE_MISMATCH";
         goto err;
+    }
     if (enc && cdat->aead) {
         unsigned char rtag[16];
+
         if (cdat->tag_len > sizeof(rtag)) {
-            err = "TAG_LENGTH_INTERNAL_ERROR";
+            t->err = "TAG_LENGTH_INTERNAL_ERROR";
             goto err;
         }
         if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG,
                                  cdat->tag_len, rtag)) {
-            err = "TAG_RETRIEVE_ERROR";
+            t->err = "TAG_RETRIEVE_ERROR";
             goto err;
         }
-        if (check_output(t, cdat->tag, rtag, cdat->tag_len)) {
-            err = "TAG_VALUE_MISMATCH";
+        if (!TEST_mem_eq(cdat->tag, cdat->tag_len, rtag, cdat->tag_len)) {
+            t->err = "TAG_VALUE_MISMATCH";
             goto err;
         }
     }
-    err = NULL;
+    t->err = NULL;
+    ok = 1;
  err:
     OPENSSL_free(tmp);
     EVP_CIPHER_CTX_free(ctx);
-    t->err = err;
-    return err ? 0 : 1;
+    return ok;
 }
 
-static int cipher_test_run(struct evp_test *t)
+static int cipher_test_run(EVP_TEST *t)
 {
-    struct cipher_data *cdat = t->data;
+    CIPHER_DATA *cdat = t->data;
     int rv, frag = 0;
     size_t out_misalign, inp_misalign;
 
@@ -1176,7 +1109,7 @@ static int cipher_test_run(struct evp_test *t)
     return 1;
 }
 
-static const struct evp_test_method cipher_test_method = {
+static const EVP_TEST_METHOD cipher_test_method = {
     "Cipher",
     cipher_test_init,
     cipher_test_cleanup,
@@ -1184,7 +1117,7 @@ static const struct evp_test_method cipher_test_method = {
     cipher_test_run
 };
 
-struct mac_data {
+typedef struct mac_data_st {
     /* MAC type */
     int type;
     /* Algorithm string for this MAC */
@@ -1198,12 +1131,13 @@ struct mac_data {
     /* Expected output */
     unsigned char *output;
     size_t output_len;
-};
+} MAC_DATA;
 
-static int mac_test_init(struct evp_test *t, const char *alg)
+static int mac_test_init(EVP_TEST *t, const char *alg)
 {
     int type;
-    struct mac_data *mdat;
+    MAC_DATA *mdat;
+
     if (strcmp(alg, "HMAC") == 0) {
         type = EVP_PKEY_HMAC;
     } else if (strcmp(alg, "CMAC") == 0) {
@@ -1230,29 +1164,27 @@ static int mac_test_init(struct evp_test *t, const char *alg)
     } else
         return 0;
 
-    mdat = OPENSSL_malloc(sizeof(*mdat));
+    mdat = OPENSSL_zalloc(sizeof(*mdat));
     mdat->type = type;
-    mdat->alg = NULL;
-    mdat->key = NULL;
-    mdat->input = NULL;
-    mdat->output = NULL;
     t->data = mdat;
     return 1;
 }
 
-static void mac_test_cleanup(struct evp_test *t)
+static void mac_test_cleanup(EVP_TEST *t)
 {
-    struct mac_data *mdat = t->data;
-    test_free(mdat->alg);
-    test_free(mdat->key);
-    test_free(mdat->input);
-    test_free(mdat->output);
+    MAC_DATA *mdat = t->data;
+
+    OPENSSL_free(mdat->alg);
+    OPENSSL_free(mdat->key);
+    OPENSSL_free(mdat->input);
+    OPENSSL_free(mdat->output);
 }
 
-static int mac_test_parse(struct evp_test *t,
+static int mac_test_parse(EVP_TEST *t,
                           const char *keyword, const char *value)
 {
-    struct mac_data *mdata = t->data;
+    MAC_DATA *mdata = t->data;
+
     if (strcmp(keyword, "Key") == 0)
         return test_bin(value, &mdata->key, &mdata->key_len);
     if (strcmp(keyword, "Algorithm") == 0) {
@@ -1268,10 +1200,9 @@ static int mac_test_parse(struct evp_test *t,
     return 0;
 }
 
-static int mac_test_run(struct evp_test *t)
+static int mac_test_run(EVP_TEST *t)
 {
-    struct mac_data *mdata = t->data;
-    const char *err = "INTERNAL_ERROR";
+    MAC_DATA *mdata = t->data;
     EVP_MD_CTX *mctx = NULL;
     EVP_PKEY_CTX *pctx = NULL, *genctx = NULL;
     EVP_PKEY *key = NULL;
@@ -1282,75 +1213,75 @@ static int mac_test_run(struct evp_test *t)
 #ifdef OPENSSL_NO_DES
     if (mdata->alg != NULL && strstr(mdata->alg, "DES") != NULL) {
         /* Skip DES */
-        err = NULL;
+        t->err = NULL;
         goto err;
     }
 #endif
 
-    err = "MAC_PKEY_CTX_ERROR";
-    genctx = EVP_PKEY_CTX_new_id(mdata->type, NULL);
-    if (!genctx)
+    if (!TEST_ptr(genctx = EVP_PKEY_CTX_new_id(mdata->type, NULL))) {
+        t->err = "MAC_PKEY_CTX_ERROR";
         goto err;
+    }
 
-    err = "MAC_KEYGEN_INIT_ERROR";
-    if (EVP_PKEY_keygen_init(genctx) <= 0)
+    if (EVP_PKEY_keygen_init(genctx) <= 0) {
+        t->err = "MAC_KEYGEN_INIT_ERROR";
+        goto err;
+    }
+    if (mdata->type == EVP_PKEY_CMAC
+             && EVP_PKEY_CTX_ctrl_str(genctx, "cipher", mdata->alg) <= 0) {
+        t->err = "MAC_ALGORITHM_SET_ERROR";
         goto err;
-    if (mdata->type == EVP_PKEY_CMAC) {
-        err = "MAC_ALGORITHM_SET_ERROR";
-        if (EVP_PKEY_CTX_ctrl_str(genctx, "cipher", mdata->alg) <= 0)
-            goto err;
     }
 
-    err = "MAC_KEY_SET_ERROR";
-    if (EVP_PKEY_CTX_set_mac_key(genctx, mdata->key, mdata->key_len) <= 0)
+    if (EVP_PKEY_CTX_set_mac_key(genctx, mdata->key, mdata->key_len) <= 0) {
+        t->err = "MAC_KEY_SET_ERROR";
         goto err;
+    }
 
-    err = "MAC_KEY_GENERATE_ERROR";
-    if (EVP_PKEY_keygen(genctx, &key) <= 0)
+    if (EVP_PKEY_keygen(genctx, &key) <= 0) {
+        t->err = "MAC_KEY_GENERATE_ERROR";
         goto err;
+    }
     if (mdata->type == EVP_PKEY_HMAC) {
-        err = "MAC_ALGORITHM_SET_ERROR";
-        md = EVP_get_digestbyname(mdata->alg);
-        if (!md)
+        if (!TEST_ptr(md = EVP_get_digestbyname(mdata->alg))) {
+            t->err = "MAC_ALGORITHM_SET_ERROR";
             goto err;
+        }
     }
-    mctx = EVP_MD_CTX_new();
-    if (!mctx)
+    if (!TEST_ptr(mctx = EVP_MD_CTX_new())) {
+        t->err = "INTERNAL_ERROR";
         goto err;
-    err = "DIGESTSIGNINIT_ERROR";
-    if (!EVP_DigestSignInit(mctx, &pctx, md, NULL, key))
+    }
+    if (!EVP_DigestSignInit(mctx, &pctx, md, NULL, key)) {
+        t->err = "DIGESTSIGNINIT_ERROR";
         goto err;
+    }
 
-    err = "DIGESTSIGNUPDATE_ERROR";
-    if (!EVP_DigestSignUpdate(mctx, mdata->input, mdata->input_len))
-        goto err;
-    err = "DIGESTSIGNFINAL_LENGTH_ERROR";
-    if (!EVP_DigestSignFinal(mctx, NULL, &mac_len))
+    if (!EVP_DigestSignUpdate(mctx, mdata->input, mdata->input_len)) {
+        t->err = "DIGESTSIGNUPDATE_ERROR";
         goto err;
-    mac = OPENSSL_malloc(mac_len);
-    if (!mac) {
-        fprintf(stderr, "Error allocating mac buffer!\n");
-        exit(1);
     }
-    if (!EVP_DigestSignFinal(mctx, mac, &mac_len))
+    if (!EVP_DigestSignFinal(mctx, NULL, &mac_len)) {
+        t->err = "DIGESTSIGNFINAL_LENGTH_ERROR";
         goto err;
-    err = "MAC_LENGTH_MISMATCH";
-    if (mac_len != mdata->output_len)
-        goto err;
-    err = "MAC_MISMATCH";
-    if (check_output(t, mdata->output, mac, mac_len))
+    }
+    if (!TEST_ptr(mac = OPENSSL_malloc(mac_len))
+            || !EVP_DigestSignFinal(mctx, mac, &mac_len)
+            || !TEST_mem_eq(mdata->output, mdata->output_len, mac, mac_len)) {
+        t->err = "TEST_FAILURE";
         goto err;
-    err = NULL;
+    }
+
+    t->err = NULL;
  err:
     EVP_MD_CTX_free(mctx);
     OPENSSL_free(mac);
     EVP_PKEY_CTX_free(genctx);
     EVP_PKEY_free(key);
-    t->err = err;
     return 1;
 }
 
-static const struct evp_test_method mac_test_method = {
+static const EVP_TEST_METHOD mac_test_method = {
     "MAC",
     mac_test_init,
     mac_test_cleanup,
@@ -1363,7 +1294,7 @@ static const struct evp_test_method mac_test_method = {
  * a lot of common code.
  */
 
-struct pkey_data {
+typedef struct pkey_data_st {
     /* Context for this operation */
     EVP_PKEY_CTX *ctx;
     /* Key operation to perform */
@@ -1376,13 +1307,13 @@ struct pkey_data {
     /* Expected output */
     unsigned char *output;
     size_t output_len;
-};
+} PKEY_DATA;
 
 /*
  * Perform public key operation setup: lookup key, allocated ctx and call
  * the appropriate initialisation function
  */
-static int pkey_test_init(struct evp_test *t, const char *name,
+static int pkey_test_init(EVP_TEST *t, const char *name,
                           int use_public,
                           int (*keyopinit) (EVP_PKEY_CTX *ctx),
                           int (*keyop) (EVP_PKEY_CTX *ctx,
@@ -1391,20 +1322,20 @@ static int pkey_test_init(struct evp_test *t, const char *name,
                                         size_t tbslen)
     )
 {
-    struct pkey_data *kdata;
+    PKEY_DATA *kdata;
     EVP_PKEY *pkey = NULL;
     int rv = 0;
+
     if (use_public)
-        rv = find_key(&pkey, name, t->public);
-    if (!rv)
-        rv = find_key(&pkey, name, t->private);
-    if (!rv || pkey == NULL) {
+        rv = find_key(&pkey, name, public_keys);
+    if (rv == 0)
+        rv = find_key(&pkey, name, private_keys);
+    if (rv == 0 || pkey == NULL) {
         t->skip = 1;
         return 1;
     }
 
-    kdata = OPENSSL_malloc(sizeof(*kdata));
-    if (!kdata) {
+    if (!TEST_ptr(kdata = OPENSSL_malloc(sizeof(*kdata)))) {
         EVP_PKEY_free(pkey);
         return 0;
     }
@@ -1413,31 +1344,29 @@ static int pkey_test_init(struct evp_test *t, const char *name,
     kdata->output = NULL;
     kdata->keyop = keyop;
     t->data = kdata;
-    kdata->ctx = EVP_PKEY_CTX_new(pkey, NULL);
-    if (!kdata->ctx)
+    if (!TEST_ptr(kdata->ctx = EVP_PKEY_CTX_new(pkey, NULL)))
         return 0;
     if (keyopinit(kdata->ctx) <= 0)
         t->err = "KEYOP_INIT_ERROR";
     return 1;
 }
 
-static void pkey_test_cleanup(struct evp_test *t)
+static void pkey_test_cleanup(EVP_TEST *t)
 {
-    struct pkey_data *kdata = t->data;
+    PKEY_DATA *kdata = t->data;
 
     OPENSSL_free(kdata->input);
     OPENSSL_free(kdata->output);
     EVP_PKEY_CTX_free(kdata->ctx);
 }
 
-static int pkey_test_ctrl(struct evp_test *t, EVP_PKEY_CTX *pctx,
+static int pkey_test_ctrl(EVP_TEST *t, EVP_PKEY_CTX *pctx,
                           const char *value)
 {
     int rv;
     char *p, *tmpval;
 
-    tmpval = OPENSSL_strdup(value);
-    if (tmpval == NULL)
+    if (!TEST_ptr(tmpval = OPENSSL_strdup(value)))
         return 0;
     p = strchr(tmpval, ':');
     if (p != NULL)
@@ -1449,6 +1378,7 @@ static int pkey_test_ctrl(struct evp_test *t, EVP_PKEY_CTX *pctx,
     } else if (p != NULL && rv <= 0) {
         /* If p has an OID and lookup fails assume disabled algorithm */
         int nid = OBJ_sn2nid(p);
+
         if (nid == NID_undef)
              nid = OBJ_ln2nid(p);
         if ((nid != NID_undef) && EVP_get_digestbynid(nid) == NULL &&
@@ -1464,10 +1394,10 @@ static int pkey_test_ctrl(struct evp_test *t, EVP_PKEY_CTX *pctx,
     return rv > 0;
 }
 
-static int pkey_test_parse(struct evp_test *t,
+static int pkey_test_parse(EVP_TEST *t,
                            const char *keyword, const char *value)
 {
-    struct pkey_data *kdata = t->data;
+    PKEY_DATA *kdata = t->data;
     if (strcmp(keyword, "Input") == 0)
         return test_bin(value, &kdata->input, &kdata->input_len);
     if (strcmp(keyword, "Output") == 0)
@@ -1477,43 +1407,39 @@ static int pkey_test_parse(struct evp_test *t,
     return 0;
 }
 
-static int pkey_test_run(struct evp_test *t)
+static int pkey_test_run(EVP_TEST *t)
 {
-    struct pkey_data *kdata = t->data;
+    PKEY_DATA *kdata = t->data;
     unsigned char *out = NULL;
     size_t out_len;
-    const char *err = "KEYOP_LENGTH_ERROR";
+
     if (kdata->keyop(kdata->ctx, NULL, &out_len, kdata->input,
-                     kdata->input_len) <= 0)
-        goto err;
-    out = OPENSSL_malloc(out_len);
-    if (!out) {
-        fprintf(stderr, "Error allocating output buffer!\n");
-        exit(1);
-    }
-    err = "KEYOP_ERROR";
-    if (kdata->keyop
-        (kdata->ctx, out, &out_len, kdata->input, kdata->input_len) <= 0)
+                     kdata->input_len) <= 0
+            || !TEST_ptr(out = OPENSSL_malloc(out_len))) {
+        t->err = "KEYOP_LENGTH_ERROR";
         goto err;
-    err = "KEYOP_LENGTH_MISMATCH";
-    if (out_len != kdata->output_len)
+    }
+    if (kdata->keyop(kdata->ctx, out,
+                     &out_len, kdata->input, kdata->input_len) <= 0) {
+        t->err = "KEYOP_ERROR";
         goto err;
-    err = "KEYOP_MISMATCH";
-    if (check_output(t, kdata->output, out, out_len))
+    }
+    if (!TEST_mem_eq(kdata->output, kdata->output_len, out, out_len)) {
+        t->err = "KEYOP_MISMATCH";
         goto err;
-    err = NULL;
+    }
+    t->err = NULL;
  err:
     OPENSSL_free(out);
-    t->err = err;
     return 1;
 }
 
-static int sign_test_init(struct evp_test *t, const char *name)
+static int sign_test_init(EVP_TEST *t, const char *name)
 {
     return pkey_test_init(t, name, 0, EVP_PKEY_sign_init, EVP_PKEY_sign);
 }
 
-static const struct evp_test_method psign_test_method = {
+static const EVP_TEST_METHOD psign_test_method = {
     "Sign",
     sign_test_init,
     pkey_test_cleanup,
@@ -1521,13 +1447,13 @@ static const struct evp_test_method psign_test_method = {
     pkey_test_run
 };
 
-static int verify_recover_test_init(struct evp_test *t, const char *name)
+static int verify_recover_test_init(EVP_TEST *t, const char *name)
 {
     return pkey_test_init(t, name, 1, EVP_PKEY_verify_recover_init,
                           EVP_PKEY_verify_recover);
 }
 
-static const struct evp_test_method pverify_recover_test_method = {
+static const EVP_TEST_METHOD pverify_recover_test_method = {
     "VerifyRecover",
     verify_recover_test_init,
     pkey_test_cleanup,
@@ -1535,13 +1461,13 @@ static const struct evp_test_method pverify_recover_test_method = {
     pkey_test_run
 };
 
-static int decrypt_test_init(struct evp_test *t, const char *name)
+static int decrypt_test_init(EVP_TEST *t, const char *name)
 {
     return pkey_test_init(t, name, 0, EVP_PKEY_decrypt_init,
                           EVP_PKEY_decrypt);
 }
 
-static const struct evp_test_method pdecrypt_test_method = {
+static const EVP_TEST_METHOD pdecrypt_test_method = {
     "Decrypt",
     decrypt_test_init,
     pkey_test_cleanup,
@@ -1549,21 +1475,22 @@ static const struct evp_test_method pdecrypt_test_method = {
     pkey_test_run
 };
 
-static int verify_test_init(struct evp_test *t, const char *name)
+static int verify_test_init(EVP_TEST *t, const char *name)
 {
     return pkey_test_init(t, name, 1, EVP_PKEY_verify_init, 0);
 }
 
-static int verify_test_run(struct evp_test *t)
+static int verify_test_run(EVP_TEST *t)
 {
-    struct pkey_data *kdata = t->data;
+    PKEY_DATA *kdata = t->data;
+
     if (EVP_PKEY_verify(kdata->ctx, kdata->output, kdata->output_len,
                         kdata->input, kdata->input_len) <= 0)
         t->err = "VERIFY_ERROR";
     return 1;
 }
 
-static const struct evp_test_method pverify_test_method = {
+static const EVP_TEST_METHOD pverify_test_method = {
     "Verify",
     verify_test_init,
     pkey_test_cleanup,
@@ -1572,19 +1499,19 @@ static const struct evp_test_method pverify_test_method = {
 };
 
 
-static int pderive_test_init(struct evp_test *t, const char *name)
+static int pderive_test_init(EVP_TEST *t, const char *name)
 {
     return pkey_test_init(t, name, 0, EVP_PKEY_derive_init, 0);
 }
 
-static int pderive_test_parse(struct evp_test *t,
+static int pderive_test_parse(EVP_TEST *t,
                               const char *keyword, const char *value)
 {
-    struct pkey_data *kdata = t->data;
+    PKEY_DATA *kdata = t->data;
 
     if (strcmp(keyword, "PeerKey") == 0) {
         EVP_PKEY *peer;
-        if (find_key(&peer, value, t->public) == 0)
+        if (find_key(&peer, value, public_keys) == 0)
             return 0;
         if (EVP_PKEY_derive_set_peer(kdata->ctx, peer) <= 0)
             return 0;
@@ -1597,36 +1524,33 @@ static int pderive_test_parse(struct evp_test *t,
     return 0;
 }
 
-static int pderive_test_run(struct evp_test *t)
+static int pderive_test_run(EVP_TEST *t)
 {
-    struct pkey_data *kdata = t->data;
+    PKEY_DATA *kdata = t->data;
     unsigned char *out = NULL;
     size_t out_len;
-    const char *err = "INTERNAL_ERROR";
 
     out_len = kdata->output_len;
-    out = OPENSSL_malloc(out_len);
-    if (!out) {
-        fprintf(stderr, "Error allocating output buffer!\n");
-        exit(1);
-    }
-    err = "DERIVE_ERROR";
-    if (EVP_PKEY_derive(kdata->ctx, out, &out_len) <= 0)
+    if (!TEST_ptr(out = OPENSSL_malloc(out_len))) {
+        t->err = "DERIVE_ERROR";
         goto err;
-    err = "SHARED_SECRET_LENGTH_MISMATCH";
-    if (out_len != kdata->output_len)
+    }
+    if (EVP_PKEY_derive(kdata->ctx, out, &out_len) <= 0) {
+        t->err = "DERIVE_ERROR";
         goto err;
-    err = "SHARED_SECRET_MISMATCH";
-    if (check_output(t, kdata->output, out, out_len))
+    }
+    if (!TEST_mem_eq(kdata->output, kdata->output_len, out, out_len)) {
+        t->err = "SHARED_SECRET_MISMATCH";
         goto err;
-    err = NULL;
+    }
+
+    t->err = NULL;
  err:
     OPENSSL_free(out);
-    t->err = err;
     return 1;
 }
 
-static const struct evp_test_method pderive_test_method = {
+static const EVP_TEST_METHOD pderive_test_method = {
     "Derive",
     pderive_test_init,
     pkey_test_cleanup,
@@ -1640,35 +1564,29 @@ static const struct evp_test_method pderive_test_method = {
 #define PBE_TYPE_PBKDF2 2
 #define PBE_TYPE_PKCS12 3
 
-struct pbe_data {
-
+typedef struct pbe_data_st {
     int pbe_type;
-
-    /* scrypt parameters */
+        /* scrypt parameters */
     uint64_t N, r, p, maxmem;
-
-    /* PKCS#12 parameters */
+        /* PKCS#12 parameters */
     int id, iter;
     const EVP_MD *md;
-
-    /* password */
+        /* password */
     unsigned char *pass;
     size_t pass_len;
-
-    /* salt */
+        /* salt */
     unsigned char *salt;
     size_t salt_len;
-
-    /* Expected output */
+        /* Expected output */
     unsigned char *key;
     size_t key_len;
-};
+} PBE_DATA;
 
 #ifndef OPENSSL_NO_SCRYPT
-static int scrypt_test_parse(struct evp_test *t,
+static int scrypt_test_parse(EVP_TEST *t,
                              const char *keyword, const char *value)
 {
-    struct pbe_data *pdata = t->data;
+    PBE_DATA *pdata = t->data;
 
     if (strcmp(keyword, "N") == 0)
         return test_uint64(value, &pdata->N);
@@ -1682,10 +1600,10 @@ static int scrypt_test_parse(struct evp_test *t,
 }
 #endif
 
-static int pbkdf2_test_parse(struct evp_test *t,
+static int pbkdf2_test_parse(EVP_TEST *t,
                              const char *keyword, const char *value)
 {
-    struct pbe_data *pdata = t->data;
+    PBE_DATA *pdata = t->data;
 
     if (strcmp(keyword, "iter") == 0) {
         pdata->iter = atoi(value);
@@ -1702,10 +1620,10 @@ static int pbkdf2_test_parse(struct evp_test *t,
     return 0;
 }
 
-static int pkcs12_test_parse(struct evp_test *t,
+static int pkcs12_test_parse(EVP_TEST *t,
                              const char *keyword, const char *value)
 {
-    struct pbe_data *pdata = t->data;
+    PBE_DATA *pdata = t->data;
 
     if (strcmp(keyword, "id") == 0) {
         pdata->id = atoi(value);
@@ -1716,9 +1634,9 @@ static int pkcs12_test_parse(struct evp_test *t,
     return pbkdf2_test_parse(t, keyword, value);
 }
 
-static int pbe_test_init(struct evp_test *t, const char *alg)
+static int pbe_test_init(EVP_TEST *t, const char *alg)
 {
-    struct pbe_data *pdat;
+    PBE_DATA *pdat;
     int pbe_type = 0;
 
     if (strcmp(alg, "scrypt") == 0) {
@@ -1733,7 +1651,7 @@ static int pbe_test_init(struct evp_test *t, const char *alg)
     } else if (strcmp(alg, "pkcs12") == 0) {
         pbe_type = PBE_TYPE_PKCS12;
     } else {
-        fprintf(stderr, "Unknown pbe algorithm %s\n", alg);
+        TEST_error("Unknown pbe algorithm %s", alg);
     }
     pdat = OPENSSL_malloc(sizeof(*pdat));
     pdat->pbe_type = pbe_type;
@@ -1750,18 +1668,19 @@ static int pbe_test_init(struct evp_test *t, const char *alg)
     return 1;
 }
 
-static void pbe_test_cleanup(struct evp_test *t)
+static void pbe_test_cleanup(EVP_TEST *t)
 {
-    struct pbe_data *pdat = t->data;
-    test_free(pdat->pass);
-    test_free(pdat->salt);
-    test_free(pdat->key);
+    PBE_DATA *pdat = t->data;
+
+    OPENSSL_free(pdat->pass);
+    OPENSSL_free(pdat->salt);
+    OPENSSL_free(pdat->key);
 }
 
-static int pbe_test_parse(struct evp_test *t,
-                             const char *keyword, const char *value)
+static int pbe_test_parse(EVP_TEST *t,
+                          const char *keyword, const char *value)
 {
-    struct pbe_data *pdata = t->data;
+    PBE_DATA *pdata = t->data;
 
     if (strcmp(keyword, "Password") == 0)
         return test_bin(value, &pdata->pass, &pdata->pass_len);
@@ -1780,50 +1699,53 @@ static int pbe_test_parse(struct evp_test *t,
     return 0;
 }
 
-static int pbe_test_run(struct evp_test *t)
+static int pbe_test_run(EVP_TEST *t)
 {
-    struct pbe_data *pdata = t->data;
-    const char *err = "INTERNAL_ERROR";
+    PBE_DATA *pdata = t->data;
     unsigned char *key;
 
-    key = OPENSSL_malloc(pdata->key_len);
-    if (!key)
+    if (!TEST_ptr(key = OPENSSL_malloc(pdata->key_len))) {
+        t->err = "INTERNAL_ERROR";
         goto err;
+    }
     if (pdata->pbe_type == PBE_TYPE_PBKDF2) {
-        err = "PBKDF2_ERROR";
         if (PKCS5_PBKDF2_HMAC((char *)pdata->pass, pdata->pass_len,
                               pdata->salt, pdata->salt_len,
                               pdata->iter, pdata->md,
-                              pdata->key_len, key) == 0)
+                              pdata->key_len, key) == 0) {
+            t->err = "PBKDF2_ERROR";
             goto err;
+        }
 #ifndef OPENSSL_NO_SCRYPT
     } else if (pdata->pbe_type == PBE_TYPE_SCRYPT) {
-        err = "SCRYPT_ERROR";
         if (EVP_PBE_scrypt((const char *)pdata->pass, pdata->pass_len,
                            pdata->salt, pdata->salt_len,
                            pdata->N, pdata->r, pdata->p, pdata->maxmem,
-                           key, pdata->key_len) == 0)
+                           key, pdata->key_len) == 0) {
+            t->err = "SCRYPT_ERROR";
             goto err;
+        }
 #endif
     } else if (pdata->pbe_type == PBE_TYPE_PKCS12) {
-        err = "PKCS12_ERROR";
         if (PKCS12_key_gen_uni(pdata->pass, pdata->pass_len,
                                pdata->salt, pdata->salt_len,
                                pdata->id, pdata->iter, pdata->key_len,
-                               key, pdata->md) == 0)
+                               key, pdata->md) == 0) {
+            t->err = "PKCS12_ERROR";
             goto err;
+        }
     }
-    err = "KEY_MISMATCH";
-    if (check_output(t, pdata->key, key, pdata->key_len))
+    if (!TEST_mem_eq(pdata->key, pdata->key_len, key, pdata->key_len)) {
+        t->err = "KEY_MISMATCH";
         goto err;
-    err = NULL;
-    err:
+    }
+    t->err = NULL;
+err:
     OPENSSL_free(key);
-    t->err = err;
     return 1;
 }
 
-static const struct evp_test_method pbe_test_method = {
+static const EVP_TEST_METHOD pbe_test_method = {
     "PBE",
     pbe_test_init,
     pbe_test_cleanup,
@@ -1839,7 +1761,7 @@ typedef enum {
     BASE64_INVALID_ENCODING = 2
 } base64_encoding_type;
 
-struct encode_data {
+typedef struct encode_data_st {
     /* Input to encoding */
     unsigned char *input;
     size_t input_len;
@@ -1847,11 +1769,11 @@ struct encode_data {
     unsigned char *output;
     size_t output_len;
     base64_encoding_type encoding;
-};
+} ENCODE_DATA;
 
-static int encode_test_init(struct evp_test *t, const char *encoding)
+static int encode_test_init(EVP_TEST *t, const char *encoding)
 {
-    struct encode_data *edata = OPENSSL_zalloc(sizeof(*edata));
+    ENCODE_DATA *edata = OPENSSL_zalloc(sizeof(*edata));
 
     if (strcmp(encoding, "canonical") == 0) {
         edata->encoding = BASE64_CANONICAL_ENCODING;
@@ -1863,26 +1785,27 @@ static int encode_test_init(struct evp_test *t, const char *encoding)
         if (t->expected_err == NULL)
             return 0;
     } else {
-        fprintf(stderr, "Bad encoding: %s. Should be one of "
-                "{canonical, valid, invalid}\n", encoding);
+        TEST_info("Bad encoding: %s. Should be one of "
+                  "{canonical, valid, invalid}", encoding);
         return 0;
     }
     t->data = edata;
     return 1;
 }
 
-static void encode_test_cleanup(struct evp_test *t)
+static void encode_test_cleanup(EVP_TEST *t)
 {
-    struct encode_data *edata = t->data;
-    test_free(edata->input);
-    test_free(edata->output);
+    ENCODE_DATA *edata = t->data;
+
+    OPENSSL_free(edata->input);
+    OPENSSL_free(edata->output);
     memset(edata, 0, sizeof(*edata));
 }
 
-static int encode_test_parse(struct evp_test *t,
+static int encode_test_parse(EVP_TEST *t,
                              const char *keyword, const char *value)
 {
-    struct encode_data *edata = t->data;
+    ENCODE_DATA *edata = t->data;
     if (strcmp(keyword, "Input") == 0)
         return test_bin(value, &edata->input, &edata->input_len);
     if (strcmp(keyword, "Output") == 0)
@@ -1890,23 +1813,24 @@ static int encode_test_parse(struct evp_test *t,
     return 0;
 }
 
-static int encode_test_run(struct evp_test *t)
+static int encode_test_run(EVP_TEST *t)
 {
-    struct encode_data *edata = t->data;
+    ENCODE_DATA *edata = t->data;
     unsigned char *encode_out = NULL, *decode_out = NULL;
     int output_len, chunk_len;
-    const char *err = "INTERNAL_ERROR";
-    EVP_ENCODE_CTX *decode_ctx = EVP_ENCODE_CTX_new();
+    EVP_ENCODE_CTX *decode_ctx;
 
-    if (decode_ctx == NULL)
+    if (!TEST_ptr(decode_ctx = EVP_ENCODE_CTX_new())) {
+        t->err = "INTERNAL_ERROR";
         goto err;
+    }
 
     if (edata->encoding == BASE64_CANONICAL_ENCODING) {
-        EVP_ENCODE_CTX *encode_ctx = EVP_ENCODE_CTX_new();
-        if (encode_ctx == NULL)
-            goto err;
-        encode_out = OPENSSL_malloc(EVP_ENCODE_LENGTH(edata->input_len));
-        if (encode_out == NULL)
+        EVP_ENCODE_CTX *encode_ctx;
+
+        if (!TEST_ptr(encode_ctx = EVP_ENCODE_CTX_new())
+                || !TEST_ptr(encode_out =
+                        OPENSSL_malloc(EVP_ENCODE_LENGTH(edata->input_len))))
             goto err;
 
         EVP_EncodeInit(encode_ctx);
@@ -1919,48 +1843,47 @@ static int encode_test_run(struct evp_test *t)
 
         EVP_ENCODE_CTX_free(encode_ctx);
 
-        if (check_var_length_output(t, edata->output, edata->output_len,
-                                    encode_out, output_len)) {
-            err = "BAD_ENCODING";
+        if (!TEST_mem_eq(edata->output, edata->output_len,
+                         encode_out, output_len)) {
+            t->err = "BAD_ENCODING";
             goto err;
         }
     }
 
-    decode_out = OPENSSL_malloc(EVP_DECODE_LENGTH(edata->output_len));
-    if (decode_out == NULL)
+    if (!TEST_ptr(decode_out =
+                OPENSSL_malloc(EVP_DECODE_LENGTH(edata->output_len))))
         goto err;
 
     EVP_DecodeInit(decode_ctx);
     if (EVP_DecodeUpdate(decode_ctx, decode_out, &chunk_len, edata->output,
                          edata->output_len) < 0) {
-        err = "DECODE_ERROR";
+        t->err = "DECODE_ERROR";
         goto err;
     }
     output_len = chunk_len;
 
     if (EVP_DecodeFinal(decode_ctx, decode_out + chunk_len, &chunk_len) != 1) {
-        err = "DECODE_ERROR";
+        t->err = "DECODE_ERROR";
         goto err;
     }
     output_len += chunk_len;
 
-    if (edata->encoding != BASE64_INVALID_ENCODING &&
-        check_var_length_output(t, edata->input, edata->input_len,
-                                decode_out, output_len)) {
-        err = "BAD_DECODING";
+    if (edata->encoding != BASE64_INVALID_ENCODING
+            && !TEST_mem_eq(edata->input, edata->input_len,
+                            decode_out, output_len)) {
+        t->err = "BAD_DECODING";
         goto err;
     }
 
-    err = NULL;
+    t->err = NULL;
  err:
-    t->err = err;
     OPENSSL_free(encode_out);
     OPENSSL_free(decode_out);
     EVP_ENCODE_CTX_free(decode_ctx);
     return 1;
 }
 
-static const struct evp_test_method encode_test_method = {
+static const EVP_TEST_METHOD encode_test_method = {
     "Encoding",
     encode_test_init,
     encode_test_cleanup,
@@ -1970,21 +1893,21 @@ static const struct evp_test_method encode_test_method = {
 
 /* KDF operations */
 
-struct kdf_data {
+typedef struct kdf_data_st {
     /* Context for this operation */
     EVP_PKEY_CTX *ctx;
     /* Expected output */
     unsigned char *output;
     size_t output_len;
-};
+} KDF_DATA;
 
 /*
  * Perform public key operation setup: lookup key, allocated ctx and call
  * the appropriate initialisation function
  */
-static int kdf_test_init(struct evp_test *t, const char *name)
+static int kdf_test_init(EVP_TEST *t, const char *name)
 {
-    struct kdf_data *kdata;
+    KDF_DATA *kdata;
 
     kdata = OPENSSL_malloc(sizeof(*kdata));
     if (kdata == NULL)
@@ -2000,17 +1923,18 @@ static int kdf_test_init(struct evp_test *t, const char *name)
     return 1;
 }
 
-static void kdf_test_cleanup(struct evp_test *t)
+static void kdf_test_cleanup(EVP_TEST *t)
 {
-    struct kdf_data *kdata = t->data;
+    KDF_DATA *kdata = t->data;
     OPENSSL_free(kdata->output);
     EVP_PKEY_CTX_free(kdata->ctx);
 }
 
-static int kdf_test_parse(struct evp_test *t,
+static int kdf_test_parse(EVP_TEST *t,
                           const char *keyword, const char *value)
 {
-    struct kdf_data *kdata = t->data;
+    KDF_DATA *kdata = t->data;
+
     if (strcmp(keyword, "Output") == 0)
         return test_bin(value, &kdata->output, &kdata->output_len);
     if (strncmp(keyword, "Ctrl", 4) == 0)
@@ -2018,34 +1942,32 @@ static int kdf_test_parse(struct evp_test *t,
     return 0;
 }
 
-static int kdf_test_run(struct evp_test *t)
+static int kdf_test_run(EVP_TEST *t)
 {
-    struct kdf_data *kdata = t->data;
+    KDF_DATA *kdata = t->data;
     unsigned char *out = NULL;
     size_t out_len = kdata->output_len;
-    const char *err = "INTERNAL_ERROR";
-    out = OPENSSL_malloc(out_len);
-    if (!out) {
-        fprintf(stderr, "Error allocating output buffer!\n");
-        exit(1);
-    }
-    err = "KDF_DERIVE_ERROR";
-    if (EVP_PKEY_derive(kdata->ctx, out, &out_len) <= 0)
+
+    if (!TEST_ptr(out = OPENSSL_malloc(out_len))) {
+        t->err = "INTERNAL_ERROR";
         goto err;
-    err = "KDF_LENGTH_MISMATCH";
-    if (out_len != kdata->output_len)
+    }
+    if (EVP_PKEY_derive(kdata->ctx, out, &out_len) <= 0) {
+        t->err = "KDF_DERIVE_ERROR";
         goto err;
-    err = "KDF_MISMATCH";
-    if (check_output(t, kdata->output, out, out_len))
+    }
+    if (!TEST_mem_eq(kdata->output, kdata->output_len, out, out_len)) {
+        t->err = "KDF_MISMATCH";
         goto err;
-    err = NULL;
+    }
+    t->err = NULL;
+
  err:
     OPENSSL_free(out);
-    t->err = err;
     return 1;
 }
 
-static const struct evp_test_method kdf_test_method = {
+static const EVP_TEST_METHOD kdf_test_method = {
     "KDF",
     kdf_test_init,
     kdf_test_cleanup,
@@ -2053,37 +1975,33 @@ static const struct evp_test_method kdf_test_method = {
     kdf_test_run
 };
 
-struct keypair_test_data {
+typedef struct keypair_test_data_st {
     EVP_PKEY *privk;
     EVP_PKEY *pubk;
-};
+} KEYPAIR_TEST_DATA;
 
-static int keypair_test_init(struct evp_test *t, const char *pair)
+static int keypair_test_init(EVP_TEST *t, const char *pair)
 {
     int rv = 0;
     EVP_PKEY *pk = NULL, *pubk = NULL;
     char *pub, *priv = NULL;
-    const char *err = "INTERNAL_ERROR";
-    struct keypair_test_data *data;
+    KEYPAIR_TEST_DATA *data;
 
-    priv = OPENSSL_strdup(pair);
-    if (priv == NULL)
-        return 0;
-    pub = strchr(priv, ':');
-    if ( pub == NULL ) {
-        fprintf(stderr, "Wrong syntax \"%s\"\n", pair);
+    if (!TEST_ptr(priv = OPENSSL_strdup(pair))
+            || !TEST_ptr(pub = strchr(priv, ':'))) {
+        t->err = "PARSING_ERROR";
         goto end;
     }
     *pub++ = 0; /* split priv and pub strings */
 
-    if (find_key(&pk, priv, t->private) == 0) {
-        fprintf(stderr, "Cannot find private key: %s\n", priv);
-        err = "MISSING_PRIVATE_KEY";
+    if (!TEST_true(find_key(&pk, priv, private_keys))) {
+        TEST_info("Cannot find private key: %s", priv);
+        t->err = "MISSING_PRIVATE_KEY";
         goto end;
     }
-    if (find_key(&pubk, pub, t->public) == 0) {
-        fprintf(stderr, "Cannot find public key: %s\n", pub);
-        err = "MISSING_PUBLIC_KEY";
+    if (!TEST_true(find_key(&pubk, pub, public_keys))) {
+        TEST_info("Cannot find public key: %s", pub);
+        t->err = "MISSING_PUBLIC_KEY";
         goto end;
     }
 
@@ -2094,69 +2012,59 @@ static int keypair_test_init(struct evp_test *t, const char *pair)
         goto end;
     }
 
-    data = OPENSSL_malloc(sizeof(*data));
-    if (data == NULL )
+    if (!TEST_ptr(data = OPENSSL_malloc(sizeof(*data))))
         goto end;
 
     data->privk = pk;
     data->pubk = pubk;
     t->data = data;
-
     rv = 1;
-    err = NULL;
+    t->err = NULL;
 
 end:
-    if (priv)
-        OPENSSL_free(priv);
-    t->err = err;
+    OPENSSL_free(priv);
     return rv;
 }
 
-static void keypair_test_cleanup(struct evp_test *t)
+static void keypair_test_cleanup(EVP_TEST *t)
 {
-    struct keypair_test_data *data = t->data;
+    OPENSSL_free(t->data);
     t->data = NULL;
-    if (data)
-        test_free(data);
-    return;
 }
 
 /* For test that do not accept any custom keyword:
  *      return 0 if called
  */
-static int void_test_parse(struct evp_test *t, const char *keyword, const char *value)
+static int void_test_parse(EVP_TEST *t, const char *keyword, const char *value)
 {
     return 0;
 }
 
-static int keypair_test_run(struct evp_test *t)
+static int keypair_test_run(EVP_TEST *t)
 {
     int rv = 0;
-    const struct keypair_test_data *pair = t->data;
-    const char *err = "INTERNAL_ERROR";
-
-    if (pair == NULL)
-        goto end;
+    const KEYPAIR_TEST_DATA *pair = t->data;
 
     if (pair->privk == NULL || pair->pubk == NULL) {
-        /* this can only happen if only one of the keys is not set
+        /*
+         * this can only happen if only one of the keys is not set
          * which means that one of them was unsupported while the
          * other isn't: hence a key type mismatch.
          */
-        err = "KEYPAIR_TYPE_MISMATCH";
+        t->err = "KEYPAIR_TYPE_MISMATCH";
         rv = 1;
         goto end;
     }
 
     if ((rv = EVP_PKEY_cmp(pair->privk, pair->pubk)) != 1 ) {
         if ( 0 == rv ) {
-            err = "KEYPAIR_MISMATCH";
+            t->err = "KEYPAIR_MISMATCH";
         } else if ( -1 == rv ) {
-            err = "KEYPAIR_TYPE_MISMATCH";
+            t->err = "KEYPAIR_TYPE_MISMATCH";
         } else if ( -2 == rv ) {
-            err = "UNSUPPORTED_KEY_COMPARISON";
+            t->err = "UNSUPPORTED_KEY_COMPARISON";
         } else {
-            fprintf(stderr, "Unexpected error in key comparison\n");
+            TEST_error("Unexpected error in key comparison");
             rv = 0;
             goto end;
         }
@@ -2165,14 +2073,13 @@ static int keypair_test_run(struct evp_test *t)
     }
 
     rv = 1;
-    err = NULL;
+    t->err = NULL;
 
 end:
-    t->err = err;
     return rv;
 }
 
-static const struct evp_test_method keypair_test_method = {
+static const EVP_TEST_METHOD keypair_test_method = {
     "PrivPubKeyPair",
     keypair_test_init,
     keypair_test_cleanup,
@@ -2180,3 +2087,52 @@ static const struct evp_test_method keypair_test_method = {
     keypair_test_run
 };
 
+static int do_test_file(const char *testfile)
+{
+    BIO *in;
+    char buf[10240];
+    EVP_TEST t;
+
+    if (!TEST_ptr(in = BIO_new_file(testfile, "rb")))
+        return 0;
+    memset(&t, 0, sizeof(t));
+    t.start_line = -1;
+    t.in = in;
+    t.err = NULL;
+    while (BIO_gets(in, buf, sizeof(buf))) {
+        t.line++;
+        if (!TEST_true(parse_test_line(&t, buf)))
+            return 0;
+    }
+    /* Run any final test we have */
+    if (!run_and_get_next(&t, NULL))
+        return 0;
+
+    TEST_info("Completed %d tests with %d errors and %d skipped",
+              t.ntests, t.errors, t.nskip);
+    free_key_list(public_keys);
+    free_key_list(private_keys);
+    BIO_free(t.key);
+    BIO_free(in);
+    return t.errors == 0;
+}
+
+static char * const *testfiles;
+
+static int run_file_tests(int i)
+{
+    return do_test_file(testfiles[i]);
+}
+
+int test_main(int argc, char *argv[])
+{
+    if (argc < 2) {
+        TEST_error("Usage: %s file...", argv[0]);
+        return 0;
+    }
+    testfiles = &argv[1];
+
+    ADD_ALL_TESTS(run_file_tests, argc - 1);
+
+    return run_tests(argv[0]);
+}