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
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
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;
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;
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);
{
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;
}
}
- 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;
}
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';
}
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);
}
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;
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))
}
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;
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;
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:
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);
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[])
#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
};
#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;
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);
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);
{
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;
}
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;
}
#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;
}
*/
#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;
}
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;
}
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);
}
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.
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.
# 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)
#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)
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
{
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;
}
projects / oweals / openssl.git / commitdiff