Convert of evp_test to framework

Also, allow multiple files on commandline (for future splitup of
evptests.txt)

Reviewed-by: Richard Levitte <levitte@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/3324)

1 files changed, 551 insertions, 595 deletions

diff --git a/test/evp_test.c b/test/evp_test.c
index e7396f7b2a..0d5de4d5b3 100644
--- a/test/evp_test.c
+++ b/test/evp_test.c
@@ -18,9 +18,11 @@
 #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;