From adcd8e37db682a5818415b1e0e1d8847dd9ab1e6 Mon Sep 17 00:00:00 2001 From: Rich Salz Date: Tue, 18 Apr 2017 16:33:15 -0400 Subject: [PATCH] Convert more tests 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 (Merged from https://github.com/openssl/openssl/pull/3234) --- test/build.info | 4 +- test/ct_test.c | 228 ++++++------------ test/evp_extra_test.c | 182 +++++--------- test/packettest.c | 543 +++++++++++++++++++----------------------- test/testutil.c | 32 +++ test/testutil.h | 10 + test/wpackettest.c | 479 ++++++++++++++++--------------------- 7 files changed, 635 insertions(+), 843 deletions(-) diff --git a/test/build.info b/test/build.info index d6e43cf7b3..01b4c6831c 100644 --- a/test/build.info +++ b/test/build.info @@ -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 diff --git a/test/ct_test.c b/test/ct_test.c index ac89f57847..e96eab0a7a 100644 --- a/test/ct_test.c +++ b/test/ct_test.c @@ -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; + 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())) + || !TEST_true(X509V3_EXT_print(text_buffer, extension, + X509V3_EXT_DEFAULT, 0))) goto end; - } - if (!X509V3_EXT_print(text_buffer, extension, X509V3_EXT_DEFAULT, 0)) { - fprintf(stderr, "Failed to print extension\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; - } - - /* 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"); - 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; + 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); + 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[]) diff --git a/test/evp_extra_test.c b/test/evp_extra_test.c index 9217f3ae51..b8cfc0d204 100644 --- a/test/evp_extra_test.c +++ b/test/evp_extra_test.c @@ -15,6 +15,8 @@ #include #include #include +#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(); - - 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_ptr(md_ctx = EVP_MD_CTX_new()) + || !TEST_ptr(pkey = load_example_rsa_key())) + goto out; + + 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"); + 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; - } - - if (EVP_PKEY_id(pkey) != expected_id) { - fprintf(stderr, "Did not decode expected type\n"); - 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 (!p8inf || derp != kExampleBadECKeyDER + sizeof(kExampleBadECKeyDER)) { - fprintf(stderr, "Failed to parse key\n"); + if (!TEST_ptr(p8inf = d2i_PKCS8_PRIV_KEY_INFO(NULL, &derp, + sizeof(kExampleBadECKeyDER)))) goto done; - } - pkey = EVP_PKCS82PKEY(p8inf); - if (pkey) { - fprintf(stderr, "Imported invalid EC key\n"); + if (!TEST_ptr_eq(derp, + kExampleBadECKeyDER + sizeof(kExampleBadECKeyDER))) + goto done; + + 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; } diff --git a/test/packettest.c b/test/packettest.c index 58fc7525fb..7ee4a08fe0 100644 --- a/test/packettest.c +++ b/test/packettest.c @@ -8,328 +8,311 @@ */ #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; + int result = 0; - 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; - } - + 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; + PACKET pkt, short_pkt, subpkt = {0}; - buf[0] = len; - for (i = 1; i < BUF_LEN; i++) { - buf[i] = (i * 2) & 0xff; - } + buf1[0] = len; + for (i = 1; i < BUF_LEN; i++) + buf1[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"); + 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; + PACKET pkt, short_pkt, subpkt = {0}; - for (i = 1; i <= 1024; i++) { - buf[i-1] = (i * 2) & 0xff; - } + for (i = 1; i <= 1024; i++) + buf1[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"); + 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; + PACKET pkt, short_pkt, subpkt = {0}; - for (i = 0; i < 1024; i++) { - buf[i] = (i * 2) & 0xff; - } + for (i = 0; i < 1024; i++) + buf1[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"); + 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; - } + buf1[0] = len; + for (i = 1; i < BUF_LEN; i++) + buf1[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"); + 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; + for (i = 1; i <= BUF_LEN; i++) + smbuf[i - 1] = (i * 2) & 0xff; - 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; + 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); } diff --git a/test/testutil.c b/test/testutil.c index 3d2824c1f9..ae98e1096d 100644 --- a/test/testutil.c +++ b/test/testutil.c @@ -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. diff --git a/test/testutil.h b/test/testutil.h index 0631a8b7f8..e7478a8ade 100644 --- a/test/testutil.h +++ b/test/testutil.h @@ -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) diff --git a/test/wpackettest.c b/test/wpackettest.c index 3ab293e0e9..2546ef3c6c 100644 --- a/test/wpackettest.c +++ b/test/wpackettest.c @@ -13,22 +13,22 @@ #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 (!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 (!WPACKET_init_len(&pkt, buf, 1)) { - testfail("test_WPACKET_init():4 failed\n", &pkt); - return 0; - } + 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); + if (!TEST_ptr(buf = BUF_MEM_new())) + return 0; - testresult = run_tests(argv[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; }