Convert more tests

recordlentest, srptest, ecdsatest, enginetest, pbelutest

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

6 files changed, 317 insertions, 462 deletions

diff --git a/test/build.info b/test/build.info
index 537b361f5d..8346385412 100644
--- a/test/build.info
+++ b/test/build.info
@@ -55,7 +55,7 @@ IF[{- !$disabled{tests} -}]
   INCLUDE[ectest]=.. ../include
   DEPEND[ectest]=../libcrypto
 
-  SOURCE[ecdsatest]=ecdsatest.c
+  SOURCE[ecdsatest]=ecdsatest.c testutil.c test_main.c
   INCLUDE[ecdsatest]=../include
   DEPEND[ecdsatest]=../libcrypto
 
@@ -63,7 +63,7 @@ IF[{- !$disabled{tests} -}]
   INCLUDE[gmdifftest]=../include
   DEPEND[gmdifftest]=../libcrypto
 
-  SOURCE[pbelutest]=pbelutest.c
+  SOURCE[pbelutest]=pbelutest.c testutil.c test_main.c
   INCLUDE[pbelutest]=../include
   DEPEND[pbelutest]=../libcrypto
 
@@ -119,11 +119,11 @@ IF[{- !$disabled{tests} -}]
   INCLUDE[dhtest]=../include
   DEPEND[dhtest]=../libcrypto
 
-  SOURCE[enginetest]=enginetest.c
+  SOURCE[enginetest]=enginetest.c testutil.c test_main.c
   INCLUDE[enginetest]=../include
   DEPEND[enginetest]=../libcrypto
 
-  SOURCE[casttest]=casttest.c testutil.c test_main.o
+  SOURCE[casttest]=casttest.c testutil.c test_main.c
   INCLUDE[casttest]=.. ../include
   DEPEND[casttest]=../libcrypto
 
@@ -203,7 +203,7 @@ IF[{- !$disabled{tests} -}]
   INCLUDE[secmemtest]=../include
   DEPEND[secmemtest]=../libcrypto
 
-  SOURCE[srptest]=srptest.c
+  SOURCE[srptest]=srptest.c testutil.c test_main.c
   INCLUDE[srptest]=../include
   DEPEND[srptest]=../libcrypto
 
diff --git a/test/ecdsatest.c b/test/ecdsatest.c
index ce73778791..8b1e566ae8 100644
--- a/test/ecdsatest.c
+++ b/test/ecdsatest.c
@@ -45,48 +45,39 @@ int main(int argc, char *argv[])
 # endif
 # include <openssl/err.h>
 # include <openssl/rand.h>
+# include "testutil.h"
+# include "test_main.h"
 
 static const char rnd_seed[] = "string to make the random number generator "
     "think it has entropy";
 
-/* declaration of the test functions */
-int x9_62_tests(BIO *);
-int x9_62_test_internal(BIO *out, int nid, const char *r, const char *s);
-int test_builtin(BIO *);
 
 /* functions to change the RAND_METHOD */
-int change_rand(void);
-int restore_rand(void);
-int fbytes(unsigned char *buf, int num);
+static int fbytes(unsigned char *buf, int num);
 
 static RAND_METHOD fake_rand;
 static const RAND_METHOD *old_rand;
 
-int change_rand(void)
+static int change_rand(void)
 {
     /* save old rand method */
-    if ((old_rand = RAND_get_rand_method()) == NULL)
+    if (!TEST_ptr(old_rand = RAND_get_rand_method()))
         return 0;
 
-    fake_rand.seed = old_rand->seed;
-    fake_rand.cleanup = old_rand->cleanup;
-    fake_rand.add = old_rand->add;
-    fake_rand.status = old_rand->status;
+    fake_rand = *old_rand;
     /* use own random function */
     fake_rand.bytes = fbytes;
-    fake_rand.pseudorand = old_rand->bytes;
     /* set new RAND_METHOD */
-    if (!RAND_set_rand_method(&fake_rand))
+    if (!TEST_true(RAND_set_rand_method(&fake_rand)))
         return 0;
     return 1;
 }
 
-int restore_rand(void)
+static int restore_rand(void)
 {
-    if (!RAND_set_rand_method(old_rand))
+    if (!TEST_true(RAND_set_rand_method(old_rand)))
         return 0;
-    else
-        return 1;
+    return 1;
 }
 
 static int fbytes_counter = 0, use_fake = 0;
@@ -105,9 +96,9 @@ static const char *numbers[8] = {
         "40041670216363"
 };
 
-int fbytes(unsigned char *buf, int num)
+static int fbytes(unsigned char *buf, int num)
 {
-    int ret;
+    int ret = 0;
     BIGNUM *tmp = NULL;
 
     if (use_fake == 0)
@@ -117,85 +108,77 @@ int fbytes(unsigned char *buf, int num)
 
     if (fbytes_counter >= 8)
         return 0;
-    tmp = BN_new();
-    if (!tmp)
+    if (!TEST_ptr(tmp = BN_new()))
         return 0;
-    if (!BN_dec2bn(&tmp, numbers[fbytes_counter])) {
+    if (!TEST_true(BN_dec2bn(&tmp, numbers[fbytes_counter]))) {
         BN_free(tmp);
         return 0;
     }
     fbytes_counter++;
-    if (num != BN_num_bytes(tmp) || !BN_bn2bin(tmp, buf))
-        ret = 0;
-    else
+    if (TEST_int_eq(BN_num_bytes(tmp), num)
+            && TEST_true(BN_bn2bin(tmp, buf)))
         ret = 1;
     BN_free(tmp);
     return ret;
 }
 
 /* some tests from the X9.62 draft */
-int x9_62_test_internal(BIO *out, int nid, const char *r_in, const char *s_in)
+static int x9_62_test_internal(int nid, const char *r_in, const char *s_in)
 {
     int ret = 0;
     const char message[] = "abc";
     unsigned char digest[20];
     unsigned int dgst_len = 0;
-    EVP_MD_CTX *md_ctx = EVP_MD_CTX_new();
+    EVP_MD_CTX *md_ctx;
     EC_KEY *key = NULL;
     ECDSA_SIG *signature = NULL;
     BIGNUM *r = NULL, *s = NULL;
     BIGNUM *kinv = NULL, *rp = NULL;
     const BIGNUM *sig_r, *sig_s;
 
-    if (md_ctx == NULL)
+    if (!TEST_ptr(md_ctx = EVP_MD_CTX_new()))
         goto x962_int_err;
 
     /* get the message digest */
-    if (!EVP_DigestInit(md_ctx, EVP_sha1())
-        || !EVP_DigestUpdate(md_ctx, (const void *)message, 3)
-        || !EVP_DigestFinal(md_ctx, digest, &dgst_len))
+    if (!TEST_true(EVP_DigestInit(md_ctx, EVP_sha1()))
+        || !TEST_true(EVP_DigestUpdate(md_ctx, (const void *)message, 3))
+        || !TEST_true(EVP_DigestFinal(md_ctx, digest, &dgst_len)))
         goto x962_int_err;
 
-    BIO_printf(out, "testing %s: ", OBJ_nid2sn(nid));
+    TEST_info("testing %s", OBJ_nid2sn(nid));
+
     /* create the key */
-    if ((key = EC_KEY_new_by_curve_name(nid)) == NULL)
+    if (!TEST_ptr(key = EC_KEY_new_by_curve_name(nid)))
         goto x962_int_err;
     use_fake = 1;
-    if (!EC_KEY_generate_key(key))
+    if (!TEST_true(EC_KEY_generate_key(key)))
         goto x962_int_err;
-    BIO_printf(out, ".");
-    (void)BIO_flush(out);
+
     /* create the signature */
     use_fake = 1;
     /* Use ECDSA_sign_setup to avoid use of ECDSA nonces */
-    if (!ECDSA_sign_setup(key, NULL, &kinv, &rp))
+    if (!TEST_true(ECDSA_sign_setup(key, NULL, &kinv, &rp)))
         goto x962_int_err;
-    signature = ECDSA_do_sign_ex(digest, 20, kinv, rp, key);
-    if (signature == NULL)
+    if (!TEST_ptr(signature = ECDSA_do_sign_ex(digest, 20, kinv, rp, key)))
         goto x962_int_err;
-    BIO_printf(out, ".");
-    (void)BIO_flush(out);
+
     /* compare the created signature with the expected signature */
-    if ((r = BN_new()) == NULL || (s = BN_new()) == NULL)
+    if (!TEST_ptr(r = BN_new()) || !TEST_ptr(s = BN_new()))
         goto x962_int_err;
-    if (!BN_dec2bn(&r, r_in) || !BN_dec2bn(&s, s_in))
+    if (!TEST_true(BN_dec2bn(&r, r_in)) || !TEST_true(BN_dec2bn(&s, s_in)))
         goto x962_int_err;
     ECDSA_SIG_get0(signature, &sig_r, &sig_s);
-    if (BN_cmp(sig_r, r) || BN_cmp(sig_s, s))
+    if (!TEST_int_eq(BN_cmp(sig_r, r), 0)
+            || !TEST_int_eq(BN_cmp(sig_s, s), 0))
         goto x962_int_err;
-    BIO_printf(out, ".");
-    (void)BIO_flush(out);
+
     /* verify the signature */
-    if (ECDSA_do_verify(digest, 20, signature, key) != 1)
+    if (!TEST_int_eq(ECDSA_do_verify(digest, 20, signature, key), 1))
         goto x962_int_err;
-    BIO_printf(out, ".");
-    (void)BIO_flush(out);
 
-    BIO_printf(out, " ok\n");
     ret = 1;
+
  x962_int_err:
-    if (!ret)
-        BIO_printf(out, " failed\n");
     EC_KEY_free(key);
     ECDSA_SIG_free(signature);
     BN_free(r);
@@ -206,46 +189,46 @@ int x9_62_test_internal(BIO *out, int nid, const char *r_in, const char *s_in)
     return ret;
 }
 
-int x9_62_tests(BIO *out)
+static int x9_62_tests()
 {
     int ret = 0;
 
-    BIO_printf(out, "some tests from X9.62:\n");
-
     /* set own rand method */
     if (!change_rand())
         goto x962_err;
 
-    if (!x9_62_test_internal(out, NID_X9_62_prime192v1,
-                             "3342403536405981729393488334694600415596881826869351677613",
-                             "5735822328888155254683894997897571951568553642892029982342"))
+    if (!TEST_true(x9_62_test_internal(NID_X9_62_prime192v1,
+                 "3342403536405981729393488334694600415596881826869351677613",
+                 "5735822328888155254683894997897571951568553642892029982342")))
         goto x962_err;
-    if (!x9_62_test_internal(out, NID_X9_62_prime239v1,
-                             "3086361431751678114926225473006680188549593787585317781474"
+    if (!TEST_true(x9_62_test_internal(NID_X9_62_prime239v1,
+                 "3086361431751678114926225473006680188549593787585317781474"
                              "62058306432176",
-                             "3238135532097973577080787768312505059318910517550078427819"
-                             "78505179448783"))
+                 "3238135532097973577080787768312505059318910517550078427819"
+                             "78505179448783")))
         goto x962_err;
+
 # ifndef OPENSSL_NO_EC2M
-    if (!x9_62_test_internal(out, NID_X9_62_c2tnb191v1,
-                             "87194383164871543355722284926904419997237591535066528048",
-                             "308992691965804947361541664549085895292153777025772063598"))
+    if (!TEST_true(x9_62_test_internal(NID_X9_62_c2tnb191v1,
+                 "87194383164871543355722284926904419997237591535066528048",
+                 "308992691965804947361541664549085895292153777025772063598")))
         goto x962_err;
-    if (!x9_62_test_internal(out, NID_X9_62_c2tnb239v1,
-                             "2159633321041961198501834003903461262881815148684178964245"
+    if (!TEST_true(x9_62_test_internal(NID_X9_62_c2tnb239v1,
+                 "2159633321041961198501834003903461262881815148684178964245"
                              "5876922391552",
-                             "1970303740007316867383349976549972270528498040721988191026"
-                             "49413465737174"))
+                 "1970303740007316867383349976549972270528498040721988191026"
+                             "49413465737174")))
         goto x962_err;
 # endif
     ret = 1;
+
  x962_err:
-    if (!restore_rand())
+    if (!TEST_true(restore_rand()))
         ret = 0;
     return ret;
 }
 
-int test_builtin(BIO *out)
+static int test_builtin(void)
 {
     EC_builtin_curve *curves = NULL;
     size_t crv_len = 0, n = 0;
@@ -264,29 +247,16 @@ int test_builtin(BIO *out)
     int nid, ret = 0;
 
     /* fill digest values with some random data */
-    if (RAND_bytes(digest, 20) <= 0 || RAND_bytes(wrong_digest, 20) <= 0) {
-        BIO_printf(out, "ERROR: unable to get random data\n");
+    if (!TEST_true(RAND_bytes(digest, 20))
+            || !TEST_true(RAND_bytes(wrong_digest, 20)))
         goto builtin_err;
-    }
-
-    /*
-     * create and verify a ecdsa signature with every available curve (with )
-     */
-    BIO_printf(out, "\ntesting ECDSA_sign() and ECDSA_verify() "
-               "with some internal curves:\n");
 
+    /* create and verify a ecdsa signature with every available curve */
     /* get a list of all internal curves */
     crv_len = EC_get_builtin_curves(NULL, 0);
-    curves = OPENSSL_malloc(sizeof(*curves) * crv_len);
-    if (curves == NULL) {
-        BIO_printf(out, "malloc error\n");
+    if (!TEST_ptr(curves = OPENSSL_malloc(sizeof(*curves) * crv_len))
+            || !TEST_true(EC_get_builtin_curves(curves, crv_len)))
         goto builtin_err;
-    }
-
-    if (!EC_get_builtin_curves(curves, crv_len)) {
-        BIO_printf(out, "unable to get internal curves\n");
-        goto builtin_err;
-    }
 
     /* now create and verify a signature for every curve */
     for (n = 0; n < crv_len; n++) {
@@ -296,12 +266,9 @@ int test_builtin(BIO *out)
         if (nid == NID_ipsec4 || nid == NID_X25519)
             continue;
         /* create new ecdsa key (== EC_KEY) */
-        if ((eckey = EC_KEY_new()) == NULL)
-            goto builtin_err;
-        group = EC_GROUP_new_by_curve_name(nid);
-        if (group == NULL)
-            goto builtin_err;
-        if (EC_KEY_set_group(eckey, group) == 0)
+        if (!TEST_ptr(eckey = EC_KEY_new())
+                || !TEST_ptr(group = EC_GROUP_new_by_curve_name(nid))
+                || !TEST_true(EC_KEY_set_group(eckey, group)))
             goto builtin_err;
         EC_GROUP_free(group);
         degree = EC_GROUP_get_degree(EC_KEY_get0_group(eckey));
@@ -311,73 +278,50 @@ int test_builtin(BIO *out)
             eckey = NULL;
             continue;
         }
-        BIO_printf(out, "%s: ", OBJ_nid2sn(nid));
+        TEST_info("testing %s", OBJ_nid2sn(nid));
+
         /* create key */
-        if (!EC_KEY_generate_key(eckey)) {
-            BIO_printf(out, " failed\n");
+        if (!TEST_true(EC_KEY_generate_key(eckey)))
             goto builtin_err;
-        }
         /* create second key */
-        if ((wrong_eckey = EC_KEY_new()) == NULL)
-            goto builtin_err;
-        group = EC_GROUP_new_by_curve_name(nid);
-        if (group == NULL)
-            goto builtin_err;
-        if (EC_KEY_set_group(wrong_eckey, group) == 0)
+        if (!TEST_ptr(wrong_eckey = EC_KEY_new())
+                || !TEST_ptr(group = EC_GROUP_new_by_curve_name(nid))
+                || !TEST_true(EC_KEY_set_group(wrong_eckey, group)))
             goto builtin_err;
         EC_GROUP_free(group);
-        if (!EC_KEY_generate_key(wrong_eckey)) {
-            BIO_printf(out, " failed\n");
+        if (!TEST_true(EC_KEY_generate_key(wrong_eckey)))
             goto builtin_err;
-        }
 
-        BIO_printf(out, ".");
-        (void)BIO_flush(out);
         /* check key */
-        if (!EC_KEY_check_key(eckey)) {
-            BIO_printf(out, " failed\n");
+        if (!TEST_true(EC_KEY_check_key(eckey)))
             goto builtin_err;
-        }
-        BIO_printf(out, ".");
-        (void)BIO_flush(out);
+
         /* create signature */
         sig_len = ECDSA_size(eckey);
-        if ((signature = OPENSSL_malloc(sig_len)) == NULL)
+        if (!TEST_ptr(signature = OPENSSL_malloc(sig_len))
+                || !TEST_true(ECDSA_sign(0, digest, 20, signature, &sig_len,
+                                         eckey)))
             goto builtin_err;
-        if (!ECDSA_sign(0, digest, 20, signature, &sig_len, eckey)) {
-            BIO_printf(out, " failed\n");
-            goto builtin_err;
-        }
-        BIO_printf(out, ".");
-        (void)BIO_flush(out);
+
         /* verify signature */
-        if (ECDSA_verify(0, digest, 20, signature, sig_len, eckey) != 1) {
-            BIO_printf(out, " failed\n");
+        if (!TEST_int_eq(ECDSA_verify(0, digest, 20, signature, sig_len,
+                                      eckey), 1))
             goto builtin_err;
-        }
-        BIO_printf(out, ".");
-        (void)BIO_flush(out);
+
         /* verify signature with the wrong key */
-        if (ECDSA_verify(0, digest, 20, signature, sig_len, wrong_eckey) == 1) {
-            BIO_printf(out, " failed\n");
+        if (!TEST_int_ne(ECDSA_verify(0, digest, 20, signature, sig_len,
+                                      wrong_eckey), 1))
             goto builtin_err;
-        }
-        BIO_printf(out, ".");
-        (void)BIO_flush(out);
+
         /* wrong digest */
-        if (ECDSA_verify(0, wrong_digest, 20, signature, sig_len, eckey) == 1) {
-            BIO_printf(out, " failed\n");
+        if (!TEST_int_ne(ECDSA_verify(0, wrong_digest, 20, signature,
+                                      sig_len, eckey), 1))
             goto builtin_err;
-        }
-        BIO_printf(out, ".");
-        (void)BIO_flush(out);
+
         /* wrong length */
-        if (ECDSA_verify(0, digest, 20, signature, sig_len - 1, eckey) == 1) {
-            BIO_printf(out, " failed\n");
+        if (!TEST_int_ne(ECDSA_verify(0, digest, 20, signature,
+                                      sig_len - 1, eckey), 1))
             goto builtin_err;
-        }
-        BIO_printf(out, ".");
-        (void)BIO_flush(out);
 
         /*
          * Modify a single byte of the signature: to ensure we don't garble
@@ -385,10 +329,8 @@ int test_builtin(BIO *out)
          * one of the bignums directly.
          */
         sig_ptr = signature;
-        if ((ecdsa_sig = d2i_ECDSA_SIG(NULL, &sig_ptr, sig_len)) == NULL) {
-            BIO_printf(out, " failed\n");
+        if (!TEST_ptr(ecdsa_sig = d2i_ECDSA_SIG(NULL, &sig_ptr, sig_len)))
             goto builtin_err;
-        }
 
         ECDSA_SIG_get0(ecdsa_sig, &sig_r, &sig_s);
 
@@ -396,12 +338,11 @@ int test_builtin(BIO *out)
         r_len = BN_num_bytes(sig_r);
         s_len = BN_num_bytes(sig_s);
         bn_len = (degree + 7) / 8;
-        if ((r_len > bn_len) || (s_len > bn_len)) {
-            BIO_printf(out, " failed\n");
+        if (!TEST_false(r_len > bn_len)
+                || !TEST_false(s_len > bn_len))
             goto builtin_err;
-        }
         buf_len = 2 * bn_len;
-        if ((raw_buf = OPENSSL_zalloc(buf_len)) == NULL)
+        if (!TEST_ptr(raw_buf = OPENSSL_zalloc(buf_len)))
             goto builtin_err;
         BN_bn2bin(sig_r, raw_buf + bn_len - r_len);
         BN_bn2bin(sig_s, raw_buf + buf_len - s_len);
@@ -410,30 +351,31 @@ int test_builtin(BIO *out)
         offset = raw_buf[10] % buf_len;
         dirt = raw_buf[11] ? raw_buf[11] : 1;
         raw_buf[offset] ^= dirt;
+
         /* Now read the BIGNUMs back in from raw_buf. */
-        modified_sig = ECDSA_SIG_new();
-        if (modified_sig == NULL)
+        if (!TEST_ptr(modified_sig = ECDSA_SIG_new()))
             goto builtin_err;
-        if (((modified_r = BN_bin2bn(raw_buf, bn_len, NULL)) == NULL)
-            || ((modified_s = BN_bin2bn(raw_buf + bn_len, bn_len, NULL)) == NULL)
-            || !ECDSA_SIG_set0(modified_sig, modified_r, modified_s)) {
+        if (!TEST_ptr(modified_r = BN_bin2bn(raw_buf, bn_len, NULL))
+                || !TEST_ptr(modified_s = BN_bin2bn(raw_buf + bn_len,
+                                                    bn_len, NULL))
+                || !TEST_true(ECDSA_SIG_set0(modified_sig,
+                                             modified_r, modified_s))) {
             BN_free(modified_r);
             BN_free(modified_s);
             goto builtin_err;
         }
         sig_ptr2 = signature;
         sig_len = i2d_ECDSA_SIG(modified_sig, &sig_ptr2);
-        if (ECDSA_verify(0, digest, 20, signature, sig_len, eckey) == 1) {
-            BIO_printf(out, " failed\n");
+        if (!TEST_false(ECDSA_verify(0, digest, 20, signature, sig_len, eckey)))
             goto builtin_err;
-        }
-        /*
-         * Sanity check: undo the modification and verify signature.
-         */
+
+        /* Sanity check: undo the modification and verify signature. */
         raw_buf[offset] ^= dirt;
-        if (((unmodified_r = BN_bin2bn(raw_buf, bn_len, NULL)) == NULL)
-            || ((unmodified_s = BN_bin2bn(raw_buf + bn_len, bn_len, NULL)) == NULL)
-            || !ECDSA_SIG_set0(modified_sig, unmodified_r, unmodified_s)) {
+        if (!TEST_ptr(unmodified_r = BN_bin2bn(raw_buf, bn_len, NULL))
+                || !TEST_ptr(unmodified_s = BN_bin2bn(raw_buf + bn_len,
+                                                       bn_len, NULL))
+                || !TEST_true(ECDSA_SIG_set0(modified_sig, unmodified_r,
+                                             unmodified_s))) {
             BN_free(unmodified_r);
             BN_free(unmodified_s);
             goto builtin_err;
@@ -441,16 +383,10 @@ int test_builtin(BIO *out)
 
         sig_ptr2 = signature;
         sig_len = i2d_ECDSA_SIG(modified_sig, &sig_ptr2);
-        if (ECDSA_verify(0, digest, 20, signature, sig_len, eckey) != 1) {
-            BIO_printf(out, " failed\n");
+        if (!TEST_true(ECDSA_verify(0, digest, 20, signature, sig_len, eckey)))
             goto builtin_err;
-        }
-        BIO_printf(out, ".");
-        (void)BIO_flush(out);
 
-        BIO_printf(out, " ok\n");
         /* cleanup */
-        /* clean bogus errors */
         ERR_clear_error();
         OPENSSL_free(signature);
         signature = NULL;
@@ -479,41 +415,11 @@ int test_builtin(BIO *out)
     return ret;
 }
 
-int main(void)
+void register_tests(void)
 {
-    int ret = 1;
-    BIO *out;
-    char *p;
-
-    out = BIO_new_fp(stdout, BIO_NOCLOSE | BIO_FP_TEXT);
-
-    p = getenv("OPENSSL_DEBUG_MEMORY");
-    if (p != NULL && strcmp(p, "on") == 0)
-        CRYPTO_set_mem_debug(1);
-
     /* initialize the prng */
     RAND_seed(rnd_seed, sizeof(rnd_seed));
-
-    /* the tests */
-    if (!x9_62_tests(out))
-        goto err;
-    if (!test_builtin(out))
-        goto err;
-
-    ret = 0;
- err:
-    if (ret)
-        BIO_printf(out, "\nECDSA test failed\n");
-    else
-        BIO_printf(out, "\nECDSA test passed\n");
-    if (ret)
-        ERR_print_errors(out);
-
-#ifndef OPENSSL_NO_CRYPTO_MDEBUG
-    if (CRYPTO_mem_leaks(out) <= 0)
-        ret = 1;
-#endif
-    BIO_free(out);
-    return ret;
+    ADD_TEST(x9_62_tests);
+    ADD_TEST(test_builtin);
 }
 #endif
diff --git a/test/enginetest.c b/test/enginetest.c
index 21cd20af05..89107a3b1e 100644
--- a/test/enginetest.c
+++ b/test/enginetest.c
@@ -22,21 +22,20 @@ int main(int argc, char *argv[])
 # include <openssl/crypto.h>
 # include <openssl/engine.h>
 # include <openssl/err.h>
+# include "testutil.h"
+# include "test_main.h"
 
 static void display_engine_list(void)
 {
     ENGINE *h;
     int loop;
 
-    h = ENGINE_get_first();
     loop = 0;
-    printf("listing available engine types\n");
-    while (h) {
-        printf("engine %i, id = \"%s\", name = \"%s\"\n",
+    for (h = ENGINE_get_first(); h != NULL; h = ENGINE_get_next(h)) {
+        TEST_info("#%d: id = \"%s\", name = \"%s\"",
                loop++, ENGINE_get_id(h), ENGINE_get_name(h));
-        h = ENGINE_get_next(h);
     }
-    printf("end of list\n");
+
     /*
      * ENGINE_get_first() increases the struct_ref counter, so we must call
      * ENGINE_free() to decrease it again
@@ -44,161 +43,146 @@ static void display_engine_list(void)
     ENGINE_free(h);
 }
 
-int main(int argc, char *argv[])
+#define NUMTOADD 512
+
+static int test_engines(void)
 {
-    ENGINE *block[512];
+    ENGINE *block[NUMTOADD];
     char buf[256];
-    const char *id, *name, *p;
+    const char *id, *name;
     ENGINE *ptr;
     int loop;
-    int to_return = 1;
+    int to_return = 0;
     ENGINE *new_h1 = NULL;
     ENGINE *new_h2 = NULL;
     ENGINE *new_h3 = NULL;
     ENGINE *new_h4 = NULL;
 
-    p = getenv("OPENSSL_DEBUG_MEMORY");
-    if (p != NULL && strcmp(p, "on") == 0)
-        CRYPTO_set_mem_debug(1);
-
     memset(block, 0, sizeof(block));
-    if (((new_h1 = ENGINE_new()) == NULL) ||
-        !ENGINE_set_id(new_h1, "test_id0") ||
-        !ENGINE_set_name(new_h1, "First test item") ||
-        ((new_h2 = ENGINE_new()) == NULL) ||
-        !ENGINE_set_id(new_h2, "test_id1") ||
-        !ENGINE_set_name(new_h2, "Second test item") ||
-        ((new_h3 = ENGINE_new()) == NULL) ||
-        !ENGINE_set_id(new_h3, "test_id2") ||
-        !ENGINE_set_name(new_h3, "Third test item") ||
-        ((new_h4 = ENGINE_new()) == NULL) ||
-        !ENGINE_set_id(new_h4, "test_id3") ||
-        !ENGINE_set_name(new_h4, "Fourth test item")) {
-        printf("Couldn't set up test ENGINE structures\n");
+    if (!TEST_ptr(new_h1 = ENGINE_new())
+            || !TEST_true(ENGINE_set_id(new_h1, "test_id0"))
+            || !TEST_true(ENGINE_set_name(new_h1, "First test item"))
+            || !TEST_ptr(new_h2 = ENGINE_new())
+            || !TEST_true(ENGINE_set_id(new_h2, "test_id1"))
+            || !TEST_true(ENGINE_set_name(new_h2, "Second test item"))
+            || !TEST_ptr(new_h3 = ENGINE_new())
+            || !TEST_true(ENGINE_set_id(new_h3, "test_id2"))
+            || !TEST_true(ENGINE_set_name(new_h3, "Third test item"))
+            || !TEST_ptr(new_h4 = ENGINE_new())
+            || !TEST_true(ENGINE_set_id(new_h4, "test_id3"))
+            || !TEST_true(ENGINE_set_name(new_h4, "Fourth test item")))
         goto end;
-    }
-    printf("\nenginetest beginning\n\n");
+    TEST_info("Engines:");
     display_engine_list();
-    if (!ENGINE_add(new_h1)) {
-        printf("Add failed!\n");
+
+    if (!TEST_true(ENGINE_add(new_h1)))
         goto end;
-    }
+    TEST_info("Engines:");
     display_engine_list();
+
     ptr = ENGINE_get_first();
-    if (!ENGINE_remove(ptr)) {
-        printf("Remove failed!\n");
+    if (!TEST_true(ENGINE_remove(ptr)))
         goto end;
-    }
     ENGINE_free(ptr);
+    TEST_info("Engines:");
     display_engine_list();
-    if (!ENGINE_add(new_h3) || !ENGINE_add(new_h2)) {
-        printf("Add failed!\n");
+
+    if (!TEST_true(ENGINE_add(new_h3))
+            || !TEST_true(ENGINE_add(new_h2)))
         goto end;
-    }
+    TEST_info("Engines:");
     display_engine_list();
-    if (!ENGINE_remove(new_h2)) {
-        printf("Remove failed!\n");
+
+    if (!TEST_true(ENGINE_remove(new_h2)))
         goto end;
-    }
+    TEST_info("Engines:");
     display_engine_list();
-    if (!ENGINE_add(new_h4)) {
-        printf("Add failed!\n");
+
+    if (!TEST_true(ENGINE_add(new_h4)))
         goto end;
-    }
+    TEST_info("Engines:");
     display_engine_list();
-    if (ENGINE_add(new_h3)) {
-        printf("Add *should* have failed but didn't!\n");
+
+    /* Should fail. */
+    if (!TEST_false(ENGINE_add(new_h3)))
         goto end;
-    } else
-        printf("Add that should fail did.\n");
     ERR_clear_error();
-    if (ENGINE_remove(new_h2)) {
-        printf("Remove *should* have failed but didn't!\n");
+
+    /* Should fail. */
+    if (!TEST_false(ENGINE_remove(new_h2)))
         goto end;
-    } else
-        printf("Remove that should fail did.\n");
     ERR_clear_error();
-    if (!ENGINE_remove(new_h3)) {
-        printf("Remove failed!\n");
+
+    if (!TEST_true(ENGINE_remove(new_h3)))
         goto end;
-    }
+    TEST_info("Engines:");
     display_engine_list();
-    if (!ENGINE_remove(new_h4)) {
-        printf("Remove failed!\n");
+
+    if (!TEST_true(ENGINE_remove(new_h4)))
         goto end;
-    }
+    TEST_info("Engines:");
     display_engine_list();
+
     /*
      * Depending on whether there's any hardware support compiled in, this
      * remove may be destined to fail.
      */
-    ptr = ENGINE_get_first();
-    if (ptr)
+    if ((ptr = ENGINE_get_first()) != NULL) {
         if (!ENGINE_remove(ptr))
-            printf("Remove failed!i - probably no hardware "
-                   "support present.\n");
+            TEST_info("Remove failed - probably no hardware support present");
+    }
     ENGINE_free(ptr);
+    TEST_info("Engines:");
     display_engine_list();
-    if (!ENGINE_add(new_h1) || !ENGINE_remove(new_h1)) {
-        printf("Couldn't add and remove to an empty list!\n");
+
+    if (!TEST_true(ENGINE_add(new_h1))
+            || !TEST_true(ENGINE_remove(new_h1)))
         goto end;
-    } else
-        printf("Successfully added and removed to an empty list!\n");
-    printf("About to beef up the engine-type list\n");
-    for (loop = 0; loop < 512; loop++) {
-        sprintf(buf, "id%i", loop);
+
+    TEST_info("About to beef up the engine-type list");
+    for (loop = 0; loop < NUMTOADD; loop++) {
+        sprintf(buf, "id%d", loop);
         id = OPENSSL_strdup(buf);
-        sprintf(buf, "Fake engine type %i", loop);
+        sprintf(buf, "Fake engine type %d", loop);
         name = OPENSSL_strdup(buf);
-        if (((block[loop] = ENGINE_new()) == NULL) ||
-            !ENGINE_set_id(block[loop], id) ||
-            !ENGINE_set_name(block[loop], name)) {
-            printf("Couldn't create block of ENGINE structures.\n"
-                   "I'll probably also core-dump now, damn.\n");
+        if (!TEST_ptr(block[loop] = ENGINE_new())
+                || !TEST_true(ENGINE_set_id(block[loop], id))
+                || !TEST_true(ENGINE_set_name(block[loop], name)))
             goto end;
-        }
     }
-    for (loop = 0; loop < 512; loop++) {
-        if (!ENGINE_add(block[loop])) {
-            printf("\nAdding stopped at %i, (%s,%s)\n",
+    for (loop = 0; loop < NUMTOADD; loop++) {
+        if (!TEST_true(ENGINE_add(block[loop]))) {
+            printf("Adding stopped at %d, (%s,%s)",
                    loop, ENGINE_get_id(block[loop]),
                    ENGINE_get_name(block[loop]));
             goto cleanup_loop;
-        } else
-            printf(".");
-        fflush(stdout);
+        }
     }
  cleanup_loop:
-    printf("\nAbout to empty the engine-type list\n");
+    TEST_info("About to empty the engine-type list");
     while ((ptr = ENGINE_get_first()) != NULL) {
-        if (!ENGINE_remove(ptr)) {
-            printf("\nRemove failed!\n");
+        if (!TEST_true(ENGINE_remove(ptr)))
             goto end;
-        }
         ENGINE_free(ptr);
-        printf(".");
-        fflush(stdout);
     }
-    for (loop = 0; loop < 512; loop++) {
+    for (loop = 0; loop < NUMTOADD; loop++) {
         OPENSSL_free((void *)ENGINE_get_id(block[loop]));
         OPENSSL_free((void *)ENGINE_get_name(block[loop]));
     }
-    printf("\nTests completed happily\n");
-    to_return = 0;
+    to_return = 1;
+
  end:
-    if (to_return)
-        ERR_print_errors_fp(stderr);
     ENGINE_free(new_h1);
     ENGINE_free(new_h2);
     ENGINE_free(new_h3);
     ENGINE_free(new_h4);
-    for (loop = 0; loop < 512; loop++)
+    for (loop = 0; loop < NUMTOADD; loop++)
         ENGINE_free(block[loop]);
-
-#ifndef OPENSSL_NO_CRYPTO_MDEBUG
-    if (CRYPTO_mem_leaks_fp(stderr) <= 0)
-        to_return = 1;
-#endif
     return to_return;
 }
+
+void register_tests(void)
+{
+    ADD_TEST(test_engines);
+}
 #endif
diff --git a/test/pbelutest.c b/test/pbelutest.c
index e226d43f26..11189b4776 100644
--- a/test/pbelutest.c
+++ b/test/pbelutest.c
@@ -8,40 +8,49 @@
  */
 
 #include <openssl/evp.h>
-#include <stdio.h>
-#include <string.h>
+#include "testutil.h"
+#include "test_main.h"
 
 /*
  * Password based encryption (PBE) table ordering test.
  * Attempt to look up all supported algorithms.
  */
 
-int main(int argc, char **argv)
+static int test_pbelu(void)
 {
-    size_t i;
-    int rv = 0;
-    int pbe_type, pbe_nid;
-    int last_type = -1, last_nid = -1;
+    int i, failed = 0, ok;
+    int pbe_type, pbe_nid, last_type = -1, last_nid = -1;
+
     for (i = 0; EVP_PBE_get(&pbe_type, &pbe_nid, i) != 0; i++) {
-        if (EVP_PBE_find(pbe_type, pbe_nid, NULL, NULL, 0) == 0) {
-            rv = 1;
+        if (!TEST_true(EVP_PBE_find(pbe_type, pbe_nid, NULL, NULL, 0))) {
+            TEST_info("i=%d, pbe_type=%d, pbe_nid=%d", i, pbe_type, pbe_nid);
+            failed = 1;
             break;
         }
     }
-    if (rv == 0)
-        return 0;
+
+    if (!failed)
+        return 1;
+
     /* Error: print out whole table */
     for (i = 0; EVP_PBE_get(&pbe_type, &pbe_nid, i) != 0; i++) {
         if (pbe_type > last_type)
-            rv = 0;
+            ok = 0;
         else if (pbe_type < last_type || pbe_nid < last_nid)
-            rv = 1;
+            ok = 1;
         else
-            rv = 0;
-        fprintf(stderr, "PBE type=%d %d (%s): %s\n", pbe_type, pbe_nid,
-                OBJ_nid2sn(pbe_nid), rv ? "ERROR" : "OK");
+            ok = 0;
+        if (!ok)
+            failed = 1;
+        TEST_info("PBE type=%d %d (%s): %s\n", pbe_type, pbe_nid,
+                OBJ_nid2sn(pbe_nid), ok ? "ERROR" : "OK");
         last_type = pbe_type;
         last_nid = pbe_nid;
     }
-    return 1;
+    return failed ? 0 : 1;
+}
+
+void register_tests(void)
+{
+    ADD_TEST(test_pbelu);
 }
diff --git a/test/recordlentest.c b/test/recordlentest.c
index b9d868f6ae..70631495a6 100644
--- a/test/recordlentest.c
+++ b/test/recordlentest.c
@@ -103,11 +103,9 @@ static int test_record_overflow(int idx)
 
     ERR_clear_error();
 
-    if (!create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(), &sctx,
-                             &cctx, cert, privkey)) {
-        printf("Unable to create SSL_CTX pair\n");
+    if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
+                                       &sctx, &cctx, cert, privkey)))
         goto end;
-    }
 
     if (idx == TEST_ENCRYPTED_OVERFLOW_TLS1_2_OK
             || idx == TEST_ENCRYPTED_OVERFLOW_TLS1_2_NOT_OK) {
@@ -121,10 +119,9 @@ static int test_record_overflow(int idx)
         len = SSL3_RT_MAX_TLS13_ENCRYPTED_LENGTH;
     }
 
-    if (!create_ssl_objects(sctx, cctx, &serverssl, &clientssl, NULL, NULL)) {
-        printf("Unable to create SSL objects\n");
+    if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
+                                      NULL, NULL)))
         goto end;
-    }
 
     serverbio = SSL_get_rbio(serverssl);
 
@@ -135,29 +132,23 @@ static int test_record_overflow(int idx)
         if (idx == TEST_PLAINTEXT_OVERFLOW_NOT_OK)
             len++;
 
-        if (!write_record(serverbio, len, SSL3_RT_HANDSHAKE, TLS1_VERSION)) {
-            printf("Unable to write plaintext record\n");
+        if (!TEST_true(write_record(serverbio, len,
+                                    SSL3_RT_HANDSHAKE, TLS1_VERSION)))
             goto end;
-        }
 
-        if (SSL_accept(serverssl) > 0) {
-            printf("Unexpected success reading plaintext record\n");
+        if (!TEST_int_le(SSL_accept(serverssl), 0))
             goto end;
-        }
 
         overf_expected = (idx == TEST_PLAINTEXT_OVERFLOW_OK) ? 0 : 1;
-        if (fail_due_to_record_overflow(0) != overf_expected) {
-            printf("Unexpected error value received\n");
+        if (!TEST_int_eq(fail_due_to_record_overflow(0), overf_expected))
             goto end;
-        }
 
         goto success;
     }
 
-    if (!create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)) {
-        printf("Unable to create SSL connection\n");
+    if (!TEST_true(create_ssl_connection(serverssl, clientssl,
+                                         SSL_ERROR_NONE)))
         goto end;
-    }
 
     if (idx == TEST_ENCRYPTED_OVERFLOW_TLS1_2_NOT_OK
             || idx == TEST_ENCRYPTED_OVERFLOW_TLS1_3_NOT_OK) {
@@ -173,32 +164,24 @@ static int test_record_overflow(int idx)
     else
         recversion = TLS1_2_VERSION;
 
-    if (!write_record(serverbio, len, SSL3_RT_APPLICATION_DATA, recversion)) {
-        printf("Unable to write encrypted record\n");
+    if (!TEST_true(write_record(serverbio, len, SSL3_RT_APPLICATION_DATA,
+                                recversion)))
         goto end;
-    }
 
-    if (SSL_read_ex(serverssl, &buf, sizeof(buf), &written)) {
-        printf("Unexpected success reading encrypted record\n");
+    if (!TEST_false(SSL_read_ex(serverssl, &buf, sizeof(buf), &written)))
         goto end;
-    }
 
-    if (fail_due_to_record_overflow(1) != overf_expected) {
-        printf("Unexpected error value received\n");
+    if (!TEST_int_eq(fail_due_to_record_overflow(1), overf_expected))
         goto end;
-    }
 
  success:
     testresult = 1;
 
  end:
-    if(!testresult)
-        ERR_print_errors_fp(stdout);
     SSL_free(serverssl);
     SSL_free(clientssl);
     SSL_CTX_free(sctx);
     SSL_CTX_free(cctx);
-
     return testresult;
 }
 
@@ -207,10 +190,9 @@ int test_main(int argc, char *argv[])
     int testresult = 1;
 
     if (argc != 3) {
-        printf("Invalid argument count\n");
+        TEST_error("Invalid argument count");
         return 1;
     }
-
     cert = argv[1];
     privkey = argv[2];
 
diff --git a/test/srptest.c b/test/srptest.c
index 73b3881ec6..6d14571635 100644
--- a/test/srptest.c
+++ b/test/srptest.c
@@ -23,13 +23,23 @@ int main(int argc, char *argv[])
 # include <openssl/srp.h>
 # include <openssl/rand.h>
 # include <openssl/err.h>
+# include "testutil.h"
+# include "test_main.h"
 
 static void showbn(const char *name, const BIGNUM *bn)
 {
-    fputs(name, stdout);
-    fputs(" = ", stdout);
-    BN_print_fp(stdout, bn);
-    putc('\n', stdout);
+    BIO *b;
+    const char *text;
+    
+    if (!TEST_ptr(b = BIO_new(BIO_s_mem())))
+        return;
+    BIO_write(b, name, strlen(name));
+    BIO_write(b, " = ", 3);
+    BN_print(b, bn);
+    BIO_write(b, "\0", 1);
+    BIO_get_mem_data(b, &text);
+    TEST_info("%s", text);
+    BIO_free(b);
 }
 
 # define RANDOM_SIZE 32         /* use 256 bits on each side */
@@ -37,7 +47,7 @@ static void showbn(const char *name, const BIGNUM *bn)
 static int run_srp(const char *username, const char *client_pass,
                    const char *server_pass)
 {
-    int ret = -1;
+    int ret = 0;
     BIGNUM *s = NULL;
     BIGNUM *v = NULL;
     BIGNUM *a = NULL;
@@ -50,17 +60,15 @@ static int run_srp(const char *username, const char *client_pass,
     BIGNUM *Kserver = NULL;
     unsigned char rand_tmp[RANDOM_SIZE];
     /* use builtin 1024-bit params */
-    const SRP_gN *GN = SRP_get_default_gN("1024");
+    const SRP_gN *GN;
+    
+    if (!TEST_ptr(GN = SRP_get_default_gN("1024")))
+        return 0;
 
-    if (GN == NULL) {
-        fprintf(stderr, "Failed to get SRP parameters\n");
-        return -1;
-    }
     /* Set up server's password entry */
-    if (!SRP_create_verifier_BN(username, server_pass, &s, &v, GN->N, GN->g)) {
-        fprintf(stderr, "Failed to create SRP verifier\n");
-        return -1;
-    }
+    if (!TEST_true(SRP_create_verifier_BN(username, server_pass,
+                                          &s, &v, GN->N, GN->g)))
+        goto end;
 
     showbn("N", GN->N);
     showbn("g", GN->g);
@@ -70,32 +78,30 @@ static int run_srp(const char *username, const char *client_pass,
     /* Server random */
     RAND_bytes(rand_tmp, sizeof(rand_tmp));
     b = BN_bin2bn(rand_tmp, sizeof(rand_tmp), NULL);
-    /* TODO - check b != 0 */
+    if (!TEST_false(BN_is_zero(b)))
+        goto end;
     showbn("b", b);
 
     /* Server's first message */
     Bpub = SRP_Calc_B(b, GN->N, GN->g, v);
     showbn("B", Bpub);
 
-    if (!SRP_Verify_B_mod_N(Bpub, GN->N)) {
-        fprintf(stderr, "Invalid B\n");
-        return -1;
-    }
+    if (!TEST_true(SRP_Verify_B_mod_N(Bpub, GN->N)))
+        goto end;
 
     /* Client random */
     RAND_bytes(rand_tmp, sizeof(rand_tmp));
     a = BN_bin2bn(rand_tmp, sizeof(rand_tmp), NULL);
-    /* TODO - check a != 0 */
+    if (!TEST_false(BN_is_zero(a)))
+        goto end;
     showbn("a", a);
 
     /* Client's response */
     Apub = SRP_Calc_A(a, GN->N, GN->g);
     showbn("A", Apub);
 
-    if (!SRP_Verify_A_mod_N(Apub, GN->N)) {
-        fprintf(stderr, "Invalid A\n");
-        return -1;
-    }
+    if (!TEST_true(SRP_Verify_A_mod_N(Apub, GN->N)))
+        goto end;
 
     /* Both sides calculate u */
     u = SRP_Calc_u(Apub, Bpub, GN->N);
@@ -109,13 +115,12 @@ static int run_srp(const char *username, const char *client_pass,
     Kserver = SRP_Calc_server_key(Apub, v, u, b, GN->N);
     showbn("Server's key", Kserver);
 
-    if (BN_cmp(Kclient, Kserver) == 0) {
-        ret = 0;
-    } else {
-        fprintf(stderr, "Keys mismatch\n");
-        ret = 1;
-    }
+    if (!TEST_int_eq(BN_cmp(Kclient, Kserver), 0))
+        goto end;
+
+    ret = 1;
 
+end:
     BN_clear_free(Kclient);
     BN_clear_free(Kserver);
     BN_clear_free(x);
@@ -133,25 +138,19 @@ static int run_srp(const char *username, const char *client_pass,
 static int check_bn(const char *name, const BIGNUM *bn, const char *hexbn)
 {
     BIGNUM *tmp = NULL;
-    int rv;
-    if (BN_hex2bn(&tmp, hexbn) == 0)
+
+    if (!TEST_true(BN_hex2bn(&tmp, hexbn)))
         return 0;
-    rv = BN_cmp(bn, tmp);
-    if (rv == 0) {
-        printf("%s = ", name);
-        BN_print_fp(stdout, bn);
-        printf("\n");
+
+    if (!TEST_int_eq(BN_cmp(bn, tmp), 0)) {
+        TEST_info("Unexpected %s value", name);
+        showbn("expecting", tmp);
+        showbn("received", bn);
         BN_free(tmp);
-        return 1;
+        return 0;
     }
-    printf("Unexpected %s value\n", name);
-    printf("Expecting: ");
-    BN_print_fp(stdout, tmp);
-    printf("\nReceived: ");
-    BN_print_fp(stdout, bn);
-    printf("\n");
     BN_free(tmp);
-    return 0;
+    return 1;
 }
 
 /* SRP test vectors from RFC5054 */
@@ -169,26 +168,22 @@ static int run_srp_kat(void)
     BIGNUM *Kclient = NULL;
     BIGNUM *Kserver = NULL;
     /* use builtin 1024-bit params */
-    const SRP_gN *GN = SRP_get_default_gN("1024");
-
-    if (GN == NULL) {
-        fprintf(stderr, "Failed to get SRP parameters\n");
+    const SRP_gN *GN;
+        
+    if (!TEST_ptr(GN = SRP_get_default_gN("1024")))
         goto err;
-    }
     BN_hex2bn(&s, "BEB25379D1A8581EB5A727673A2441EE");
     /* Set up server's password entry */
-    if (!SRP_create_verifier_BN("alice", "password123", &s, &v, GN->N,
-                                GN->g)) {
-        fprintf(stderr, "Failed to create SRP verifier\n");
+    if (!TEST_true(SRP_create_verifier_BN("alice", "password123", &s, &v, GN->N,
+                                GN->g)))
         goto err;
-    }
 
-    if (!check_bn("v", v,
+    if (!TEST_true(check_bn("v", v,
                  "7E273DE8696FFC4F4E337D05B4B375BEB0DDE1569E8FA00A9886D812"
                  "9BADA1F1822223CA1A605B530E379BA4729FDC59F105B4787E5186F5"
                  "C671085A1447B52A48CF1970B4FB6F8400BBF4CEBFBB168152E08AB5"
                  "EA53D15C1AFF87B2B9DA6E04E058AD51CC72BFC9033B564E26480D78"
-                 "E955A5E29E7AB245DB2BE315E2099AFB"))
+                 "E955A5E29E7AB245DB2BE315E2099AFB")))
         goto err;
 
     /* Server random */
@@ -197,18 +192,15 @@ static int run_srp_kat(void)
 
     /* Server's first message */
     Bpub = SRP_Calc_B(b, GN->N, GN->g, v);
-
-    if (!SRP_Verify_B_mod_N(Bpub, GN->N)) {
-        fprintf(stderr, "Invalid B\n");
+    if (!TEST_true(SRP_Verify_B_mod_N(Bpub, GN->N)))
         goto err;
-    }
 
-    if (!check_bn("B", Bpub,
+    if (!TEST_true(check_bn("B", Bpub,
                   "BD0C61512C692C0CB6D041FA01BB152D4916A1E77AF46AE105393011"
                   "BAF38964DC46A0670DD125B95A981652236F99D9B681CBF87837EC99"
                   "6C6DA04453728610D0C6DDB58B318885D7D82C7F8DEB75CE7BD4FBAA"
                   "37089E6F9C6059F388838E7A00030B331EB76840910440B1B27AAEAE"
-                  "EB4012B7D7665238A8E3FB004B117B58"))
+                  "EB4012B7D7665238A8E3FB004B117B58")))
         goto err;
 
     /* Client random */
@@ -217,49 +209,48 @@ static int run_srp_kat(void)
 
     /* Client's response */
     Apub = SRP_Calc_A(a, GN->N, GN->g);
+    if (!TEST_true(SRP_Verify_A_mod_N(Apub, GN->N)))
+        goto err;
 
-    if (!SRP_Verify_A_mod_N(Apub, GN->N)) {
-        fprintf(stderr, "Invalid A\n");
-        return -1;
-    }
-
-    if (!check_bn("A", Apub,
+    if (!TEST_true(check_bn("A", Apub,
                   "61D5E490F6F1B79547B0704C436F523DD0E560F0C64115BB72557EC4"
                   "4352E8903211C04692272D8B2D1A5358A2CF1B6E0BFCF99F921530EC"
                   "8E39356179EAE45E42BA92AEACED825171E1E8B9AF6D9C03E1327F44"
                   "BE087EF06530E69F66615261EEF54073CA11CF5858F0EDFDFE15EFEA"
-                  "B349EF5D76988A3672FAC47B0769447B"))
+                  "B349EF5D76988A3672FAC47B0769447B")))
         goto err;
 
     /* Both sides calculate u */
     u = SRP_Calc_u(Apub, Bpub, GN->N);
 
-    if (!check_bn("u", u, "CE38B9593487DA98554ED47D70A7AE5F462EF019"))
+    if (!TEST_true(check_bn("u", u,
+                    "CE38B9593487DA98554ED47D70A7AE5F462EF019")))
         goto err;
 
     /* Client's key */
     x = SRP_Calc_x(s, "alice", "password123");
     Kclient = SRP_Calc_client_key(GN->N, Bpub, GN->g, x, a, u);
-    if (!check_bn("Client's key", Kclient,
+    if (!TEST_true(check_bn("Client's key", Kclient,
                   "B0DC82BABCF30674AE450C0287745E7990A3381F63B387AAF271A10D"
                   "233861E359B48220F7C4693C9AE12B0A6F67809F0876E2D013800D6C"
                   "41BB59B6D5979B5C00A172B4A2A5903A0BDCAF8A709585EB2AFAFA8F"
                   "3499B200210DCC1F10EB33943CD67FC88A2F39A4BE5BEC4EC0A3212D"
-                  "C346D7E474B29EDE8A469FFECA686E5A"))
+                  "C346D7E474B29EDE8A469FFECA686E5A")))
         goto err;
+
     /* Server's key */
     Kserver = SRP_Calc_server_key(Apub, v, u, b, GN->N);
-    if (!check_bn("Server's key", Kserver,
+    if (!TEST_true(check_bn("Server's key", Kserver,
                   "B0DC82BABCF30674AE450C0287745E7990A3381F63B387AAF271A10D"
                   "233861E359B48220F7C4693C9AE12B0A6F67809F0876E2D013800D6C"
                   "41BB59B6D5979B5C00A172B4A2A5903A0BDCAF8A709585EB2AFAFA8F"
                   "3499B200210DCC1F10EB33943CD67FC88A2F39A4BE5BEC4EC0A3212D"
-                  "C346D7E474B29EDE8A469FFECA686E5A"))
+                  "C346D7E474B29EDE8A469FFECA686E5A")))
         goto err;
 
     ret = 1;
 
-    err:
+err:
     BN_clear_free(Kclient);
     BN_clear_free(Kserver);
     BN_clear_free(x);
@@ -274,39 +265,22 @@ static int run_srp_kat(void)
     return ret;
 }
 
-int main(int argc, char **argv)
+static int run_srp_tests(void)
 {
-    BIO *bio_err;
-    bio_err = BIO_new_fp(stderr, BIO_NOCLOSE | BIO_FP_TEXT);
-
-    CRYPTO_set_mem_debug(1);
-    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
-
-
     /* "Negative" test, expect a mismatch */
-    if (run_srp("alice", "password1", "password2") == 0) {
-        fprintf(stderr, "Mismatched SRP run failed\n");
-        return 1;
-    }
+    if (!TEST_false(run_srp("alice", "password1", "password2")))
+        return 0;
 
     /* "Positive" test, should pass */
-    if (run_srp("alice", "password", "password") != 0) {
-        fprintf(stderr, "Plain SRP run failed\n");
-        return 1;
-    }
-
-    /* KAT from RFC5054: should pass */
-    if (run_srp_kat() != 1) {
-        fprintf(stderr, "SRP KAT failed\n");
-        return 1;
-    }
+    if (!TEST_true(run_srp("alice", "password", "password")))
+        return 0;
 
-#ifndef OPENSSL_NO_CRYPTO_MDEBUG
-    if (CRYPTO_mem_leaks(bio_err) <= 0)
-        return 1;
-#endif
-    BIO_free(bio_err);
+    return 1;
+}
 
-    return 0;
+void register_tests(void)
+{
+    ADD_TEST(run_srp_tests);
+    ADD_TEST(run_srp_kat);
 }
 #endif