Convert more tests
authorRich Salz <rsalz@openssl.org>
Tue, 18 Apr 2017 20:33:15 +0000 (16:33 -0400)
committerRich Salz <rsalz@openssl.org>
Tue, 18 Apr 2017 20:33:15 +0000 (16:33 -0400)
ct_test,evp_extra_test,wpackettest,packettest
Add strncmp TEST wrappers
And make some style/consistency fixes to ct_test
Silence travis; gcc bug?

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

test/build.info
test/ct_test.c
test/evp_extra_test.c
test/packettest.c
test/testutil.c
test/testutil.h
test/wpackettest.c

index d6e43cf..01b4c68 100644 (file)
@@ -151,7 +151,7 @@ IF[{- !$disabled{tests} -}]
   INCLUDE[evp_test]=../include
   DEPEND[evp_test]=../libcrypto
 
-  SOURCE[evp_extra_test]=evp_extra_test.c
+  SOURCE[evp_extra_test]=evp_extra_test.c testutil.c test_main.c
   INCLUDE[evp_extra_test]=../include
   DEPEND[evp_extra_test]=../libcrypto
 
@@ -191,7 +191,7 @@ IF[{- !$disabled{tests} -}]
   INCLUDE[bad_dtls_test]=../include
   DEPEND[bad_dtls_test]=../libcrypto ../libssl
 
-  SOURCE[packettest]=packettest.c
+  SOURCE[packettest]=packettest.c testutil.c test_main.c
   INCLUDE[packettest]=../include
   DEPEND[packettest]=../libcrypto
 
index ac89f57..e96eab0 100644 (file)
@@ -60,29 +60,21 @@ typedef struct ct_test_fixture {
 static CT_TEST_FIXTURE set_up(const char *const test_case_name)
 {
     CT_TEST_FIXTURE fixture;
-    int setup_ok = 1;
+    int ok = 0;
 
     memset(&fixture, 0, sizeof(fixture));
-
     fixture.test_case_name = test_case_name;
     fixture.epoch_time_in_ms = 1473269626000; /* Sep 7 17:33:46 2016 GMT */
-    fixture.ctlog_store = CTLOG_STORE_new();
-
-    if (fixture.ctlog_store == NULL) {
-        setup_ok = 0;
-        fprintf(stderr, "Failed to create a new CT log store\n");
+    if (!TEST_ptr(fixture.ctlog_store = CTLOG_STORE_new())
+            || !TEST_int_eq(
+                    CTLOG_STORE_load_default_file(fixture.ctlog_store), 1))
         goto end;
-    }
-
-    if (CTLOG_STORE_load_default_file(fixture.ctlog_store) != 1) {
-        setup_ok = 0;
-        fprintf(stderr, "Failed to load CT log list\n");
-        goto end;
-    }
+    ok = 1;
 
 end:
-    if (!setup_ok) {
+    if (!ok) {
         CTLOG_STORE_free(fixture.ctlog_store);
+        TEST_error("Failed to setup");
         exit(EXIT_FAILURE);
     }
     return fixture;
@@ -96,19 +88,18 @@ static void tear_down(CT_TEST_FIXTURE fixture)
 
 static char *mk_file_path(const char *dir, const char *file)
 {
-    char *full_file = NULL;
-    size_t full_file_l = 0;
-    const char *sep = "";
 #ifndef OPENSSL_SYS_VMS
-    sep = "/";
+    const char *sep = "/";
+#else
+    const char *sep = "";
 #endif
+    size_t len = strlen(dir) + strlen(sep) + strlen(file) + 1;
+    char *full_file = OPENSSL_zalloc(len);
 
-    full_file_l = strlen(dir) + strlen(sep) + strlen(file) + 1;
-    full_file = OPENSSL_zalloc(full_file_l);
     if (full_file != NULL) {
-        OPENSSL_strlcpy(full_file, dir, full_file_l);
-        OPENSSL_strlcat(full_file, sep, full_file_l);
-        OPENSSL_strlcat(full_file, file, full_file_l);
+        OPENSSL_strlcpy(full_file, dir, len);
+        OPENSSL_strlcat(full_file, sep, len);
+        OPENSSL_strlcat(full_file, file, len);
     }
 
     return full_file;
@@ -121,65 +112,54 @@ static X509 *load_pem_cert(const char *dir, const char *file)
 
     if (file_path != NULL) {
         BIO *cert_io = BIO_new_file(file_path, "r");
-        OPENSSL_free(file_path);
 
         if (cert_io != NULL)
             cert = PEM_read_bio_X509(cert_io, NULL, NULL, NULL);
-
         BIO_free(cert_io);
     }
+
+    OPENSSL_free(file_path);
     return cert;
 }
 
 static int read_text_file(const char *dir, const char *file,
                           char *buffer, int buffer_length)
 {
-    int result = -1;
+    int len = -1;
     char *file_path = mk_file_path(dir, file);
 
     if (file_path != NULL) {
         BIO *file_io = BIO_new_file(file_path, "r");
-        OPENSSL_free(file_path);
 
-        if (file_io != NULL) {
-            result = BIO_read(file_io, buffer, buffer_length);
-            BIO_free(file_io);
-        }
+        if (file_io != NULL)
+            len = BIO_read(file_io, buffer, buffer_length);
+        BIO_free(file_io);
     }
 
-    return result;
+    OPENSSL_free(file_path);
+    return len;
 }
 
 static int compare_sct_list_printout(STACK_OF(SCT) *sct,
-    const char *expected_output)
+                                     const char *expected_output)
 {
     BIO *text_buffer = NULL;
     char *actual_output = NULL;
-    int result = 1;
+    int result = 0;
 
-    text_buffer = BIO_new(BIO_s_mem());
-    if (text_buffer == NULL) {
-        fprintf(stderr, "Unable to allocate buffer\n");
+    if (!TEST_ptr(text_buffer = BIO_new(BIO_s_mem())))
         goto end;
-    }
 
     SCT_LIST_print(sct, text_buffer, 0, "\n", NULL);
 
-    /* Append null terminator because we're about to use the buffer contents
-    * as a string. */
-    if (BIO_write(text_buffer, "\0", 1) != 1) {
-        fprintf(stderr, "Failed to append null terminator to SCT text\n");
+    /* Append \0 because we're about to use the buffer contents as a string. */
+    if (!TEST_true(BIO_write(text_buffer, "\0", 1)))
         goto end;
-    }
 
     BIO_get_mem_data(text_buffer, &actual_output);
-    result = strcmp(actual_output, expected_output);
-
-    if (result != 0) {
-        fprintf(stderr,
-            "Expected SCT printout:\n%s\nActual SCT printout:\n%s\n",
-            expected_output, actual_output);
-    }
+    if (!TEST_str_eq(actual_output, expected_output))
+        goto end;
+    result = 1;
 
 end:
     BIO_free(text_buffer);
@@ -191,55 +171,41 @@ static int compare_extension_printout(X509_EXTENSION *extension,
 {
     BIO *text_buffer = NULL;
     char *actual_output = NULL;
-    int result = 1;
-
-    text_buffer = BIO_new(BIO_s_mem());
-    if (text_buffer == NULL) {
-        fprintf(stderr, "Unable to allocate buffer\n");
-        goto end;
-    }
+    int result = 0;
 
-    if (!X509V3_EXT_print(text_buffer, extension, X509V3_EXT_DEFAULT, 0)) {
-        fprintf(stderr, "Failed to print extension\n");
+    if (!TEST_ptr(text_buffer = BIO_new(BIO_s_mem()))
+            || !TEST_true(X509V3_EXT_print(text_buffer, extension,
+                                           X509V3_EXT_DEFAULT, 0)))
         goto end;
-    }
 
-    /* Append null terminator because we're about to use the buffer contents
-     * as a string. */
-    if (BIO_write(text_buffer, "\0", 1) != 1) {
-        fprintf(stderr,
-                "Failed to append null terminator to extension text\n");
+    /* Append \0 because we're about to use the buffer contents as a string. */
+    if (!TEST_true(BIO_write(text_buffer, "\0", 1)))
         goto end;
-    }
 
     BIO_get_mem_data(text_buffer, &actual_output);
-    result = strcmp(actual_output, expected_output);
+    if (!TEST_str_eq(actual_output, expected_output))
+        goto end;
 
-    if (result != 0) {
-        fprintf(stderr,
-                "Expected SCT printout:\n%s\nActual SCT printout:\n%s\n",
-                expected_output, actual_output);
-    }
+    result = 1;
 
 end:
     BIO_free(text_buffer);
     return result;
 }
 
-static int assert_validity(CT_TEST_FIXTURE fixture,
-                           STACK_OF(SCT) *scts,
-                           CT_POLICY_EVAL_CTX *policy_ctx) {
+static int assert_validity(CT_TEST_FIXTURE fixture, STACK_OF(SCT) *scts,
+                           CT_POLICY_EVAL_CTX *policy_ctx)
+{
     int invalid_sct_count = 0;
     int valid_sct_count = 0;
     int i;
 
-    if (SCT_LIST_validate(scts, policy_ctx) < 0) {
-        fprintf(stderr, "Error verifying SCTs\n");
+    if (!TEST_int_ge(SCT_LIST_validate(scts, policy_ctx), 0))
         return 0;
-    }
 
     for (i = 0; i < sk_SCT_num(scts); ++i) {
         SCT *sct_i = sk_SCT_value(scts, i);
+
         switch (SCT_get_validation_status(sct_i)) {
         case SCT_VALIDATION_STATUS_VALID:
             ++valid_sct_count;
@@ -256,18 +222,12 @@ static int assert_validity(CT_TEST_FIXTURE fixture,
         }
     }
 
-    if (valid_sct_count != fixture.expected_valid_sct_count) {
+    if (!TEST_int_eq(valid_sct_count, fixture.expected_valid_sct_count)) {
         int unverified_sct_count = sk_SCT_num(scts) -
-                invalid_sct_count - valid_sct_count;
-
-        fprintf(stderr,
-                "%d SCTs failed verification\n"
-                "%d SCTs passed verification (%d expected)\n"
-                "%d SCTs were unverified\n",
-                invalid_sct_count,
-                valid_sct_count,
-                fixture.expected_valid_sct_count,
-                unverified_sct_count);
+                                        invalid_sct_count - valid_sct_count;
+
+        TEST_info("%d SCTs failed, %d SCTs unverified",
+                  invalid_sct_count, unverified_sct_count);
         return 0;
     }
 
@@ -291,12 +251,8 @@ static int execute_cert_test(CT_TEST_FIXTURE fixture)
                                       expected_sct_text,
                                       CT_TEST_MAX_FILE_SIZE - 1);
 
-        if (sct_text_len < 0) {
-            fprintf(stderr, "Test data file not found: %s\n",
-                fixture.sct_text_file);
+        if (!TEST_int_ge(sct_text_len, 0))
             goto end;
-        }
-
         expected_sct_text[sct_text_len] = '\0';
     }
 
@@ -308,25 +264,17 @@ static int execute_cert_test(CT_TEST_FIXTURE fixture)
     if (fixture.certificate_file != NULL) {
         int sct_extension_index;
         X509_EXTENSION *sct_extension = NULL;
-        cert = load_pem_cert(fixture.certs_dir, fixture.certificate_file);
 
-        if (cert == NULL) {
-            fprintf(stderr, "Unable to load certificate: %s\n",
-                fixture.certificate_file);
+        if (!TEST_ptr(cert = load_pem_cert(fixture.certs_dir,
+                                           fixture.certificate_file)))
             goto end;
-        }
 
         CT_POLICY_EVAL_CTX_set1_cert(ct_policy_ctx, cert);
 
         if (fixture.issuer_file != NULL) {
-            issuer = load_pem_cert(fixture.certs_dir, fixture.issuer_file);
-
-            if (issuer == NULL) {
-                fprintf(stderr, "Unable to load issuer certificate: %s\n",
-                        fixture.issuer_file);
+            if (!TEST_ptr(issuer = load_pem_cert(fixture.certs_dir,
+                                                 fixture.issuer_file)))
                 goto end;
-            }
-
             CT_POLICY_EVAL_CTX_set1_issuer(ct_policy_ctx, issuer);
         }
 
@@ -334,17 +282,13 @@ static int execute_cert_test(CT_TEST_FIXTURE fixture)
                 X509_get_ext_by_NID(cert, NID_ct_precert_scts, -1);
         sct_extension = X509_get_ext(cert, sct_extension_index);
         if (fixture.expected_sct_count > 0) {
-            if (sct_extension == NULL) {
-                fprintf(stderr, "SCT extension not found in: %s\n",
-                    fixture.certificate_file);
+            if (!TEST_ptr(sct_extension))
                 goto end;
-            }
 
             if (fixture.sct_text_file
-                && compare_extension_printout(sct_extension,
-                                              expected_sct_text)) {
+                && !compare_extension_printout(sct_extension,
+                                               expected_sct_text))
                     goto end;
-            }
 
             if (fixture.test_validity) {
                 int i;
@@ -353,30 +297,24 @@ static int execute_cert_test(CT_TEST_FIXTURE fixture)
                 for (i = 0; i < sk_SCT_num(scts); ++i) {
                     SCT *sct_i = sk_SCT_value(scts, i);
 
-                    if (!SCT_set_source(sct_i, SCT_SOURCE_X509V3_EXTENSION)) {
-                        fprintf(stderr,
-                                "Error setting SCT source to X509v3 extension\n");
+                    if (!TEST_true(SCT_set_source(sct_i,
+                                                  SCT_SOURCE_X509V3_EXTENSION)))
                         goto end;
-                    }
                 }
 
                 if (!assert_validity(fixture, scts, ct_policy_ctx))
                     goto end;
             }
-        } else if (sct_extension != NULL) {
-            fprintf(stderr,
-                    "Expected no SCTs, but found SCT extension in: %s\n",
-                    fixture.certificate_file);
+        } else if (!TEST_ptr_null(sct_extension)) {
             goto end;
         }
     }
 
     if (fixture.tls_sct_list != NULL) {
         const unsigned char *p = fixture.tls_sct_list;
-        if (o2i_SCT_LIST(&scts, &p, fixture.tls_sct_list_len) == NULL) {
-            fprintf(stderr, "Failed to decode SCTs from TLS format\n");
+
+        if (!TEST_ptr(o2i_SCT_LIST(&scts, &p, fixture.tls_sct_list_len)))
             goto end;
-        }
 
         if (fixture.test_validity && cert != NULL) {
             if (!assert_validity(fixture, scts, ct_policy_ctx))
@@ -384,17 +322,14 @@ static int execute_cert_test(CT_TEST_FIXTURE fixture)
         }
 
         if (fixture.sct_text_file
-            && compare_sct_list_printout(scts, expected_sct_text)) {
+            && !compare_sct_list_printout(scts, expected_sct_text)) {
                 goto end;
         }
 
         tls_sct_list_len = i2o_SCT_LIST(scts, &tls_sct_list);
-        if (tls_sct_list_len != fixture.tls_sct_list_len ||
-            memcmp(fixture.tls_sct_list, tls_sct_list, tls_sct_list_len) != 0) {
-            fprintf(stderr,
-                    "Failed to encode SCTs into TLS format correctly\n");
+        if (!TEST_mem_eq(fixture.tls_sct_list, fixture.tls_sct_list_len,
+                         tls_sct_list, tls_sct_list_len))
             goto end;
-        }
     }
     success = 1;
 
@@ -520,15 +455,11 @@ static int test_encode_tls_sct()
     SETUP_CT_TEST_FIXTURE();
 
     fixture.sct_list = sk_SCT_new_null();
-    sct = SCT_new_from_base64(SCT_VERSION_V1, log_id,
-                              CT_LOG_ENTRY_TYPE_X509, timestamp,
-                              extensions, signature);
+    if (!TEST_ptr(sct = SCT_new_from_base64(SCT_VERSION_V1, log_id,
+                                            CT_LOG_ENTRY_TYPE_X509, timestamp,
+                                            extensions, signature)))
 
-    if (sct == NULL) {
-        tear_down(fixture);
-        fprintf(stderr, "Failed to create SCT from base64-encoded test data\n");
         return 0;
-    }
 
     sk_SCT_push(fixture.sct_list, sct);
     fixture.sct_dir = ct_dir;
@@ -548,11 +479,8 @@ static int test_default_ct_policy_eval_ctx_time_is_now()
             1000;
     const time_t time_tolerance = 600;  /* 10 minutes */
 
-    if (fabs(difftime(time(NULL), default_time)) > time_tolerance) {
-        fprintf(stderr,
-                "Default CT_POLICY_EVAL_CTX time is not approximately now.\n");
+    if (!TEST_uint_le(fabs(difftime(time(NULL), default_time)), time_tolerance))
         goto end;
-    }
 
     success = 1;
 end:
@@ -562,13 +490,10 @@ end:
 
 int test_main(int argc, char *argv[])
 {
-    int result = 0;
-    char *tmp_env;
-
-    tmp_env = getenv("CT_DIR");
-    ct_dir = OPENSSL_strdup(tmp_env != NULL ? tmp_env : "ct");
-    tmp_env = getenv("CERTS_DIR");
-    certs_dir = OPENSSL_strdup(tmp_env != NULL ? tmp_env : "certs");
+    if ((ct_dir = getenv("CT_DIR")) == NULL)
+        ct_dir = "ct";
+    if ((certs_dir = getenv("CERTS_DIR")) == NULL)
+        certs_dir = "certs";
 
     ADD_TEST(test_no_scts_in_certificate);
     ADD_TEST(test_one_sct_in_certificate);
@@ -580,12 +505,7 @@ int test_main(int argc, char *argv[])
     ADD_TEST(test_encode_tls_sct);
     ADD_TEST(test_default_ct_policy_eval_ctx_time_is_now);
 
-    result = run_tests(argv[0]);
-
-    OPENSSL_free(ct_dir);
-    OPENSSL_free(certs_dir);
-
-    return result;
+    return run_tests(argv[0]);
 }
 #else
 int test_main(int argc, char *argv[])
index 9217f3a..b8cfc0d 100644 (file)
@@ -15,6 +15,8 @@
 #include <openssl/evp.h>
 #include <openssl/rsa.h>
 #include <openssl/x509.h>
+#include "testutil.h"
+#include "test_main.h"
 
 /*
  * kExampleRSAKeyDER is an RSA private key in ASN.1, DER format. Of course, you
@@ -186,6 +188,18 @@ static const unsigned char kExampleBadECKeyDER[] = {
 };
 #endif
 
+typedef struct APK_DATA_st {
+    const unsigned char *kder;
+    size_t size;
+    int evptype;
+} APK_DATA;
+
+static APK_DATA keydata[] = {
+    {kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER), EVP_PKEY_RSA},
+    {kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8), EVP_PKEY_RSA},
+    {kExampleECKeyDER, sizeof(kExampleECKeyDER), EVP_PKEY_EC}
+};
+
 static EVP_PKEY *load_example_rsa_key(void)
 {
     EVP_PKEY *ret = NULL;
@@ -193,19 +207,17 @@ static EVP_PKEY *load_example_rsa_key(void)
     EVP_PKEY *pkey = NULL;
     RSA *rsa = NULL;
 
-    if (!d2i_RSAPrivateKey(&rsa, &derp, sizeof(kExampleRSAKeyDER))) {
+    if (!TEST_true(d2i_RSAPrivateKey(&rsa, &derp, sizeof(kExampleRSAKeyDER))))
         return NULL;
-    }
 
-    pkey = EVP_PKEY_new();
-    if (pkey == NULL || !EVP_PKEY_set1_RSA(pkey, rsa)) {
-        goto out;
-    }
+    if (!TEST_ptr(pkey = EVP_PKEY_new())
+            || !TEST_true(EVP_PKEY_set1_RSA(pkey, rsa)))
+        goto end;
 
     ret = pkey;
     pkey = NULL;
 
- out:
+end:
     EVP_PKEY_free(pkey);
     RSA_free(rsa);
 
@@ -218,48 +230,37 @@ static int test_EVP_DigestSignInit(void)
     EVP_PKEY *pkey = NULL;
     unsigned char *sig = NULL;
     size_t sig_len = 0;
-    EVP_MD_CTX *md_ctx, *md_ctx_verify;
+    EVP_MD_CTX *md_ctx, *md_ctx_verify = NULL;
 
-    md_ctx = EVP_MD_CTX_new();
-    md_ctx_verify = EVP_MD_CTX_new();
-    if (md_ctx == NULL || md_ctx_verify == NULL)
+    if (!TEST_ptr(md_ctx = EVP_MD_CTX_new())
+            || !TEST_ptr(md_ctx_verify = EVP_MD_CTX_new())
+            || !TEST_ptr(pkey = load_example_rsa_key()))
         goto out;
 
-    pkey = load_example_rsa_key();
-    if (pkey == NULL ||
-        !EVP_DigestSignInit(md_ctx, NULL, EVP_sha256(), NULL, pkey) ||
-        !EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))) {
+    if (!TEST_true(EVP_DigestSignInit(md_ctx, NULL, EVP_sha256(), NULL, pkey))
+            || !TEST_true(EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))))
         goto out;
-    }
+
     /* Determine the size of the signature. */
-    if (!EVP_DigestSignFinal(md_ctx, NULL, &sig_len)) {
+    if (!TEST_true(EVP_DigestSignFinal(md_ctx, NULL, &sig_len))
+            || !TEST_size_t_eq(sig_len, (size_t)EVP_PKEY_size(pkey)))
         goto out;
-    }
-    /* Sanity check for testing. */
-    if (sig_len != (size_t)EVP_PKEY_size(pkey)) {
-        fprintf(stderr, "sig_len mismatch\n");
-        goto out;
-    }
 
-    sig = OPENSSL_malloc(sig_len);
-    if (sig == NULL || !EVP_DigestSignFinal(md_ctx, sig, &sig_len)) {
+    if (!TEST_ptr(sig = OPENSSL_malloc(sig_len))
+            || !TEST_true(EVP_DigestSignFinal(md_ctx, sig, &sig_len)))
         goto out;
-    }
 
     /* Ensure that the signature round-trips. */
-    if (!EVP_DigestVerifyInit(md_ctx_verify, NULL, EVP_sha256(), NULL, pkey)
-        || !EVP_DigestVerifyUpdate(md_ctx_verify, kMsg, sizeof(kMsg))
-        || !EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len)) {
+    if (!TEST_true(EVP_DigestVerifyInit(md_ctx_verify, NULL, EVP_sha256(),
+                                        NULL, pkey))
+            || !TEST_true(EVP_DigestVerifyUpdate(md_ctx_verify,
+                                                 kMsg, sizeof(kMsg)))
+            || !TEST_true(EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len)))
         goto out;
-    }
 
     ret = 1;
 
  out:
-    if (!ret) {
-        ERR_print_errors_fp(stderr);
-    }
-
     EVP_MD_CTX_free(md_ctx);
     EVP_MD_CTX_free(md_ctx_verify);
     EVP_PKEY_free(pkey);
@@ -272,56 +273,44 @@ static int test_EVP_DigestVerifyInit(void)
 {
     int ret = 0;
     EVP_PKEY *pkey = NULL;
-    EVP_MD_CTX *md_ctx;
+    EVP_MD_CTX *md_ctx = NULL;
 
-    md_ctx = EVP_MD_CTX_new();
+    if (!TEST_ptr(md_ctx = EVP_MD_CTX_new())
+            || !TEST_ptr(pkey = load_example_rsa_key()))
+        goto out;
 
-    pkey = load_example_rsa_key();
-    if (pkey == NULL ||
-        !EVP_DigestVerifyInit(md_ctx, NULL, EVP_sha256(), NULL, pkey) ||
-        !EVP_DigestVerifyUpdate(md_ctx, kMsg, sizeof(kMsg)) ||
-        !EVP_DigestVerifyFinal(md_ctx, kSignature, sizeof(kSignature))) {
+    if (!TEST_true(EVP_DigestVerifyInit(md_ctx, NULL, EVP_sha256(), NULL, pkey))
+            || !TEST_true(EVP_DigestVerifyUpdate(md_ctx, kMsg, sizeof(kMsg)))
+            || !TEST_true(EVP_DigestVerifyFinal(md_ctx, kSignature,
+                                                 sizeof(kSignature))))
         goto out;
-    }
     ret = 1;
 
  out:
-    if (!ret) {
-        ERR_print_errors_fp(stderr);
-    }
-
     EVP_MD_CTX_free(md_ctx);
     EVP_PKEY_free(pkey);
-
     return ret;
 }
 
-static int test_d2i_AutoPrivateKey(const unsigned char *input,
-                                   size_t input_len, int expected_id)
+static int test_d2i_AutoPrivateKey(int i)
 {
     int ret = 0;
     const unsigned char *p;
     EVP_PKEY *pkey = NULL;
+    const APK_DATA *ak = &keydata[i];
+    const unsigned char *input = ak->kder;
+    size_t input_len = ak->size;
+    int expected_id = ak->evptype;
 
     p = input;
-    pkey = d2i_AutoPrivateKey(NULL, &p, input_len);
-    if (pkey == NULL || p != input + input_len) {
-        fprintf(stderr, "d2i_AutoPrivateKey failed\n");
-        goto done;
-    }
-
-    if (EVP_PKEY_id(pkey) != expected_id) {
-        fprintf(stderr, "Did not decode expected type\n");
+    if (!TEST_ptr(pkey = d2i_AutoPrivateKey(NULL, &p, input_len))
+            || !TEST_ptr_eq(p, input + input_len)
+            || !TEST_int_eq(EVP_PKEY_id(pkey), expected_id))
         goto done;
-    }
 
     ret = 1;
 
  done:
-    if (!ret) {
-        ERR_print_errors_fp(stderr);
-    }
-
     EVP_PKEY_free(pkey);
     return ret;
 }
@@ -335,18 +324,16 @@ static int test_EVP_PKCS82PKEY(void)
     PKCS8_PRIV_KEY_INFO *p8inf = NULL;
     EVP_PKEY *pkey = NULL;
 
-    p8inf = d2i_PKCS8_PRIV_KEY_INFO(NULL, &derp, sizeof(kExampleBadECKeyDER));
+    if (!TEST_ptr(p8inf = d2i_PKCS8_PRIV_KEY_INFO(NULL, &derp,
+                                              sizeof(kExampleBadECKeyDER))))
+        goto done;
 
-    if (!p8inf || derp != kExampleBadECKeyDER + sizeof(kExampleBadECKeyDER)) {
-        fprintf(stderr, "Failed to parse key\n");
+    if (!TEST_ptr_eq(derp,
+                     kExampleBadECKeyDER + sizeof(kExampleBadECKeyDER)))
         goto done;
-    }
 
-    pkey = EVP_PKCS82PKEY(p8inf);
-    if (pkey) {
-        fprintf(stderr, "Imported invalid EC key\n");
+    if (!TEST_ptr_null(pkey = EVP_PKCS82PKEY(p8inf)))
         goto done;
-    }
 
     ret = 1;
 
@@ -358,52 +345,13 @@ static int test_EVP_PKCS82PKEY(void)
 }
 #endif
 
-int main(void)
+void register_tests(void)
 {
-    CRYPTO_set_mem_debug(1);
-    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
-
-
-    if (!test_EVP_DigestSignInit()) {
-        fprintf(stderr, "EVP_DigestSignInit failed\n");
-        return 1;
-    }
-
-    if (!test_EVP_DigestVerifyInit()) {
-        fprintf(stderr, "EVP_DigestVerifyInit failed\n");
-        return 1;
-    }
-
-    if (!test_d2i_AutoPrivateKey(kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER),
-                                 EVP_PKEY_RSA)) {
-        fprintf(stderr, "d2i_AutoPrivateKey(kExampleRSAKeyDER) failed\n");
-        return 1;
-    }
-
-    if (!test_d2i_AutoPrivateKey
-        (kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8), EVP_PKEY_RSA)) {
-        fprintf(stderr, "d2i_AutoPrivateKey(kExampleRSAKeyPKCS8) failed\n");
-        return 1;
-    }
-
+    ADD_TEST(test_EVP_DigestSignInit);
+    ADD_TEST(test_EVP_DigestVerifyInit);
+    ADD_ALL_TESTS(test_d2i_AutoPrivateKey,
+                  sizeof(keydata) / sizeof(keydata[0]));
 #ifndef OPENSSL_NO_EC
-    if (!test_d2i_AutoPrivateKey(kExampleECKeyDER, sizeof(kExampleECKeyDER),
-                                 EVP_PKEY_EC)) {
-        fprintf(stderr, "d2i_AutoPrivateKey(kExampleECKeyDER) failed\n");
-        return 1;
-    }
-
-    if (!test_EVP_PKCS82PKEY()) {
-        fprintf(stderr, "test_EVP_PKCS82PKEY failed\n");
-        return 1;
-    }
+    ADD_TEST(test_EVP_PKCS82PKEY);
 #endif
-
-#ifndef OPENSSL_NO_CRYPTO_MDEBUG
-    if (CRYPTO_mem_leaks_fp(stderr) <= 0)
-        return 1;
-#endif
-
-    printf("PASS\n");
-    return 0;
 }
index 58fc752..7ee4a08 100644 (file)
  */
 
 #include "../ssl/packet_locl.h"
+#include "testutil.h"
+#include "test_main.h"
 
 #define BUF_LEN 255
 
-static int test_PACKET_remaining(unsigned char buf[BUF_LEN])
+static unsigned char smbuf[BUF_LEN];
+
+static int test_PACKET_remaining()
 {
     PACKET pkt;
 
-    if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
-            ||  PACKET_remaining(&pkt) != BUF_LEN
-            || !PACKET_forward(&pkt, BUF_LEN - 1)
-            ||  PACKET_remaining(&pkt) != 1
-            || !PACKET_forward(&pkt, 1)
-            ||  PACKET_remaining(&pkt) != 0) {
-        fprintf(stderr, "test_PACKET_remaining() failed\n");
+    if (!TEST_true(PACKET_buf_init(&pkt, smbuf, sizeof(smbuf))
+            || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
+            || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 1))
+            || !TEST_size_t_eq(PACKET_remaining(&pkt), 1)
+            || !TEST_true(PACKET_forward(&pkt, 1))
+            || !TEST_size_t_eq(PACKET_remaining(&pkt), 0)))
         return 0;
-    }
 
     return 1;
 }
 
-static int test_PACKET_end(unsigned char buf[BUF_LEN])
+static int test_PACKET_end()
 {
     PACKET pkt;
 
-    if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
-            ||  PACKET_remaining(&pkt) != BUF_LEN
-            ||  PACKET_end(&pkt) != buf + BUF_LEN
-            || !PACKET_forward(&pkt, BUF_LEN - 1)
-            || PACKET_end(&pkt) != buf + BUF_LEN
-            || !PACKET_forward(&pkt, 1)
-            || PACKET_end(&pkt) != buf + BUF_LEN) {
-        fprintf(stderr, "test_PACKET_end() failed\n");
+    if (!TEST_true(PACKET_buf_init(&pkt, smbuf, sizeof(smbuf))
+            || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
+            || !TEST_ptr_ne(PACKET_end(&pkt), smbuf + BUF_LEN)
+            || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 1))
+            || !TEST_ptr_eq(PACKET_end(&pkt), smbuf + BUF_LEN)
+            || !TEST_true(PACKET_forward(&pkt, 1))
+            || !TEST_ptr_eq(PACKET_end(&pkt), smbuf + BUF_LEN)))
         return 0;
-    }
 
     return 1;
 }
 
-static int test_PACKET_get_1(unsigned char buf[BUF_LEN])
+static int test_PACKET_get_1()
 {
     unsigned int i;
     PACKET pkt;
 
-    if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
-            || !PACKET_get_1(&pkt, &i)
-            ||  i != 0x02
-            || !PACKET_forward(&pkt, BUF_LEN - 2)
-            || !PACKET_get_1(&pkt, &i)
-            ||  i != 0xfe
-            ||  PACKET_get_1(&pkt, &i)) {
-        fprintf(stderr, "test_PACKET_get_1() failed\n");
+    if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
+            || !TEST_true(PACKET_get_1(&pkt, &i))
+            || !TEST_uint_eq(i, 0x02)
+            || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 2))
+            || !TEST_true(PACKET_get_1(&pkt, &i))
+            || !TEST_uint_eq(i, 0xfe)
+            || !TEST_false(PACKET_get_1(&pkt, &i)))
         return 0;
-    }
 
     return 1;
 }
 
-static int test_PACKET_get_4(unsigned char buf[BUF_LEN])
+static int test_PACKET_get_4()
 {
     unsigned long i;
     PACKET pkt;
 
-    if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
-            || !PACKET_get_4(&pkt, &i)
-            ||  i != 0x08060402UL
-            || !PACKET_forward(&pkt, BUF_LEN - 8)
-            || !PACKET_get_4(&pkt, &i)
-            ||  i != 0xfefcfaf8UL
-            ||  PACKET_get_4(&pkt, &i)) {
-        fprintf(stderr, "test_PACKET_get_4() failed\n");
+    if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
+            || !TEST_true(PACKET_get_4(&pkt, &i))
+            || !TEST_ulong_eq(i, 0x08060402UL)
+            || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
+            || !TEST_true(PACKET_get_4(&pkt, &i))
+            || !TEST_ulong_eq(i, 0xfefcfaf8UL)
+            || !TEST_false(PACKET_get_4(&pkt, &i)))
         return 0;
-    }
 
     return 1;
 }
 
-static int test_PACKET_get_net_2(unsigned char buf[BUF_LEN])
+static int test_PACKET_get_net_2()
 {
     unsigned int i;
     PACKET pkt;
 
-    if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
-            || !PACKET_get_net_2(&pkt, &i)
-            ||  i != 0x0204
-            || !PACKET_forward(&pkt, BUF_LEN - 4)
-            || !PACKET_get_net_2(&pkt, &i)
-            ||  i != 0xfcfe
-            ||  PACKET_get_net_2(&pkt, &i)) {
-        fprintf(stderr, "test_PACKET_get_net_2() failed\n");
+    if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
+            || !TEST_true(PACKET_get_net_2(&pkt, &i))
+            || !TEST_uint_eq(i, 0x0204)
+            || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 4))
+            || !TEST_true(PACKET_get_net_2(&pkt, &i))
+            || !TEST_uint_eq(i, 0xfcfe)
+            || !TEST_false(PACKET_get_net_2(&pkt, &i)))
         return 0;
-    }
 
     return 1;
 }
 
-static int test_PACKET_get_net_3(unsigned char buf[BUF_LEN])
+static int test_PACKET_get_net_3()
 {
     unsigned long i;
     PACKET pkt;
 
-    if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
-            || !PACKET_get_net_3(&pkt, &i)
-            ||  i != 0x020406UL
-            || !PACKET_forward(&pkt, BUF_LEN - 6)
-            || !PACKET_get_net_3(&pkt, &i)
-            ||  i != 0xfafcfeUL
-            ||  PACKET_get_net_3(&pkt, &i)) {
-        fprintf(stderr, "test_PACKET_get_net_3() failed\n");
+    if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
+            || !TEST_true(PACKET_get_net_3(&pkt, &i))
+            || !TEST_ulong_eq(i, 0x020406UL)
+            || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 6))
+            || !TEST_true(PACKET_get_net_3(&pkt, &i))
+            || !TEST_ulong_eq(i, 0xfafcfeUL)
+            || !TEST_false(PACKET_get_net_3(&pkt, &i)))
         return 0;
-    }
 
     return 1;
 }
 
-static int test_PACKET_get_net_4(unsigned char buf[BUF_LEN])
+static int test_PACKET_get_net_4()
 {
     unsigned long i;
     PACKET pkt;
 
-    if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
-            || !PACKET_get_net_4(&pkt, &i)
-            ||  i != 0x02040608UL
-            || !PACKET_forward(&pkt, BUF_LEN - 8)
-            || !PACKET_get_net_4(&pkt, &i)
-            ||  i != 0xf8fafcfeUL
-            ||  PACKET_get_net_4(&pkt, &i)) {
-        fprintf(stderr, "test_PACKET_get_net_4() failed\n");
+    if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
+            || !TEST_true(PACKET_get_net_4(&pkt, &i))
+            || !TEST_ulong_eq(i, 0x02040608UL)
+            || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
+            || !TEST_true(PACKET_get_net_4(&pkt, &i))
+            || !TEST_ulong_eq(i, 0xf8fafcfeUL)
+            || !TEST_false(PACKET_get_net_4(&pkt, &i)))
         return 0;
-    }
 
     return 1;
 }
 
-static int test_PACKET_get_sub_packet(unsigned char buf[BUF_LEN])
+static int test_PACKET_get_sub_packet()
 {
     PACKET pkt, subpkt;
     unsigned long i;
 
-    if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
-            || !PACKET_get_sub_packet(&pkt, &subpkt, 4)
-            || !PACKET_get_net_4(&subpkt, &i)
-            ||  i != 0x02040608UL
-            ||  PACKET_remaining(&subpkt)
-            || !PACKET_forward(&pkt, BUF_LEN - 8)
-            || !PACKET_get_sub_packet(&pkt, &subpkt, 4)
-            || !PACKET_get_net_4(&subpkt, &i)
-            ||  i != 0xf8fafcfeUL
-            ||  PACKET_remaining(&subpkt)
-            ||  PACKET_get_sub_packet(&pkt, &subpkt, 4)) {
-        fprintf(stderr, "test_PACKET_get_sub_packet() failed\n");
+    if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
+            || !TEST_true(PACKET_get_sub_packet(&pkt, &subpkt, 4))
+            || !TEST_true(PACKET_get_net_4(&subpkt, &i))
+            || !TEST_ulong_eq(i, 0x02040608UL)
+            || !TEST_size_t_eq(PACKET_remaining(&subpkt), 0)
+            || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
+            || !TEST_true(PACKET_get_sub_packet(&pkt, &subpkt, 4))
+            || !TEST_true(PACKET_get_net_4(&subpkt, &i))
+            || !TEST_ulong_eq(i, 0xf8fafcfeUL)
+            || !TEST_size_t_eq(PACKET_remaining(&subpkt), 0)
+            || !TEST_false(PACKET_get_sub_packet(&pkt, &subpkt, 4)))
         return 0;
-    }
 
     return 1;
 }
 
-static int test_PACKET_get_bytes(unsigned char buf[BUF_LEN])
+static int test_PACKET_get_bytes()
 {
     const unsigned char *bytes;
     PACKET pkt;
 
-    if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
-            || !PACKET_get_bytes(&pkt, &bytes, 4)
-            ||  bytes[0] != 2 || bytes[1] != 4
-            ||  bytes[2] != 6 || bytes[3] != 8
-            ||  PACKET_remaining(&pkt) != BUF_LEN -4
-            || !PACKET_forward(&pkt, BUF_LEN - 8)
-            || !PACKET_get_bytes(&pkt, &bytes, 4)
-            ||  bytes[0] != 0xf8 || bytes[1] != 0xfa
-            ||  bytes[2] != 0xfc || bytes[3] != 0xfe
-            ||  PACKET_remaining(&pkt)) {
-        fprintf(stderr, "test_PACKET_get_bytes() failed\n");
+    if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
+            || !TEST_true(PACKET_get_bytes(&pkt, &bytes, 4))
+            || !TEST_uchar_eq(bytes[0], 2)
+            || !TEST_uchar_eq(bytes[1], 4)
+            || !TEST_uchar_eq(bytes[2], 6)
+            || !TEST_uchar_eq(bytes[3], 8)
+            || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN -4)
+            || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
+            || !TEST_true(PACKET_get_bytes(&pkt, &bytes, 4))
+            || !TEST_uchar_eq(bytes[0], 0xf8)
+            || !TEST_uchar_eq(bytes[1], 0xfa)
+            || !TEST_uchar_eq(bytes[2], 0xfc)
+            || !TEST_uchar_eq(bytes[3], 0xfe)
+            || !TEST_false(PACKET_remaining(&pkt)))
         return 0;
-    }
 
     return 1;
 }
 
-static int test_PACKET_copy_bytes(unsigned char buf[BUF_LEN])
+static int test_PACKET_copy_bytes()
 {
     unsigned char bytes[4];
     PACKET pkt;
 
-    if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
-            || !PACKET_copy_bytes(&pkt, bytes, 4)
-            ||  bytes[0] != 2 || bytes[1] != 4
-            ||  bytes[2] != 6 || bytes[3] != 8
-            ||  PACKET_remaining(&pkt) != BUF_LEN - 4
-            || !PACKET_forward(&pkt, BUF_LEN - 8)
-            || !PACKET_copy_bytes(&pkt, bytes, 4)
-            ||  bytes[0] != 0xf8 || bytes[1] != 0xfa
-            ||  bytes[2] != 0xfc || bytes[3] != 0xfe
-            ||  PACKET_remaining(&pkt)) {
-        fprintf(stderr, "test_PACKET_copy_bytes() failed\n");
+    if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
+            || !TEST_true(PACKET_copy_bytes(&pkt, bytes, 4))
+            || !TEST_char_eq(bytes[0], 2)
+            || !TEST_char_eq(bytes[1], 4)
+            || !TEST_char_eq(bytes[2], 6)
+            || !TEST_char_eq(bytes[3], 8)
+            || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN - 4)
+            || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
+            || !TEST_true(PACKET_copy_bytes(&pkt, bytes, 4))
+            || !TEST_uchar_eq(bytes[0], 0xf8)
+            || !TEST_uchar_eq(bytes[1], 0xfa)
+            || !TEST_uchar_eq(bytes[2], 0xfc)
+            || !TEST_uchar_eq(bytes[3], 0xfe)
+            || !TEST_false(PACKET_remaining(&pkt)))
         return 0;
-    }
 
     return 1;
 }
 
-static int test_PACKET_copy_all(unsigned char buf[BUF_LEN])
+static int test_PACKET_copy_all()
 {
     unsigned char tmp[BUF_LEN];
     PACKET pkt;
     size_t len;
 
-    if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
-               || !PACKET_copy_all(&pkt, tmp, BUF_LEN, &len)
-               || len != BUF_LEN
-               || memcmp(buf, tmp, BUF_LEN) != 0
-               || PACKET_remaining(&pkt) != BUF_LEN
-               || PACKET_copy_all(&pkt, tmp, BUF_LEN - 1, &len)) {
-        fprintf(stderr, "test_PACKET_copy_bytes() failed\n");
+    if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
+            || !TEST_true(PACKET_copy_all(&pkt, tmp, BUF_LEN, &len))
+            || !TEST_size_t_eq(len, BUF_LEN)
+            || !TEST_mem_eq(smbuf, BUF_LEN, tmp, BUF_LEN)
+            || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
+            || !TEST_false(PACKET_copy_all(&pkt, tmp, BUF_LEN - 1, &len)))
         return 0;
-    }
 
     return 1;
 }
 
-static int test_PACKET_memdup(unsigned char buf[BUF_LEN])
+static int test_PACKET_memdup()
 {
     unsigned char *data = NULL;
     size_t len;
     PACKET pkt;
-
-    if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
-            || !PACKET_memdup(&pkt, &data, &len)
-            ||  len != BUF_LEN
-            ||  memcmp(data, PACKET_data(&pkt), len)
-            || !PACKET_forward(&pkt, 10)
-            || !PACKET_memdup(&pkt, &data, &len)
-            ||  len != BUF_LEN - 10
-            ||  memcmp(data, PACKET_data(&pkt), len)) {
-        fprintf(stderr, "test_PACKET_memdup() failed\n");
-        OPENSSL_free(data);
-        return 0;
-    }
-
+    int result = 0;
+
+    if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
+            || !TEST_true(PACKET_memdup(&pkt, &data, &len))
+            || !TEST_size_t_eq(len, BUF_LEN)
+            || !TEST_mem_eq(data, len, PACKET_data(&pkt), len)
+            || !TEST_true(PACKET_forward(&pkt, 10))
+            || !TEST_true(PACKET_memdup(&pkt, &data, &len))
+            || !TEST_size_t_eq(len, BUF_LEN - 10)
+            || !TEST_mem_eq(data, len, PACKET_data(&pkt), len))
+        goto end;
+    result = 1;
+end:
     OPENSSL_free(data);
-    return 1;
+    return result;
 }
 
 static int test_PACKET_strndup()
 {
-    char buf[10], buf2[10];
+    char buf1[10], buf2[10];
     char *data = NULL;
     PACKET pkt;
+    int result = 0;
 
-    memset(buf, 'x', 10);
+    memset(buf1, 'x', 10);
     memset(buf2, 'y', 10);
     buf2[5] = '\0';
 
-    if (       !PACKET_buf_init(&pkt, (unsigned char*)buf, 10)
-            || !PACKET_strndup(&pkt, &data)
-            ||  strlen(data) != 10
-            ||  strncmp(data, buf, 10)
-            || !PACKET_buf_init(&pkt, (unsigned char*)buf2, 10)
-            || !PACKET_strndup(&pkt, &data)
-            ||  strlen(data) != 5
-            ||  strcmp(data, buf2)) {
-        fprintf(stderr, "test_PACKET_strndup failed\n");
-        OPENSSL_free(data);
-        return 0;
-    }
-
+    if (!TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf1, 10))
+            || !TEST_true(PACKET_strndup(&pkt, &data))
+            || !TEST_size_t_eq(strlen(data), 10)
+            || !TEST_strn_eq(data, buf1, 10)
+            || !TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf2, 10))
+            || !TEST_true(PACKET_strndup(&pkt, &data))
+            || !TEST_size_t_eq(strlen(data), 5)
+            || !TEST_str_eq(data, buf2))
+        goto end;
+
+    result = 1;
+end:
     OPENSSL_free(data);
-    return 1;
+    return result;
 }
 
 static int test_PACKET_contains_zero_byte()
 {
-    char buf[10], buf2[10];
+    char buf1[10], buf2[10];
     PACKET pkt;
 
-    memset(buf, 'x', 10);
+    memset(buf1, 'x', 10);
     memset(buf2, 'y', 10);
     buf2[5] = '\0';
 
-    if (       !PACKET_buf_init(&pkt, (unsigned char*)buf, 10)
-            ||  PACKET_contains_zero_byte(&pkt)
-            || !PACKET_buf_init(&pkt, (unsigned char*)buf2, 10)
-            || !PACKET_contains_zero_byte(&pkt)) {
-        fprintf(stderr, "test_PACKET_contains_zero_byte failed\n");
+    if (!TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf1, 10))
+            || !TEST_false(PACKET_contains_zero_byte(&pkt))
+            || !TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf2, 10))
+            || !TEST_true(PACKET_contains_zero_byte(&pkt)))
         return 0;
-    }
 
     return 1;
 }
 
-static int test_PACKET_forward(unsigned char buf[BUF_LEN])
+static int test_PACKET_forward()
 {
     const unsigned char *byte;
     PACKET pkt;
 
-    if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
-            || !PACKET_forward(&pkt, 1)
-            || !PACKET_get_bytes(&pkt, &byte, 1)
-            ||  byte[0] != 4
-            || !PACKET_forward(&pkt, BUF_LEN - 3)
-            || !PACKET_get_bytes(&pkt, &byte, 1)
-            ||  byte[0] != 0xfe) {
-        fprintf(stderr, "test_PACKET_forward() failed\n");
+    if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
+            || !TEST_true(PACKET_forward(&pkt, 1))
+            || !TEST_true(PACKET_get_bytes(&pkt, &byte, 1))
+            || !TEST_uchar_eq(byte[0], 4)
+            || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 3))
+            || !TEST_true(PACKET_get_bytes(&pkt, &byte, 1))
+            || !TEST_uchar_eq(byte[0], 0xfe))
         return 0;
-    }
 
     return 1;
 }
 
 static int test_PACKET_buf_init()
 {
-    unsigned char buf[BUF_LEN];
+    unsigned char buf1[BUF_LEN];
     PACKET pkt;
 
     /* Also tests PACKET_remaining() */
-    if (       !PACKET_buf_init(&pkt, buf, 4)
-            ||  PACKET_remaining(&pkt) != 4
-            || !PACKET_buf_init(&pkt, buf, BUF_LEN)
-            ||  PACKET_remaining(&pkt) != BUF_LEN
-            ||  PACKET_buf_init(&pkt, buf, -1)) {
-        fprintf(stderr, "test_PACKET_buf_init() failed\n");
+    if (!TEST_true(PACKET_buf_init(&pkt, buf1, 4))
+            || !TEST_size_t_eq(PACKET_remaining(&pkt), 4)
+            || !TEST_true(PACKET_buf_init(&pkt, buf1, BUF_LEN))
+            || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
+            || !TEST_false(PACKET_buf_init(&pkt, buf1, -1)))
         return 0;
-        }
 
     return 1;
 }
@@ -339,135 +322,119 @@ static int test_PACKET_null_init()
     PACKET pkt;
 
     PACKET_null_init(&pkt);
-    if (       PACKET_remaining(&pkt) != 0
-            || PACKET_forward(&pkt, 1)) {
-        fprintf(stderr, "test_PACKET_null_init() failed\n");
+    if (!TEST_size_t_eq(PACKET_remaining(&pkt), 0)
+            || !TEST_false(PACKET_forward(&pkt, 1)))
         return 0;
-        }
 
     return 1;
 }
 
-static int test_PACKET_equal(unsigned char buf[BUF_LEN])
+static int test_PACKET_equal()
 {
     PACKET pkt;
 
-    if (       !PACKET_buf_init(&pkt, buf, 4)
-            || !PACKET_equal(&pkt, buf, 4)
-            ||  PACKET_equal(&pkt, buf + 1, 4)
-            || !PACKET_buf_init(&pkt, buf, BUF_LEN)
-            || !PACKET_equal(&pkt, buf, BUF_LEN)
-            ||  PACKET_equal(&pkt, buf, BUF_LEN - 1)
-            ||  PACKET_equal(&pkt, buf, BUF_LEN + 1)
-            ||  PACKET_equal(&pkt, buf, 0)) {
-        fprintf(stderr, "test_PACKET_equal() failed\n");
+    if (!TEST_true(PACKET_buf_init(&pkt, smbuf, 4))
+            || !TEST_true(PACKET_equal(&pkt, smbuf, 4))
+            || !TEST_false(PACKET_equal(&pkt, smbuf + 1, 4))
+            || !TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
+            || !TEST_true(PACKET_equal(&pkt, smbuf, BUF_LEN))
+            || !TEST_false(PACKET_equal(&pkt, smbuf, BUF_LEN - 1))
+            || !TEST_false(PACKET_equal(&pkt, smbuf, BUF_LEN + 1))
+            || !TEST_false(PACKET_equal(&pkt, smbuf, 0)))
         return 0;
-        }
 
     return 1;
 }
 
 static int test_PACKET_get_length_prefixed_1()
 {
-    unsigned char buf[BUF_LEN];
+    unsigned char buf1[BUF_LEN];
     const size_t len = 16;
     unsigned int i;
-    PACKET pkt, short_pkt, subpkt;
-
-    buf[0] = len;
-    for (i = 1; i < BUF_LEN; i++) {
-        buf[i] = (i * 2) & 0xff;
-    }
-
-    if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
-            || !PACKET_buf_init(&short_pkt, buf, len)
-            || !PACKET_get_length_prefixed_1(&pkt, &subpkt)
-            ||  PACKET_remaining(&subpkt) != len
-            || !PACKET_get_net_2(&subpkt, &i)
-            ||  i != 0x0204
-            ||  PACKET_get_length_prefixed_1(&short_pkt, &subpkt)
-            ||  PACKET_remaining(&short_pkt) != len) {
-        fprintf(stderr, "test_PACKET_get_length_prefixed_1() failed\n");
+    PACKET pkt, short_pkt, subpkt = {0};
+
+    buf1[0] = len;
+    for (i = 1; i < BUF_LEN; i++)
+        buf1[i] = (i * 2) & 0xff;
+
+    if (!TEST_true(PACKET_buf_init(&pkt, buf1, BUF_LEN))
+            || !TEST_true(PACKET_buf_init(&short_pkt, buf1, len))
+            || !TEST_true(PACKET_get_length_prefixed_1(&pkt, &subpkt))
+            || !TEST_size_t_eq(PACKET_remaining(&subpkt), len)
+            || !TEST_true(PACKET_get_net_2(&subpkt, &i))
+            || !TEST_uint_eq(i, 0x0204)
+            || !TEST_false(PACKET_get_length_prefixed_1(&short_pkt, &subpkt))
+            || !TEST_size_t_eq(PACKET_remaining(&short_pkt), len))
         return 0;
-    }
 
     return 1;
 }
 
 static int test_PACKET_get_length_prefixed_2()
 {
-    unsigned char buf[1024];
+    unsigned char buf1[1024];
     const size_t len = 516;  /* 0x0204 */
     unsigned int i;
-    PACKET pkt, short_pkt, subpkt;
-
-    for (i = 1; i <= 1024; i++) {
-        buf[i-1] = (i * 2) & 0xff;
-    }
-
-    if (       !PACKET_buf_init(&pkt, buf, 1024)
-            || !PACKET_buf_init(&short_pkt, buf, len)
-            || !PACKET_get_length_prefixed_2(&pkt, &subpkt)
-            ||  PACKET_remaining(&subpkt) != len
-            || !PACKET_get_net_2(&subpkt, &i)
-            ||  i != 0x0608
-            ||  PACKET_get_length_prefixed_2(&short_pkt, &subpkt)
-            ||  PACKET_remaining(&short_pkt) != len) {
-        fprintf(stderr, "test_PACKET_get_length_prefixed_2() failed\n");
+    PACKET pkt, short_pkt, subpkt = {0};
+
+    for (i = 1; i <= 1024; i++)
+        buf1[i - 1] = (i * 2) & 0xff;
+
+    if (!TEST_true(PACKET_buf_init(&pkt, buf1, 1024))
+            || !TEST_true(PACKET_buf_init(&short_pkt, buf1, len))
+            || !TEST_true(PACKET_get_length_prefixed_2(&pkt, &subpkt))
+            || !TEST_size_t_eq(PACKET_remaining(&subpkt), len)
+            || !TEST_true(PACKET_get_net_2(&subpkt, &i))
+            || !TEST_uint_eq(i, 0x0608)
+            || !TEST_false(PACKET_get_length_prefixed_2(&short_pkt, &subpkt))
+            || !TEST_size_t_eq(PACKET_remaining(&short_pkt), len))
         return 0;
-    }
 
     return 1;
 }
 
 static int test_PACKET_get_length_prefixed_3()
 {
-    unsigned char buf[1024];
+    unsigned char buf1[1024];
     const size_t len = 516;  /* 0x000204 */
     unsigned int i;
-    PACKET pkt, short_pkt, subpkt;
-
-    for (i = 0; i < 1024; i++) {
-        buf[i] = (i * 2) & 0xff;
-    }
-
-    if (       !PACKET_buf_init(&pkt, buf, 1024)
-            || !PACKET_buf_init(&short_pkt, buf, len)
-            || !PACKET_get_length_prefixed_3(&pkt, &subpkt)
-            ||  PACKET_remaining(&subpkt) != len
-            || !PACKET_get_net_2(&subpkt, &i)
-            ||  i != 0x0608
-            ||  PACKET_get_length_prefixed_3(&short_pkt, &subpkt)
-            ||  PACKET_remaining(&short_pkt) != len) {
-        fprintf(stderr, "test_PACKET_get_length_prefixed_3() failed\n");
+    PACKET pkt, short_pkt, subpkt = {0};
+
+    for (i = 0; i < 1024; i++)
+        buf1[i] = (i * 2) & 0xff;
+
+    if (!TEST_true(PACKET_buf_init(&pkt, buf1, 1024))
+            || !TEST_true(PACKET_buf_init(&short_pkt, buf1, len))
+            || !TEST_true(PACKET_get_length_prefixed_3(&pkt, &subpkt))
+            || !TEST_size_t_eq(PACKET_remaining(&subpkt), len)
+            || !TEST_true(PACKET_get_net_2(&subpkt, &i))
+            || !TEST_uint_eq(i, 0x0608)
+            || !TEST_false(PACKET_get_length_prefixed_3(&short_pkt, &subpkt))
+            || !TEST_size_t_eq(PACKET_remaining(&short_pkt), len))
         return 0;
-    }
 
     return 1;
 }
 
 static int test_PACKET_as_length_prefixed_1()
 {
-    unsigned char buf[BUF_LEN];
+    unsigned char buf1[BUF_LEN];
     const size_t len = 16;
     unsigned int i;
     PACKET pkt, exact_pkt, subpkt;
 
-    buf[0] = len;
-    for (i = 1; i < BUF_LEN; i++) {
-        buf[i] = (i * 2) & 0xff;
-    }
-
-    if (       !PACKET_buf_init(&pkt, buf, BUF_LEN)
-            || !PACKET_buf_init(&exact_pkt, buf, len + 1)
-            ||  PACKET_as_length_prefixed_1(&pkt, &subpkt)
-            ||  PACKET_remaining(&pkt) != BUF_LEN
-            || !PACKET_as_length_prefixed_1(&exact_pkt, &subpkt)
-            ||  PACKET_remaining(&exact_pkt) != 0
-            ||  PACKET_remaining(&subpkt) != len) {
-        fprintf(stderr, "test_PACKET_as_length_prefixed_1() failed\n");
+    buf1[0] = len;
+    for (i = 1; i < BUF_LEN; i++)
+        buf1[i] = (i * 2) & 0xff;
+
+    if (!TEST_true(PACKET_buf_init(&pkt, buf1, BUF_LEN))
+            || !TEST_true(PACKET_buf_init(&exact_pkt, buf1, len + 1))
+            || !TEST_false(PACKET_as_length_prefixed_1(&pkt, &subpkt))
+            || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
+            || !TEST_true(PACKET_as_length_prefixed_1(&exact_pkt, &subpkt)
+            || !TEST_size_t_eq(PACKET_remaining(&exact_pkt), 0)
+            || !TEST_size_t_eq(PACKET_remaining(&subpkt), len)))
         return 0;
-    }
 
     return 1;
 }
@@ -479,59 +446,49 @@ static int test_PACKET_as_length_prefixed_2()
     unsigned int i;
     PACKET pkt, exact_pkt, subpkt;
 
-    for (i = 1; i <= 1024; i++) {
+    for (i = 1; i <= 1024; i++)
         buf[i-1] = (i * 2) & 0xff;
-    }
-
-    if (       !PACKET_buf_init(&pkt, buf, 1024)
-            || !PACKET_buf_init(&exact_pkt, buf, len + 2)
-            ||  PACKET_as_length_prefixed_2(&pkt, &subpkt)
-            ||  PACKET_remaining(&pkt) != 1024
-            || !PACKET_as_length_prefixed_2(&exact_pkt, &subpkt)
-            ||  PACKET_remaining(&exact_pkt) != 0
-            ||  PACKET_remaining(&subpkt) != len) {
-        fprintf(stderr, "test_PACKET_as_length_prefixed_2() failed\n");
+
+    if (!TEST_true(PACKET_buf_init(&pkt, buf, 1024))
+            || !TEST_true(PACKET_buf_init(&exact_pkt, buf, len + 2))
+            || !TEST_false(PACKET_as_length_prefixed_2(&pkt, &subpkt))
+            || !TEST_size_t_eq(PACKET_remaining(&pkt), 1024)
+            || !TEST_true(PACKET_as_length_prefixed_2(&exact_pkt, &subpkt))
+            || !TEST_size_t_eq(PACKET_remaining(&exact_pkt), 0)
+            || !TEST_size_t_eq(PACKET_remaining(&subpkt), len))
         return 0;
-    }
 
     return 1;
 }
 
-int main(int argc, char **argv)
+void register_tests(void)
 {
-    unsigned char buf[BUF_LEN];
     unsigned int i;
 
-    for (i=1; i<=BUF_LEN; i++) {
-        buf[i-1] = (i * 2) & 0xff;
-    }
-    i = 0;
-
-    if (       !test_PACKET_buf_init()
-            || !test_PACKET_null_init()
-            || !test_PACKET_remaining(buf)
-            || !test_PACKET_end(buf)
-            || !test_PACKET_equal(buf)
-            || !test_PACKET_get_1(buf)
-            || !test_PACKET_get_4(buf)
-            || !test_PACKET_get_net_2(buf)
-            || !test_PACKET_get_net_3(buf)
-            || !test_PACKET_get_net_4(buf)
-            || !test_PACKET_get_sub_packet(buf)
-            || !test_PACKET_get_bytes(buf)
-            || !test_PACKET_copy_bytes(buf)
-            || !test_PACKET_copy_all(buf)
-            || !test_PACKET_memdup(buf)
-            || !test_PACKET_strndup()
-            || !test_PACKET_contains_zero_byte()
-            || !test_PACKET_forward(buf)
-            || !test_PACKET_get_length_prefixed_1()
-            || !test_PACKET_get_length_prefixed_2()
-            || !test_PACKET_get_length_prefixed_3()
-            || !test_PACKET_as_length_prefixed_1()
-            || !test_PACKET_as_length_prefixed_2()) {
-        return 1;
-    }
-    printf("PASS\n");
-    return 0;
+    for (i = 1; i <= BUF_LEN; i++)
+        smbuf[i - 1] = (i * 2) & 0xff;
+
+    ADD_TEST(test_PACKET_buf_init);
+    ADD_TEST(test_PACKET_null_init);
+    ADD_TEST(test_PACKET_remaining);
+    ADD_TEST(test_PACKET_end);
+    ADD_TEST(test_PACKET_equal);
+    ADD_TEST(test_PACKET_get_1);
+    ADD_TEST(test_PACKET_get_4);
+    ADD_TEST(test_PACKET_get_net_2);
+    ADD_TEST(test_PACKET_get_net_3);
+    ADD_TEST(test_PACKET_get_net_4);
+    ADD_TEST(test_PACKET_get_sub_packet);
+    ADD_TEST(test_PACKET_get_bytes);
+    ADD_TEST(test_PACKET_copy_bytes);
+    ADD_TEST(test_PACKET_copy_all);
+    ADD_TEST(test_PACKET_memdup);
+    ADD_TEST(test_PACKET_strndup);
+    ADD_TEST(test_PACKET_contains_zero_byte);
+    ADD_TEST(test_PACKET_forward);
+    ADD_TEST(test_PACKET_get_length_prefixed_1);
+    ADD_TEST(test_PACKET_get_length_prefixed_2);
+    ADD_TEST(test_PACKET_get_length_prefixed_3);
+    ADD_TEST(test_PACKET_as_length_prefixed_1);
+    ADD_TEST(test_PACKET_as_length_prefixed_2);
 }
index 3d2824c..ae98e10 100644 (file)
@@ -363,6 +363,38 @@ int test_str_ne(const char *file, int line, const char *st1, const char *st2,
     return 1;
 }
 
+int test_strn_eq(const char *file, int line, const char *st1, const char *st2,
+                 const char *s1, const char *s2, size_t len)
+{
+    int prec = (int)len;
+
+    if (s1 == NULL && s2 == NULL)
+      return 1;
+    if (s1 == NULL || s2 == NULL || strncmp(s1, s2, len) != 0) {
+        test_fail_message(NULL, file, line, "string", "%.s [%.*s] == %s [%.*s]",
+                          st1, prec, print_string_maybe_null(s1),
+                          st2, prec, print_string_maybe_null(s2));
+        return 0;
+    }
+    return 1;
+}
+
+int test_strn_ne(const char *file, int line, const char *st1, const char *st2,
+                 const char *s1, const char *s2, size_t len)
+{
+    int prec = (int)len;
+
+    if ((s1 == NULL) ^ (s2 == NULL))
+      return 1;
+    if (s1 == NULL || strncmp(s1, s2, len) == 0) {
+        test_fail_message(NULL, file, line, "string", "%s [%.*s] != %s [%.*s]",
+                          st1, prec, print_string_maybe_null(s1),
+                          st2, prec, print_string_maybe_null(s2));
+        return 0;
+    }
+    return 1;
+}
+
 /*
  * We could use OPENSSL_buf2hexstr() to do this but trying to allocate memory
  * in a failure state isn't generally a great idea.
index 0631a8b..e7478a8 100644 (file)
@@ -189,6 +189,14 @@ int test_ptr_null(const char *file, int line, const char *s, const void *p);
 DECLARE_COMPARISON(char *, str, eq)
 DECLARE_COMPARISON(char *, str, ne)
 
+/*
+ * Same as above, but for strncmp.
+ */
+int test_strn_eq(const char *file, int line, const char *, const char *,
+                 const char *a, const char *b, size_t s);
+int test_strn_ne(const char *file, int line, const char *, const char *,
+                 const char *a, const char *b, size_t s);
+
 /*
  * Equality test for memory blocks where NULL is a legitimate value.
  * These calls return 1 if the two memory blocks compare true.
@@ -293,6 +301,8 @@ void test_info_c90(const char *desc, ...) PRINTF_FORMAT(1, 2);
 
 # define TEST_str_eq(a, b)    test_str_eq(__FILE__, __LINE__, #a, #b, a, b)
 # define TEST_str_ne(a, b)    test_str_ne(__FILE__, __LINE__, #a, #b, a, b)
+# define TEST_strn_eq(a, b, n) test_strn_eq(__FILE__, __LINE__, #a, #b, a, b, n)
+# define TEST_strn_ne(a, b, n) test_strn_ne(__FILE__, __LINE__, #a, #b, a, b, n)
 
 # define TEST_mem_eq(a, m, b, n) test_mem_eq(__FILE__, __LINE__, #a, #b, a, m, b, n)
 # define TEST_mem_ne(a, m, b, n) test_mem_ne(__FILE__, __LINE__, #a, #b, a, m, b, n)
index 3ab293e..2546ef3 100644 (file)
 #include "testutil.h"
 #include "test_main_custom.h"
 
-const static unsigned char simple1 = 0xff;
+const static unsigned char simple1[] = { 0xff };
 const static unsigned char simple2[] = { 0x01, 0xff };
 const static unsigned char simple3[] = { 0x00, 0x00, 0x00, 0x01, 0xff };
 const static unsigned char nestedsub[] = { 0x03, 0xff, 0x01, 0xff };
 const static unsigned char seqsub[] = { 0x01, 0xff, 0x01, 0xff };
-const static unsigned char empty = 0x00;
+const static unsigned char empty[] = { 0x00 };
 const static unsigned char alloc[] = { 0x02, 0xfe, 0xff };
 const static unsigned char submem[] = { 0x03, 0x02, 0xfe, 0xff };
 const static unsigned char fixed[] = { 0xff, 0xff, 0xff };
 
 static BUF_MEM *buf;
 
-static void testfail(const char *msg, WPACKET *pkt)
+static int cleanup(WPACKET *pkt)
 {
-    fprintf(stderr, "%s", msg);
     WPACKET_cleanup(pkt);
+    return 0;
 }
 
 static int test_WPACKET_init(void)
@@ -38,90 +38,71 @@ static int test_WPACKET_init(void)
     size_t written;
     unsigned char sbuf[3];
 
-    if (!WPACKET_init(&pkt, buf)
-            || !WPACKET_put_bytes_u8(&pkt, 0xff)
+    if (!TEST_true(WPACKET_init(&pkt, buf))
+            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
                 /* Closing a top level WPACKET should fail */
-            ||  WPACKET_close(&pkt)
+            || !TEST_false(WPACKET_close(&pkt))
                 /* Finishing a top level WPACKET should succeed */
-            || !WPACKET_finish(&pkt)
+            || !TEST_true(WPACKET_finish(&pkt))
                 /*
                  * Can't call close or finish on a WPACKET that's already
                  * finished.
                  */
-            ||  WPACKET_close(&pkt)
-            ||  WPACKET_finish(&pkt)
-            || !WPACKET_get_total_written(&pkt, &written)
-            ||  written != sizeof(simple1)
-            ||  memcmp(buf->data, &simple1, written) != 0) {
-        testfail("test_WPACKET_init():1 failed\n", &pkt);
-        return 0;
-    }
+            || !TEST_false(WPACKET_close(&pkt))
+            || !TEST_false(WPACKET_finish(&pkt))
+            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
+            || !TEST_mem_eq(buf->data, written, simple1, sizeof(simple1)))
+        return cleanup(&pkt);
 
     /* Now try with a one byte length prefix */
-    if (!WPACKET_init_len(&pkt, buf, 1)
-            || !WPACKET_put_bytes_u8(&pkt, 0xff)
-            || !WPACKET_finish(&pkt)
-            || !WPACKET_get_total_written(&pkt, &written)
-            ||  written != sizeof(simple2)
-            ||  memcmp(buf->data, &simple2, written) != 0) {
-        testfail("test_WPACKET_init():2 failed\n", &pkt);
-        return 0;
-    }
+    if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
+            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
+            || !TEST_true(WPACKET_finish(&pkt))
+            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
+            || !TEST_mem_eq(buf->data, written, simple2, sizeof(simple2)))
+        return cleanup(&pkt);
 
     /* And a longer length prefix */
-    if (!WPACKET_init_len(&pkt, buf, 4)
-            || !WPACKET_put_bytes_u8(&pkt, 0xff)
-            || !WPACKET_finish(&pkt)
-            || !WPACKET_get_total_written(&pkt, &written)
-            ||  written != sizeof(simple3)
-            ||  memcmp(buf->data, &simple3, written) != 0) {
-        testfail("test_WPACKET_init():3 failed\n", &pkt);
-        return 0;
-    }
-
-    if (!WPACKET_init_len(&pkt, buf, 1)) {
-        testfail("test_WPACKET_init():4 failed\n", &pkt);
-        return 0;
-    }
+    if (!TEST_true(WPACKET_init_len(&pkt, buf, 4))
+            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
+            || !TEST_true(WPACKET_finish(&pkt))
+            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
+            || !TEST_mem_eq(buf->data, written, simple3, sizeof(simple3)))
+        return cleanup(&pkt);
+
+    if (!TEST_true(WPACKET_init_len(&pkt, buf, 1)))
+        return cleanup(&pkt);
     for (i = 1; i < 257; i++) {
         /*
          * Putting more bytes in than fit for the size of the length prefix
          * should fail
          */
-        if ((!WPACKET_put_bytes_u8(&pkt, 0xff)) == (i != 256)) {
-            testfail("test_WPACKET_init():4 failed\n", &pkt);
-            return 0;
-        }
-    }
-    if (!WPACKET_finish(&pkt)) {
-        testfail("test_WPACKET_init():4 failed\n", &pkt);
-        return 0;
+        if (!TEST_int_eq(WPACKET_put_bytes_u8(&pkt, 0xff), i < 256))
+            return cleanup(&pkt);
     }
+    if (!TEST_true(WPACKET_finish(&pkt)))
+        return cleanup(&pkt);
 
     /* Test initialising from a fixed size buffer */
-    if (!WPACKET_init_static_len(&pkt, sbuf, sizeof(sbuf), 0)
+    if (!TEST_true(WPACKET_init_static_len(&pkt, sbuf, sizeof(sbuf), 0))
                 /* Adding 3 bytes should succeed */
-            || !WPACKET_put_bytes_u24(&pkt, 0xffffff)
+            || !TEST_true(WPACKET_put_bytes_u24(&pkt, 0xffffff))
                 /* Adding 1 more byte should fail */
-            ||  WPACKET_put_bytes_u8(&pkt, 0xff)
+            || !TEST_false(WPACKET_put_bytes_u8(&pkt, 0xff))
                 /* Finishing the top level WPACKET should succeed */
-            || !WPACKET_finish(&pkt)
-            || !WPACKET_get_total_written(&pkt, &written)
-            ||  written != sizeof(fixed)
-            || memcmp(sbuf, fixed, sizeof(sbuf)) != 0
+            || !TEST_true(WPACKET_finish(&pkt))
+            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
+            || !TEST_mem_eq(sbuf, written, fixed, sizeof(sbuf))
                 /* Initialise with 1 len byte */
-            || !WPACKET_init_static_len(&pkt, sbuf, sizeof(sbuf), 1)
+            || !TEST_true(WPACKET_init_static_len(&pkt, sbuf, sizeof(sbuf), 1))
                 /* Adding 2 bytes should succeed */
-            || !WPACKET_put_bytes_u16(&pkt, 0xfeff)
+            || !TEST_true(WPACKET_put_bytes_u16(&pkt, 0xfeff))
                 /* Adding 1 more byte should fail */
-            ||  WPACKET_put_bytes_u8(&pkt, 0xff)
-            || !WPACKET_finish(&pkt)
-            || !WPACKET_get_total_written(&pkt, &written)
-            ||  written != sizeof(alloc)
-            ||  memcmp(sbuf, alloc, written) != 0) {
-        testfail("test_WPACKET_init():5 failed\n", &pkt);
-        return 0;
-    }
+            || !TEST_false(WPACKET_put_bytes_u8(&pkt, 0xff))
+            || !TEST_true(WPACKET_finish(&pkt))
+            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
+            || !TEST_mem_eq(sbuf, written, alloc, sizeof(alloc)))
+        return cleanup(&pkt);
 
     return 1;
 }
@@ -131,53 +112,44 @@ static int test_WPACKET_set_max_size(void)
     WPACKET pkt;
     size_t written;
 
-    if (!WPACKET_init(&pkt, buf)
+    if (!TEST_true(WPACKET_init(&pkt, buf))
                 /*
                  * No previous lenbytes set so we should be ok to set the max
                  * possible max size
                  */
-            || !WPACKET_set_max_size(&pkt, SIZE_MAX)
+            || !TEST_true(WPACKET_set_max_size(&pkt, SIZE_MAX))
                 /* We should be able to set it smaller too */
-            || !WPACKET_set_max_size(&pkt, SIZE_MAX -1)
+            || !TEST_true(WPACKET_set_max_size(&pkt, SIZE_MAX -1))
                 /* And setting it bigger again should be ok */
-            || !WPACKET_set_max_size(&pkt, SIZE_MAX)
-            || !WPACKET_finish(&pkt)) {
-        testfail("test_WPACKET_set_max_size():1 failed\n", &pkt);
-        return 0;
-    }
+            || !TEST_true(WPACKET_set_max_size(&pkt, SIZE_MAX))
+            || !TEST_true(WPACKET_finish(&pkt)))
+        return cleanup(&pkt);
 
-    if (!WPACKET_init_len(&pkt, buf, 1)
+    if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
                 /*
                  * Should fail because we already consumed 1 byte with the
                  * length
                  */
-            ||  WPACKET_set_max_size(&pkt, 0)
+            || !TEST_false(WPACKET_set_max_size(&pkt, 0))
                 /*
                  * Max size can't be bigger than biggest that will fit in
                  * lenbytes
                  */
-            ||  WPACKET_set_max_size(&pkt, 0x0101)
+            || !TEST_false(WPACKET_set_max_size(&pkt, 0x0101))
                 /* It can be the same as the maximum possible size */
-            || !WPACKET_set_max_size(&pkt, 0x0100)
+            || !TEST_true(WPACKET_set_max_size(&pkt, 0x0100))
                 /* Or it can be less */
-            || !WPACKET_set_max_size(&pkt, 0x01)
-                /*
-                 * Should fail because packet is already filled
-                 */
-            ||  WPACKET_put_bytes_u8(&pkt, 0xff)
-                /*
-                 * You can't put in more bytes than max size
-                 */
-            || !WPACKET_set_max_size(&pkt, 0x02)
-            || !WPACKET_put_bytes_u8(&pkt, 0xff)
-            ||  WPACKET_put_bytes_u8(&pkt, 0xff)
-            || !WPACKET_finish(&pkt)
-            || !WPACKET_get_total_written(&pkt, &written)
-            ||  written != sizeof(simple2)
-            ||  memcmp(buf->data, &simple2, written) != 0) {
-        testfail("test_WPACKET_set_max_size():2 failed\n", &pkt);
-        return 0;
-    }
+            || !TEST_true(WPACKET_set_max_size(&pkt, 0x01))
+                /* Should fail because packet is already filled */
+            || !TEST_false(WPACKET_put_bytes_u8(&pkt, 0xff))
+                /* You can't put in more bytes than max size */
+            || !TEST_true(WPACKET_set_max_size(&pkt, 0x02))
+            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
+            || !TEST_false(WPACKET_put_bytes_u8(&pkt, 0xff))
+            || !TEST_true(WPACKET_finish(&pkt))
+            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
+            || !TEST_mem_eq(buf->data, written, simple2, sizeof(simple2)))
+        return cleanup(&pkt);
 
     return 1;
 }
@@ -188,92 +160,77 @@ static int test_WPACKET_start_sub_packet(void)
     size_t written;
     size_t len;
 
-    if (!WPACKET_init(&pkt, buf)
-            || !WPACKET_start_sub_packet(&pkt)
-            || !WPACKET_put_bytes_u8(&pkt, 0xff)
+    if (!TEST_true(WPACKET_init(&pkt, buf))
+            || !TEST_true(WPACKET_start_sub_packet(&pkt))
+            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
                 /* Can't finish because we have a sub packet */
-            ||  WPACKET_finish(&pkt)
-            || !WPACKET_close(&pkt)
+            || !TEST_false(WPACKET_finish(&pkt))
+            || !TEST_true(WPACKET_close(&pkt))
                 /* Sub packet is closed so can't close again */
-            ||  WPACKET_close(&pkt)
+            || !TEST_false(WPACKET_close(&pkt))
                 /* Now a top level so finish should succeed */
-            || !WPACKET_finish(&pkt)
-            || !WPACKET_get_total_written(&pkt, &written)
-            ||  written != sizeof(simple1)
-            ||  memcmp(buf->data, &simple1, written) != 0) {
-        testfail("test_WPACKET_start_sub_packet():1 failed\n", &pkt);
-        return 0;
-    }
+            || !TEST_true(WPACKET_finish(&pkt))
+            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
+            || !TEST_mem_eq(buf->data, written, simple1, sizeof(simple1)))
+        return cleanup(&pkt);
 
    /* Single sub-packet with length prefix */
-    if (!WPACKET_init(&pkt, buf)
-            || !WPACKET_start_sub_packet_u8(&pkt)
-            || !WPACKET_put_bytes_u8(&pkt, 0xff)
-            || !WPACKET_close(&pkt)
-            || !WPACKET_finish(&pkt)
-            || !WPACKET_get_total_written(&pkt, &written)
-            ||  written != sizeof(simple2)
-            ||  memcmp(buf->data, &simple2, written) != 0) {
-        testfail("test_WPACKET_start_sub_packet():2 failed\n", &pkt);
-        return 0;
-    }
+    if (!TEST_true(WPACKET_init(&pkt, buf))
+            || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
+            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
+            || !TEST_true(WPACKET_close(&pkt))
+            || !TEST_true(WPACKET_finish(&pkt))
+            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
+            || !TEST_mem_eq(buf->data, written, simple2, sizeof(simple2)))
+        return cleanup(&pkt);
 
     /* Nested sub-packets with length prefixes */
-    if (!WPACKET_init(&pkt, buf)
-            || !WPACKET_start_sub_packet_u8(&pkt)
-            || !WPACKET_put_bytes_u8(&pkt, 0xff)
-            || !WPACKET_start_sub_packet_u8(&pkt)
-            || !WPACKET_put_bytes_u8(&pkt, 0xff)
-            || !WPACKET_get_length(&pkt, &len)
-            || len != 1
-            || !WPACKET_close(&pkt)
-            || !WPACKET_get_length(&pkt, &len)
-            || len != 3
-            || !WPACKET_close(&pkt)
-            || !WPACKET_finish(&pkt)
-            || !WPACKET_get_total_written(&pkt, &written)
-            ||  written != sizeof(nestedsub)
-            ||  memcmp(buf->data, &nestedsub, written) != 0) {
-        testfail("test_WPACKET_start_sub_packet():3 failed\n", &pkt);
-        return 0;
-    }
+    if (!TEST_true(WPACKET_init(&pkt, buf))
+            || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
+            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
+            || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
+            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
+            || !TEST_true(WPACKET_get_length(&pkt, &len))
+            || !TEST_size_t_eq(len, 1)
+            || !TEST_true(WPACKET_close(&pkt))
+            || !TEST_true(WPACKET_get_length(&pkt, &len))
+            || !TEST_size_t_eq(len, 3)
+            || !TEST_true(WPACKET_close(&pkt))
+            || !TEST_true(WPACKET_finish(&pkt))
+            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
+            || !TEST_mem_eq(buf->data, written, nestedsub, sizeof(nestedsub)))
+        return cleanup(&pkt);
 
     /* Sequential sub-packets with length prefixes */
-    if (!WPACKET_init(&pkt, buf)
-            || !WPACKET_start_sub_packet_u8(&pkt)
-            || !WPACKET_put_bytes_u8(&pkt, 0xff)
-            || !WPACKET_close(&pkt)
-            || !WPACKET_start_sub_packet_u8(&pkt)
-            || !WPACKET_put_bytes_u8(&pkt, 0xff)
-            || !WPACKET_close(&pkt)
-            || !WPACKET_finish(&pkt)
-            || !WPACKET_get_total_written(&pkt, &written)
-            ||  written != sizeof(seqsub)
-            ||  memcmp(buf->data, &seqsub, written) != 0) {
-        testfail("test_WPACKET_start_sub_packet():4 failed\n", &pkt);
-        return 0;
-    }
+    if (!TEST_true(WPACKET_init(&pkt, buf))
+            || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
+            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
+            || !TEST_true(WPACKET_close(&pkt))
+            || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
+            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
+            || !TEST_true(WPACKET_close(&pkt))
+            || !TEST_true(WPACKET_finish(&pkt))
+            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
+            || !TEST_mem_eq(buf->data, written, seqsub, sizeof(seqsub)))
+        return cleanup(&pkt);
 
     /* Nested sub-packets with lengths filled before finish */
-    if (!WPACKET_init(&pkt, buf)
-            || !WPACKET_start_sub_packet_u8(&pkt)
-            || !WPACKET_put_bytes_u8(&pkt, 0xff)
-            || !WPACKET_start_sub_packet_u8(&pkt)
-            || !WPACKET_put_bytes_u8(&pkt, 0xff)
-            || !WPACKET_get_length(&pkt, &len)
-            || len != 1
-            || !WPACKET_close(&pkt)
-            || !WPACKET_get_length(&pkt, &len)
-            || len != 3
-            || !WPACKET_close(&pkt)
-            || !WPACKET_fill_lengths(&pkt)
-            || !WPACKET_get_total_written(&pkt, &written)
-            ||  written != sizeof(nestedsub)
-            ||  memcmp(buf->data, &nestedsub, written) != 0
-            || !WPACKET_finish(&pkt)) {
-        testfail("test_WPACKET_start_sub_packet():5 failed\n", &pkt);
-        return 0;
-    }
+    if (!TEST_true(WPACKET_init(&pkt, buf))
+            || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
+            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
+            || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
+            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
+            || !TEST_true(WPACKET_get_length(&pkt, &len))
+            || !TEST_size_t_eq(len, 1)
+            || !TEST_true(WPACKET_close(&pkt))
+            || !TEST_true(WPACKET_get_length(&pkt, &len))
+            || !TEST_size_t_eq(len, 3)
+            || !TEST_true(WPACKET_close(&pkt))
+            || !TEST_true(WPACKET_fill_lengths(&pkt))
+            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
+            || !TEST_mem_eq(buf->data, written, nestedsub, sizeof(nestedsub))
+            || !TEST_true(WPACKET_finish(&pkt)))
+        return cleanup(&pkt);
 
     return 1;
 }
@@ -285,71 +242,57 @@ static int test_WPACKET_set_flags(void)
     size_t written;
 
     /* Set packet to be non-zero length */
-    if (!WPACKET_init(&pkt, buf)
-            || !WPACKET_set_flags(&pkt, WPACKET_FLAGS_NON_ZERO_LENGTH)
+    if (!TEST_true(WPACKET_init(&pkt, buf))
+            || !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_NON_ZERO_LENGTH))
                 /* Should fail because of zero length */
-            ||  WPACKET_finish(&pkt)
-            || !WPACKET_put_bytes_u8(&pkt, 0xff)
-            || !WPACKET_finish(&pkt)
-            || !WPACKET_get_total_written(&pkt, &written)
-            ||  written != sizeof(simple1)
-            ||  memcmp(buf->data, &simple1, written) != 0) {
-        testfail("test_WPACKET_set_flags():1 failed\n", &pkt);
-        return 0;
-    }
+            || !TEST_false(WPACKET_finish(&pkt))
+            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
+            || !TEST_true(WPACKET_finish(&pkt))
+            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
+            || !TEST_mem_eq(buf->data, written, simple1, sizeof(simple1)))
+        return cleanup(&pkt);
 
     /* Repeat above test in a sub-packet */
-    if (!WPACKET_init(&pkt, buf)
-            || !WPACKET_start_sub_packet(&pkt)
-            || !WPACKET_set_flags(&pkt, WPACKET_FLAGS_NON_ZERO_LENGTH)
+    if (!TEST_true(WPACKET_init(&pkt, buf))
+            || !TEST_true(WPACKET_start_sub_packet(&pkt))
+            || !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_NON_ZERO_LENGTH))
                 /* Should fail because of zero length */
-            ||  WPACKET_close(&pkt)
-            || !WPACKET_put_bytes_u8(&pkt, 0xff)
-            || !WPACKET_close(&pkt)
-            || !WPACKET_finish(&pkt)
-            || !WPACKET_get_total_written(&pkt, &written)
-            ||  written != sizeof(simple1)
-            ||  memcmp(buf->data, &simple1, written) != 0) {
-        testfail("test_WPACKET_set_flags():2 failed\n", &pkt);
-        return 0;
-    }
+            || !TEST_false(WPACKET_close(&pkt))
+            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
+            || !TEST_true(WPACKET_close(&pkt))
+            || !TEST_true(WPACKET_finish(&pkt))
+            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
+            || !TEST_mem_eq(buf->data, written, simple1, sizeof(simple1)))
+        return cleanup(&pkt);
 
     /* Set packet to abandon non-zero length */
-    if (!WPACKET_init_len(&pkt, buf, 1)
-            || !WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH)
-            || !WPACKET_finish(&pkt)
-            || !WPACKET_get_total_written(&pkt, &written)
-            ||  written != 0) {
-        testfail("test_WPACKET_set_flags():3 failed\n", &pkt);
-        return 0;
-    }
+    if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
+            || !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))
+            || !TEST_true(WPACKET_finish(&pkt))
+            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
+            || !TEST_size_t_eq(written, 0))
+        return cleanup(&pkt);
 
     /* Repeat above test but only abandon a sub-packet */
-    if (!WPACKET_init_len(&pkt, buf, 1)
-            || !WPACKET_start_sub_packet_u8(&pkt)
-            || !WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH)
-            || !WPACKET_close(&pkt)
-            || !WPACKET_finish(&pkt)
-            || !WPACKET_get_total_written(&pkt, &written)
-            ||  written != sizeof(empty)
-            ||  memcmp(buf->data, &empty, written) != 0) {
-        testfail("test_WPACKET_set_flags():4 failed\n", &pkt);
-        return 0;
-    }
+    if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
+            || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
+            || !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))
+            || !TEST_true(WPACKET_close(&pkt))
+            || !TEST_true(WPACKET_finish(&pkt))
+            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
+            || !TEST_mem_eq(buf->data, written, empty, sizeof(empty)))
+        return cleanup(&pkt);
 
     /* And repeat with a non empty sub-packet */
-    if (!WPACKET_init(&pkt, buf)
-            || !WPACKET_start_sub_packet_u8(&pkt)
-            || !WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH)
-            || !WPACKET_put_bytes_u8(&pkt, 0xff)
-            || !WPACKET_close(&pkt)
-            || !WPACKET_finish(&pkt)
-            || !WPACKET_get_total_written(&pkt, &written)
-            ||  written != sizeof(simple2)
-            ||  memcmp(buf->data, &simple2, written) != 0) {
-        testfail("test_WPACKET_set_flags():5 failed\n", &pkt);
-        return 0;
-    }
+    if (!TEST_true(WPACKET_init(&pkt, buf))
+            || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
+            || !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))
+            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
+            || !TEST_true(WPACKET_close(&pkt))
+            || !TEST_true(WPACKET_finish(&pkt))
+            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
+            || !TEST_mem_eq(buf->data, written, simple2, sizeof(simple2)))
+        return cleanup(&pkt);
     return 1;
 }
 
@@ -359,36 +302,26 @@ static int test_WPACKET_allocate_bytes(void)
     size_t written;
     unsigned char *bytes;
 
-    if (!WPACKET_init_len(&pkt, buf, 1)
-            || !WPACKET_allocate_bytes(&pkt, 2, &bytes)) {
-        testfail("test_WPACKET_allocate_bytes():1 failed\n", &pkt);
-        return 0;
-    }
+    if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
+            || !TEST_true(WPACKET_allocate_bytes(&pkt, 2, &bytes)))
+        return cleanup(&pkt);
     bytes[0] = 0xfe;
     bytes[1] = 0xff;
-    if (!WPACKET_finish(&pkt)
-            || !WPACKET_get_total_written(&pkt, &written)
-            ||  written != sizeof(alloc)
-            ||  memcmp(buf->data, &alloc, written) != 0) {
-        testfail("test_WPACKET_allocate_bytes():2 failed\n", &pkt);
-        return 0;
-    }
+    if (!TEST_true(WPACKET_finish(&pkt))
+            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
+            || !TEST_mem_eq(buf->data, written, alloc, sizeof(alloc)))
+        return cleanup(&pkt);
 
     /* Repeat with WPACKET_sub_allocate_bytes */
-    if (!WPACKET_init_len(&pkt, buf, 1)
-            || !WPACKET_sub_allocate_bytes_u8(&pkt, 2, &bytes)) {
-        testfail("test_WPACKET_allocate_bytes():3 failed\n", &pkt);
-        return 0;
-    }
+    if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
+            || !TEST_true(WPACKET_sub_allocate_bytes_u8(&pkt, 2, &bytes)))
+        return cleanup(&pkt);
     bytes[0] = 0xfe;
     bytes[1] = 0xff;
-    if (!WPACKET_finish(&pkt)
-            || !WPACKET_get_total_written(&pkt, &written)
-            ||  written != sizeof(submem)
-            ||  memcmp(buf->data, &submem, written) != 0) {
-        testfail("test_WPACKET_allocate_bytes():4 failed\n", &pkt);
-        return 0;
-    }
+    if (!TEST_true(WPACKET_finish(&pkt))
+            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
+            || !TEST_mem_eq(buf->data, written, submem, sizeof(submem)))
+        return cleanup(&pkt);
 
     return 1;
 }
@@ -399,26 +332,20 @@ static int test_WPACKET_memcpy(void)
     size_t written;
     const unsigned char bytes[] = { 0xfe, 0xff };
 
-    if (!WPACKET_init_len(&pkt, buf, 1)
-            || !WPACKET_memcpy(&pkt, bytes, sizeof(bytes))
-            || !WPACKET_finish(&pkt)
-            || !WPACKET_get_total_written(&pkt, &written)
-            ||  written != sizeof(alloc)
-            ||  memcmp(buf->data, &alloc, written) != 0) {
-        testfail("test_WPACKET_memcpy():1 failed\n", &pkt);
-        return 0;
-    }
+    if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
+            || !TEST_true(WPACKET_memcpy(&pkt, bytes, sizeof(bytes)))
+            || !TEST_true(WPACKET_finish(&pkt))
+            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
+            || !TEST_mem_eq(buf->data, written, alloc, sizeof(alloc)))
+        return cleanup(&pkt);
 
     /* Repeat with WPACKET_sub_memcpy() */
-    if (!WPACKET_init_len(&pkt, buf, 1)
-            || !WPACKET_sub_memcpy_u8(&pkt, bytes, sizeof(bytes))
-            || !WPACKET_finish(&pkt)
-            || !WPACKET_get_total_written(&pkt, &written)
-            ||  written != sizeof(submem)
-            ||  memcmp(buf->data, &submem, written) != 0) {
-        testfail("test_WPACKET_memcpy():2 failed\n", &pkt);
-        return 0;
-    }
+    if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
+            || !TEST_true(WPACKET_sub_memcpy_u8(&pkt, bytes, sizeof(bytes)))
+            || !TEST_true(WPACKET_finish(&pkt))
+            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
+            || !TEST_mem_eq(buf->data, written, submem, sizeof(submem)))
+        return cleanup(&pkt);
 
     return 1;
 }
@@ -427,19 +354,17 @@ int test_main(int argc, char *argv[])
 {
     int testresult = 0;
 
-    buf = BUF_MEM_new();
-    if (buf != NULL) {
-        ADD_TEST(test_WPACKET_init);
-        ADD_TEST(test_WPACKET_set_max_size);
-        ADD_TEST(test_WPACKET_start_sub_packet);
-        ADD_TEST(test_WPACKET_set_flags);
-        ADD_TEST(test_WPACKET_allocate_bytes);
-        ADD_TEST(test_WPACKET_memcpy);
-
-        testresult = run_tests(argv[0]);
+    if (!TEST_ptr(buf = BUF_MEM_new()))
+            return 0;
 
-        BUF_MEM_free(buf);
-    }
+    ADD_TEST(test_WPACKET_init);
+    ADD_TEST(test_WPACKET_set_max_size);
+    ADD_TEST(test_WPACKET_start_sub_packet);
+    ADD_TEST(test_WPACKET_set_flags);
+    ADD_TEST(test_WPACKET_allocate_bytes);
+    ADD_TEST(test_WPACKET_memcpy);
+    testresult = run_tests(argv[0]);
 
+    BUF_MEM_free(buf);
     return testresult;
 }