Convert bytestringtest to individual checks and don't short circuit.

The statements were chained together with OR which makes it more annoying
to debug.  Also, it was short circuiting all tests as soon as one function
failed.  Since the functions are independent, they should each run until
error.

Discussed with miod@ and jsing@

1 files changed, 337 insertions, 321 deletions

diff --git a/regress/lib/libssl/bytestring/bytestringtest.c b/regress/lib/libssl/bytestring/bytestringtest.c
index 65b638132a5..d989868c852 100644
--- a/regress/lib/libssl/bytestring/bytestringtest.c
+++ b/regress/lib/libssl/bytestring/bytestringtest.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: bytestringtest.c,v 1.6 2015/06/17 07:15:52 doug Exp $	*/
+/*	$OpenBSD: bytestringtest.c,v 1.7 2015/06/23 01:20:24 doug Exp $	*/
 /*
  * Copyright (c) 2014, Google Inc.
  *
@@ -25,6 +25,22 @@
 /* This is from <openssl/base.h> in boringssl */
 #define OPENSSL_U64(x) x##ULL
 
+#define CHECK(a) do {							\
+	if (!(a)) {							\
+		printf("Error in %s [%s:%d]\n", __func__, __FILE__,	\
+		    __LINE__);						\
+		return 0;						\
+	}								\
+} while (0)
+
+#define CHECK_GOTO(a) do {						\
+	if (!(a)) {							\
+		printf("Error in %s [%s:%d]\n", __func__, __FILE__,	\
+		    __LINE__);						\
+		goto err;						\
+	}								\
+} while (0)
+
 static int
 test_skip(void)
 {
@@ -32,12 +48,15 @@ test_skip(void)
 	CBS data;
 
 	CBS_init(&data, kData, sizeof(kData));
-	return CBS_len(&data) == 3 &&
-	    CBS_skip(&data, 1) &&
-	    CBS_len(&data) == 2 &&
-	    CBS_skip(&data, 2) &&
-	    CBS_len(&data) == 0 &&
-	    !CBS_skip(&data, 1);
+
+	CHECK(CBS_len(&data) == 3);
+	CHECK(CBS_skip(&data, 1));
+	CHECK(CBS_len(&data) == 2);
+	CHECK(CBS_skip(&data, 2));
+	CHECK(CBS_len(&data) == 0);
+	CHECK(!CBS_skip(&data, 1));
+
+	return 1;
 }
 
 static int
@@ -50,15 +69,18 @@ test_get_u(void)
 	CBS data;
 
 	CBS_init(&data, kData, sizeof(kData));
-	return CBS_get_u8(&data, &u8) &&
-	    u8 == 1 &&
-	    CBS_get_u16(&data, &u16) &&
-	    u16 == 0x203 &&
-	    CBS_get_u24(&data, &u32) &&
-	    u32 == 0x40506 &&
-	    CBS_get_u32(&data, &u32) &&
-	    u32 == 0x708090a &&
-	    !CBS_get_u8(&data, &u8);
+
+	CHECK(CBS_get_u8(&data, &u8));
+	CHECK(u8 == 1);
+	CHECK(CBS_get_u16(&data, &u16));
+	CHECK(u16 == 0x203);
+	CHECK(CBS_get_u24(&data, &u32));
+	CHECK(u32 == 0x40506);
+	CHECK(CBS_get_u32(&data, &u32));
+	CHECK(u32 == 0x708090a);
+	CHECK(!CBS_get_u8(&data, &u8));
+
+	return 1;
 }
 
 static int
@@ -71,18 +93,21 @@ test_get_prefixed(void)
 	CBS data, prefixed;
 
 	CBS_init(&data, kData, sizeof(kData));
-	return CBS_get_u8_length_prefixed(&data, &prefixed) &&
-	    CBS_len(&prefixed) == 1 &&
-	    CBS_get_u8(&prefixed, &u8) &&
-	    u8 == 2 &&
-	    CBS_get_u16_length_prefixed(&data, &prefixed) &&
-	    CBS_len(&prefixed) == 2 &&
-	    CBS_get_u16(&prefixed, &u16) &&
-	    u16 == 0x304 &&
-	    CBS_get_u24_length_prefixed(&data, &prefixed) &&
-	    CBS_len(&prefixed) == 3 &&
-	    CBS_get_u24(&prefixed, &u32) &&
-	    u32 == 0x30201;
+
+	CHECK(CBS_get_u8_length_prefixed(&data, &prefixed));
+	CHECK(CBS_len(&prefixed) == 1);
+	CHECK(CBS_get_u8(&prefixed, &u8));
+	CHECK(u8 == 2);
+	CHECK(CBS_get_u16_length_prefixed(&data, &prefixed));
+	CHECK(CBS_len(&prefixed) == 2);
+	CHECK(CBS_get_u16(&prefixed, &u16));
+	CHECK(u16 == 0x304);
+	CHECK(CBS_get_u24_length_prefixed(&data, &prefixed));
+	CHECK(CBS_len(&prefixed) == 3);
+	CHECK(CBS_get_u24(&prefixed, &u32));
+	CHECK(u32 == 0x30201);
+
+	return 1;
 }
 
 static int
@@ -94,16 +119,13 @@ test_get_prefixed_bad(void)
 	CBS data, prefixed;
 
 	CBS_init(&data, kData1, sizeof(kData1));
-	if (CBS_get_u8_length_prefixed(&data, &prefixed))
-		return 0;
+	CHECK(!CBS_get_u8_length_prefixed(&data, &prefixed));
 
 	CBS_init(&data, kData2, sizeof(kData2));
-	if (CBS_get_u16_length_prefixed(&data, &prefixed))
-		return 0;
+	CHECK(!CBS_get_u16_length_prefixed(&data, &prefixed));
 
 	CBS_init(&data, kData3, sizeof(kData3));
-	if (CBS_get_u24_length_prefixed(&data, &prefixed))
-		return 0;
+	CHECK(!CBS_get_u24_length_prefixed(&data, &prefixed));
 
 	return 1;
 }
@@ -126,99 +148,87 @@ test_get_asn1(void)
 	uint64_t value;
 
 	CBS_init(&data, kData1, sizeof(kData1));
-	if (CBS_peek_asn1_tag(&data, 0x1) || !CBS_peek_asn1_tag(&data, 0x30))
-		return 0;
 
-	if (!CBS_get_asn1(&data, &contents, 0x30) ||
-	    CBS_len(&contents) != 2 ||
-	    memcmp(CBS_data(&contents), "\x01\x02", 2) != 0)
-		return 0;
+	CHECK(!CBS_peek_asn1_tag(&data, 0x1));
+	CHECK(CBS_peek_asn1_tag(&data, 0x30));
+
+	CHECK(CBS_get_asn1(&data, &contents, 0x30));
+	CHECK(CBS_len(&contents) == 2);
+	CHECK(memcmp(CBS_data(&contents), "\x01\x02", 2) == 0);
 
 	CBS_init(&data, kData2, sizeof(kData2));
 	/* data is truncated */
-	if (CBS_get_asn1(&data, &contents, 0x30))
-		return 0;
+	CHECK(!CBS_get_asn1(&data, &contents, 0x30));
 
 	CBS_init(&data, kData3, sizeof(kData3));
 	/* zero byte length of length */
-	if (CBS_get_asn1(&data, &contents, 0x30))
-		return 0;
+	CHECK(!CBS_get_asn1(&data, &contents, 0x30));
 
 	CBS_init(&data, kData4, sizeof(kData4));
 	/* long form mistakenly used. */
-	if (CBS_get_asn1(&data, &contents, 0x30))
-		return 0;
+	CHECK(!CBS_get_asn1(&data, &contents, 0x30));
 
 	CBS_init(&data, kData5, sizeof(kData5));
 	/* length takes too many bytes. */
-	if (CBS_get_asn1(&data, &contents, 0x30))
-		return 0;
+	CHECK(!CBS_get_asn1(&data, &contents, 0x30));
 
 	CBS_init(&data, kData1, sizeof(kData1));
 	/* wrong tag. */
-	if (CBS_get_asn1(&data, &contents, 0x31))
-		return 0;
+	CHECK(!CBS_get_asn1(&data, &contents, 0x31));
 
 	CBS_init(&data, NULL, 0);
 	/* peek at empty data. */
-	if (CBS_peek_asn1_tag(&data, 0x30))
-		return 0;
+	CHECK(!CBS_peek_asn1_tag(&data, 0x30));
 
 	CBS_init(&data, NULL, 0);
 	/* optional elements at empty data. */
-	if (!CBS_get_optional_asn1(&data, &contents, &present, 0xa0) ||
-	    present ||
-	    !CBS_get_optional_asn1_octet_string(&data, &contents, &present,
-	    0xa0) ||
-	    present ||
-	    CBS_len(&contents) != 0 ||
-	    !CBS_get_optional_asn1_octet_string(&data, &contents, NULL, 0xa0) ||
-	    CBS_len(&contents) != 0 ||
-	    !CBS_get_optional_asn1_uint64(&data, &value, 0xa0, 42) ||
-	    value != 42)
-		return 0;
+	CHECK(CBS_get_optional_asn1(&data, &contents, &present, 0xa0));
+	CHECK(!present);
+	CHECK(CBS_get_optional_asn1_octet_string(&data, &contents, &present,
+	    0xa0));
+	CHECK(!present);
+	CHECK(CBS_len(&contents) == 0);
+	CHECK(CBS_get_optional_asn1_octet_string(&data, &contents, NULL, 0xa0));
+	CHECK(CBS_len(&contents) == 0);
+	CHECK(CBS_get_optional_asn1_uint64(&data, &value, 0xa0, 42));
+	CHECK(value == 42);
 
 	CBS_init(&data, kData6, sizeof(kData6));
 	/* optional element. */
-	if (!CBS_get_optional_asn1(&data, &contents, &present, 0xa0) ||
-	    present ||
-	    !CBS_get_optional_asn1(&data, &contents, &present, 0xa1) ||
-	    !present ||
-	    CBS_len(&contents) != 3 ||
-	    memcmp(CBS_data(&contents), "\x04\x01\x01", 3) != 0)
-		return 0;
+	CHECK(CBS_get_optional_asn1(&data, &contents, &present, 0xa0));
+	CHECK(!present);
+	CHECK(CBS_get_optional_asn1(&data, &contents, &present, 0xa1));
+	CHECK(present);
+	CHECK(CBS_len(&contents) == 3);
+	CHECK(memcmp(CBS_data(&contents), "\x04\x01\x01", 3) == 0);
 
 	CBS_init(&data, kData6, sizeof(kData6));
 	/* optional octet string. */
-	if (!CBS_get_optional_asn1_octet_string(&data, &contents, &present,
-	    0xa0) ||
-	    present ||
-	    CBS_len(&contents) != 0 ||
-	    !CBS_get_optional_asn1_octet_string(&data, &contents, &present,
-	    0xa1) ||
-	    !present ||
-	    CBS_len(&contents) != 1 ||
-	    CBS_data(&contents)[0] != 1)
-		return 0;
+	CHECK(CBS_get_optional_asn1_octet_string(&data, &contents, &present,
+	    0xa0));
+	CHECK(!present);
+	CHECK(CBS_len(&contents) == 0);
+	CHECK(CBS_get_optional_asn1_octet_string(&data, &contents, &present,
+	    0xa1));
+	CHECK(present);
+	CHECK(CBS_len(&contents) == 1);
+	CHECK(CBS_data(&contents)[0] == 1);
 
 	CBS_init(&data, kData7, sizeof(kData7));
 	/* invalid optional octet string. */
-	if (CBS_get_optional_asn1_octet_string(&data, &contents, &present,
-	    0xa1))
-		return 0;
+	CHECK(!CBS_get_optional_asn1_octet_string(&data, &contents, &present,
+	    0xa1));
 
 	CBS_init(&data, kData8, sizeof(kData8));
 	/* optional octet string. */
-	if (!CBS_get_optional_asn1_uint64(&data, &value, 0xa0, 42) ||
-	    value != 42 ||
-	    !CBS_get_optional_asn1_uint64(&data, &value, 0xa1, 42) ||
-	    value != 1)
-		return 0;
+	CHECK(CBS_get_optional_asn1_uint64(&data, &value, 0xa0, 42));
+	CHECK(value == 42);
+	CHECK(CBS_get_optional_asn1_uint64(&data, &value, 0xa1, 42));
+	CHECK(value == 1);
 
 	CBS_init(&data, kData9, sizeof(kData9));
 	/* invalid optional integer. */
-	if (CBS_get_optional_asn1_uint64(&data, &value, 0xa1, 42))
-		return 0;
+	CHECK(!CBS_get_optional_asn1_uint64(&data, &value, 0xa1, 42));
 
 	return 1;
 }
@@ -235,22 +245,21 @@ test_get_optional_asn1_bool(void)
 
 	CBS_init(&data, NULL, 0);
 	val = 2;
-	if (!CBS_get_optional_asn1_bool(&data, &val, 0x0a, 0) || val != 0)
-		return 0;
+	CHECK(CBS_get_optional_asn1_bool(&data, &val, 0x0a, 0));
+	CHECK(val == 0);
 
 	CBS_init(&data, kTrue, sizeof(kTrue));
 	val = 2;
-	if (!CBS_get_optional_asn1_bool(&data, &val, 0x0a, 0) || val != 1)
-		return 0;
+	CHECK(CBS_get_optional_asn1_bool(&data, &val, 0x0a, 0));
+	CHECK(val == 1);
 
 	CBS_init(&data, kFalse, sizeof(kFalse));
 	val = 2;
-	if (!CBS_get_optional_asn1_bool(&data, &val, 0x0a, 1) || val != 0)
-		return 0;
+	CHECK(CBS_get_optional_asn1_bool(&data, &val, 0x0a, 1));
+	CHECK(val == 0);
 
 	CBS_init(&data, kInvalid, sizeof(kInvalid));
-	if (CBS_get_optional_asn1_bool(&data, &val, 0x0a, 1))
-		return 0;
+	CHECK(!CBS_get_optional_asn1_bool(&data, &val, 0x0a, 1));
 
 	return 1;
 }
@@ -259,28 +268,31 @@ static int
 test_cbb_basic(void)
 {
 	static const uint8_t kExpected[] = {1, 2, 3, 4, 5, 6, 7, 8};
-	uint8_t *buf;
+	uint8_t *buf = NULL;
 	size_t buf_len;
-	int ok;
+	int ret = 0;
 	CBB cbb;
 
-	if (!CBB_init(&cbb, 100))
-		return 0;
+	CHECK(CBB_init(&cbb, 100));
 
 	CBB_cleanup(&cbb);
 
-	if (!CBB_init(&cbb, 0) ||
-	    !CBB_add_u8(&cbb, 1) ||
-	    !CBB_add_u16(&cbb, 0x203) ||
-	    !CBB_add_u24(&cbb, 0x40506) ||
-	    !CBB_add_bytes(&cbb, (const uint8_t*) "\x07\x08", 2) ||
-	    !CBB_finish(&cbb, &buf, &buf_len))
-		return 0;
+	CHECK(CBB_init(&cbb, 0));
+	CHECK_GOTO(CBB_add_u8(&cbb, 1));
+	CHECK_GOTO(CBB_add_u16(&cbb, 0x203));
+	CHECK_GOTO(CBB_add_u24(&cbb, 0x40506));
+	CHECK_GOTO(CBB_add_bytes(&cbb, (const uint8_t*) "\x07\x08", 2));
+	CHECK_GOTO(CBB_finish(&cbb, &buf, &buf_len));
 
-	ok = buf_len == sizeof(kExpected) && memcmp(buf, kExpected, buf_len)
-	    == 0;
+	ret = (buf_len == sizeof(kExpected)
+	    && memcmp(buf, kExpected, buf_len) == 0);
+
+	if (0) {
+err:
+		CBB_cleanup(&cbb);
+	}
 	free(buf);
-	return ok;
+	return ret;
 }
 
 static int
@@ -288,26 +300,28 @@ test_cbb_fixed(void)
 {
 	CBB cbb;
 	uint8_t buf[1];
-	uint8_t *out_buf;
+	uint8_t *out_buf = NULL;
 	size_t out_size;
+	int ret = 0;
 
-	if (!CBB_init_fixed(&cbb, NULL, 0) ||
-	    CBB_add_u8(&cbb, 1) ||
-	    !CBB_finish(&cbb, &out_buf, &out_size) ||
-	    out_buf != NULL ||
-	    out_size != 0)
-		return 0;
-
-	if (!CBB_init_fixed(&cbb, buf, 1) ||
-	    !CBB_add_u8(&cbb, 1) ||
-	    CBB_add_u8(&cbb, 2) ||
-	    !CBB_finish(&cbb, &out_buf, &out_size) ||
-	    out_buf != buf ||
-	    out_size != 1 ||
-	    buf[0] != 1)
-		return 0;
+	CHECK(CBB_init_fixed(&cbb, NULL, 0));
+	CHECK_GOTO(!CBB_add_u8(&cbb, 1));
+	CHECK_GOTO(CBB_finish(&cbb, &out_buf, &out_size));
+	CHECK(out_buf == NULL && out_size == 0);
 
-	return 1;
+	CHECK(CBB_init_fixed(&cbb, buf, 1));
+	CHECK_GOTO(CBB_add_u8(&cbb, 1));
+	CHECK_GOTO(!CBB_add_u8(&cbb, 2));
+	CHECK_GOTO(CBB_finish(&cbb, &out_buf, &out_size));
+
+	ret = (out_buf == buf && out_size == 1 && buf[0] == 1);
+
+	if (0) {
+err:
+		CBB_cleanup(&cbb);
+	}
+
+	return ret;
 }
 
 static int
@@ -318,15 +332,12 @@ test_cbb_finish_child(void)
 	size_t out_size;
 	int ret = 0;
 
-	if (!CBB_init(&cbb, 16) ||
-	    !CBB_add_u8_length_prefixed(&cbb, &child) ||
-	    CBB_finish(&child, &out_buf, &out_size) ||
-	    !CBB_finish(&cbb, &out_buf, &out_size) ||
-	    out_size != 1 ||
-	    out_buf[0] != 0)
-		goto err;
+	CHECK(CBB_init(&cbb, 16));
+	CHECK_GOTO(CBB_add_u8_length_prefixed(&cbb, &child));
+	CHECK_GOTO(!CBB_finish(&child, &out_buf, &out_size));
+	CHECK_GOTO(CBB_finish(&cbb, &out_buf, &out_size));
 
-	ret = 1;
+	ret = (out_size == 1 && out_buf[0] == 0);
 
 err:
 	free(out_buf);
@@ -341,31 +352,33 @@ test_cbb_prefixed(void)
 	uint8_t *buf = NULL;
 	size_t buf_len;
 	CBB cbb, contents, inner_contents, inner_inner_contents;
-	int ok = 0;
-
-	if (!CBB_init(&cbb, 0) ||
-	    !CBB_add_u8_length_prefixed(&cbb, &contents) ||
-	    !CBB_add_u8_length_prefixed(&cbb, &contents) ||
-	    !CBB_add_u8(&contents, 1) ||
-	    !CBB_add_u16_length_prefixed(&cbb, &contents) ||
-	    !CBB_add_u16(&contents, 0x203) ||
-	    !CBB_add_u24_length_prefixed(&cbb, &contents) ||
-	    !CBB_add_u24(&contents, 0x40506) ||
-	    !CBB_add_u8_length_prefixed(&cbb, &contents) ||
-	    !CBB_add_u8_length_prefixed(&contents, &inner_contents) ||
-	    !CBB_add_u8(&inner_contents, 1) ||
-	    !CBB_add_u16_length_prefixed(&inner_contents,
-	    &inner_inner_contents) ||
-	    !CBB_add_u8(&inner_inner_contents, 2) ||
-	    !CBB_finish(&cbb, &buf, &buf_len))
-		goto err;
-
-	ok = buf_len == sizeof(kExpected) && memcmp(buf, kExpected, buf_len)
-	    == 0;
+	int ret = 0;
 
+	CHECK(CBB_init(&cbb, 0));
+	CHECK_GOTO(CBB_add_u8_length_prefixed(&cbb, &contents));
+	CHECK_GOTO(CBB_add_u8_length_prefixed(&cbb, &contents));
+	CHECK_GOTO(CBB_add_u8(&contents, 1));
+	CHECK_GOTO(CBB_add_u16_length_prefixed(&cbb, &contents));
+	CHECK_GOTO(CBB_add_u16(&contents, 0x203));
+	CHECK_GOTO(CBB_add_u24_length_prefixed(&cbb, &contents));
+	CHECK_GOTO(CBB_add_u24(&contents, 0x40506));
+	CHECK_GOTO(CBB_add_u8_length_prefixed(&cbb, &contents));
+	CHECK_GOTO(CBB_add_u8_length_prefixed(&contents, &inner_contents));
+	CHECK_GOTO(CBB_add_u8(&inner_contents, 1));
+	CHECK_GOTO(CBB_add_u16_length_prefixed(&inner_contents,
+	    &inner_inner_contents));
+	CHECK_GOTO(CBB_add_u8(&inner_inner_contents, 2));
+	CHECK_GOTO(CBB_finish(&cbb, &buf, &buf_len));
+
+	ret = (buf_len == sizeof(kExpected)
+	    && memcmp(buf, kExpected, buf_len) == 0);
+
+	if (0) {
 err:
+		CBB_cleanup(&cbb);
+	}
 	free(buf);
-	return ok;
+	return ret;
 }
 
 static int
@@ -376,34 +389,30 @@ test_cbb_misuse(void)
 	size_t buf_len;
 	int ret = 0;
 
-	if (!CBB_init(&cbb, 0) ||
-	    !CBB_add_u8_length_prefixed(&cbb, &child) ||
-	    !CBB_add_u8(&child, 1) ||
-	    !CBB_add_u8(&cbb, 2))
-		return 0;
+	CHECK(CBB_init(&cbb, 0));
+	CHECK_GOTO(CBB_add_u8_length_prefixed(&cbb, &child));
+	CHECK_GOTO(CBB_add_u8(&child, 1));
+	CHECK_GOTO(CBB_add_u8(&cbb, 2));
 
 	/*
 	 * Since we wrote to |cbb|, |child| is now invalid and attempts to write
 	 * to it should fail.
 	 */
-	if (CBB_add_u8(&child, 1) ||
-	    CBB_add_u16(&child, 1) ||
-	    CBB_add_u24(&child, 1) ||
-	    CBB_add_u8_length_prefixed(&child, &contents) ||
-	    CBB_add_u16_length_prefixed(&child, &contents) ||
-	    CBB_add_asn1(&child, &contents, 1) ||
-	    CBB_add_bytes(&child, (const uint8_t*) "a", 1)) {
-		fprintf(stderr, "CBB operation on invalid CBB did not fail.\n");
-		return 0;
-	}
-
-	if (!CBB_finish(&cbb, &buf, &buf_len) || buf_len != 3 ||
-	    memcmp(buf, "\x01\x01\x02", 3) != 0)
-		goto err;
-
-	ret = 1;
-
+	CHECK_GOTO(!CBB_add_u8(&child, 1));
+	CHECK_GOTO(!CBB_add_u16(&child, 1));
+	CHECK_GOTO(!CBB_add_u24(&child, 1));
+	CHECK_GOTO(!CBB_add_u8_length_prefixed(&child, &contents));
+	CHECK_GOTO(!CBB_add_u16_length_prefixed(&child, &contents));
+	CHECK_GOTO(!CBB_add_asn1(&child, &contents, 1));
+	CHECK_GOTO(!CBB_add_bytes(&child, (const uint8_t*) "a", 1));
+	CHECK_GOTO(CBB_finish(&cbb, &buf, &buf_len));
+
+	ret = (buf_len == 3 && memcmp(buf, "\x01\x01\x02", 3) == 0);
+
+	if (0) {
 err:
+		CBB_cleanup(&cbb);
+	}
 	free(buf);
 	return ret;
 }
@@ -416,70 +425,75 @@ test_cbb_asn1(void)
 	size_t buf_len;
 	CBB cbb, contents, inner_contents;
 	int ret = 0;
+	int alloc = 0;
 
-	if (!CBB_init(&cbb, 0) ||
-	    !CBB_add_asn1(&cbb, &contents, 0x30) ||
-	    !CBB_add_bytes(&contents, (const uint8_t*) "\x01\x02\x03", 3) ||
-	    !CBB_finish(&cbb, &buf, &buf_len))
-		goto err;
+	CHECK_GOTO(CBB_init(&cbb, 0));
+	alloc = 1;
+	CHECK_GOTO(CBB_add_asn1(&cbb, &contents, 0x30));
+	CHECK_GOTO(CBB_add_bytes(&contents, (const uint8_t*) "\x01\x02\x03",
+	    3));
+	CHECK_GOTO(CBB_finish(&cbb, &buf, &buf_len));
+	alloc = 0;
 
-	if (buf_len != sizeof(kExpected) || memcmp(buf, kExpected, buf_len)
-	    != 0)
-		goto err;
+	CHECK_GOTO(buf_len == sizeof(kExpected));
+	CHECK_GOTO(memcmp(buf, kExpected, buf_len) == 0);
 
 	free(buf);
 	buf = NULL;
 
-	if ((test_data = malloc(100000)) == NULL)
-		goto err;
+	CHECK_GOTO(((test_data = malloc(100000)) != NULL));
 	memset(test_data, 0x42, 100000);
 
-	if (!CBB_init(&cbb, 0) ||
-	    !CBB_add_asn1(&cbb, &contents, 0x30) ||
-	    !CBB_add_bytes(&contents, test_data, 130) ||
-	    !CBB_finish(&cbb, &buf, &buf_len))
-		goto err;
+	CHECK_GOTO(CBB_init(&cbb, 0));
+	alloc = 1;
+	CHECK_GOTO(CBB_add_asn1(&cbb, &contents, 0x30));
+	CHECK_GOTO(CBB_add_bytes(&contents, test_data, 130));
+	CHECK_GOTO(CBB_finish(&cbb, &buf, &buf_len));
+	alloc = 0;
+
+	CHECK_GOTO(buf_len == 3 + 130);
+	CHECK_GOTO(memcmp(buf, "\x30\x81\x82", 3) == 0);
+	CHECK_GOTO(memcmp(buf + 3, test_data, 130) == 0);
 
-	if (buf_len != 3 + 130 ||
-	    memcmp(buf, "\x30\x81\x82", 3) != 0 ||
-	    memcmp(buf + 3, test_data, 130) != 0) {
-		goto err;
-	}
 	free(buf);
 	buf = NULL;
 
-	if (!CBB_init(&cbb, 0) ||
-	    !CBB_add_asn1(&cbb, &contents, 0x30) ||
-	    !CBB_add_bytes(&contents, test_data, 1000) ||
-	    !CBB_finish(&cbb, &buf, &buf_len))
-		goto err;
+	CHECK_GOTO(CBB_init(&cbb, 0));
+	alloc = 1;
+	CHECK_GOTO(CBB_add_asn1(&cbb, &contents, 0x30));
+	CHECK_GOTO(CBB_add_bytes(&contents, test_data, 1000));
+	CHECK_GOTO(CBB_finish(&cbb, &buf, &buf_len));
+	alloc = 0;
+
+	CHECK_GOTO(buf_len == 4 + 1000);
+	CHECK_GOTO(memcmp(buf, "\x30\x82\x03\xe8", 4) == 0);
+	CHECK_GOTO(!memcmp(buf + 4, test_data, 1000));
 
-	if (buf_len != 4 + 1000 ||
-	    memcmp(buf, "\x30\x82\x03\xe8", 4) != 0 ||
-	    memcmp(buf + 4, test_data, 1000)) {
-		goto err;
-	}
 	free(buf);
 	buf = NULL;
 
-	if (!CBB_init(&cbb, 0) ||
-	    !CBB_add_asn1(&cbb, &contents, 0x30) ||
-	    !CBB_add_asn1(&contents, &inner_contents, 0x30) ||
-	    !CBB_add_bytes(&inner_contents, test_data, 100000) ||
-	    !CBB_finish(&cbb, &buf, &buf_len))
-		goto err;
+	CHECK_GOTO(CBB_init(&cbb, 0));
+	alloc = 1;
+	CHECK_GOTO(CBB_add_asn1(&cbb, &contents, 0x30));
+	CHECK_GOTO(CBB_add_asn1(&contents, &inner_contents, 0x30));
+	CHECK_GOTO(CBB_add_bytes(&inner_contents, test_data, 100000));
+	CHECK_GOTO(CBB_finish(&cbb, &buf, &buf_len));
+	alloc = 0;
 
-	if (buf_len != 5 + 5 + 100000 ||
-	    memcmp(buf, "\x30\x83\x01\x86\xa5\x30\x83\x01\x86\xa0", 10) != 0 ||
-	    memcmp(buf + 10, test_data, 100000))
-		goto err;
+	CHECK_GOTO(buf_len == 5 + 5 + 100000);
+	CHECK_GOTO(memcmp(buf, "\x30\x83\x01\x86\xa5\x30\x83\x01\x86\xa0", 10)
+	    == 0);
+	CHECK_GOTO(!memcmp(buf + 10, test_data, 100000));
 
 	ret = 1;
 
+	if (0) {
 err:
+		if (alloc)
+			CBB_cleanup(&cbb);
+	}
 	free(buf);
 	free(test_data);
-
 	return ret;
 }
 
@@ -493,33 +507,23 @@ do_indefinite_convert(const char *name, const uint8_t *definite_expected,
 	int ret = 0;
 
 	CBS_init(&in, indefinite, indefinite_len);
-	if (!CBS_asn1_indefinite_to_definite(&in, &out, &out_len)) {
-		fprintf(stderr, "%s: CBS_asn1_indefinite_to_definite failed.\n",
-		    name);
-		goto end;
-	}
+
+	CHECK_GOTO(CBS_asn1_indefinite_to_definite(&in, &out, &out_len));
 
 	if (out == NULL) {
-		if (indefinite_len != definite_len ||
-		    memcmp(definite_expected, indefinite, indefinite_len)
-		    != 0) {
-			fprintf(stderr, "%s: incorrect unconverted result.\n",
-			    name);
-			return 0;
-		}
+		CHECK_GOTO(indefinite_len == definite_len);
+		CHECK_GOTO(memcmp(definite_expected, indefinite, indefinite_len)
+		    == 0);
 
 		return 1;
 	}
 
-	if (out_len != definite_len || memcmp(out, definite_expected,
-	    definite_len) != 0) {
-		fprintf(stderr, "%s: incorrect converted result.\n", name);
-		goto end;
-	}
+	CHECK_GOTO(out_len == definite_len);
+	CHECK_GOTO(memcmp(out, definite_expected, definite_len) == 0);
 
 	ret = 1;
 
-end:
+err:
 	free(out);
 	return ret;
 }
@@ -569,15 +573,17 @@ test_indefinite_convert(void)
 	    0x6e, 0x10, 0x9b, 0xb8, 0x02, 0x02, 0x07, 0xd0,
 	};
 
-	return do_indefinite_convert("kSimpleBER", kSimpleBER, sizeof(kSimpleBER),
-	    kSimpleBER, sizeof(kSimpleBER)) &&
-	    do_indefinite_convert("kIndefBER", kIndefDER, sizeof(kIndefDER), kIndefBER,
-	    sizeof(kIndefBER)) &&
-	    do_indefinite_convert("kOctetStringBER", kOctetStringDER,
+	CHECK(do_indefinite_convert("kSimpleBER", kSimpleBER, sizeof(kSimpleBER),
+	    kSimpleBER, sizeof(kSimpleBER)));
+	CHECK(do_indefinite_convert("kIndefBER", kIndefDER, sizeof(kIndefDER),
+	    kIndefBER, sizeof(kIndefBER)));
+	CHECK(do_indefinite_convert("kOctetStringBER", kOctetStringDER,
 	    sizeof(kOctetStringDER), kOctetStringBER,
-	    sizeof(kOctetStringBER)) &&
-	    do_indefinite_convert("kNSSBER", kNSSDER, sizeof(kNSSDER), kNSSBER,
-	    sizeof(kNSSBER));
+	    sizeof(kOctetStringBER)));
+	CHECK(do_indefinite_convert("kNSSBER", kNSSDER, sizeof(kNSSDER), kNSSBER,
+	    sizeof(kNSSBER)));
+
+	return 1;
 }
 
 typedef struct {
@@ -619,40 +625,36 @@ static const ASN1_INVALID_UINT64_TEST kAsn1InvalidUint64Tests[] = {
 static int
 test_asn1_uint64(void)
 {
+	CBB cbb;
+	uint8_t *out = NULL;
 	size_t i;
+	int ret = 0;
+	int alloc = 0;
 
 	for (i = 0; i < sizeof(kAsn1Uint64Tests) / sizeof(kAsn1Uint64Tests[0]);
 	     i++) {
 		const ASN1_UINT64_TEST *test = &kAsn1Uint64Tests[i];
 		CBS cbs;
 		uint64_t value;
-		CBB cbb;
-		uint8_t *out;
 		size_t len;
 
 		CBS_init(&cbs, (const uint8_t *)test->encoding,
 		    test->encoding_len);
 
-		if (!CBS_get_asn1_uint64(&cbs, &value) ||
-		    CBS_len(&cbs) != 0 ||
-		    value != test->value)
-			return 0;
+		CHECK(CBS_get_asn1_uint64(&cbs, &value));
+		CHECK(CBS_len(&cbs) == 0);
+		CHECK(value == test->value);
 
-		if (!CBB_init(&cbb, 0))
-			return 0;
+		CHECK(CBB_init(&cbb, 0));
+		alloc = 1;
+		CHECK_GOTO(CBB_add_asn1_uint64(&cbb, test->value));
+		CHECK_GOTO(CBB_finish(&cbb, &out, &len));
+		alloc = 0;
 
-		if (!CBB_add_asn1_uint64(&cbb, test->value) ||
-		    !CBB_finish(&cbb, &out, &len)) {
-			CBB_cleanup(&cbb);
-			return 0;
-		}
-
-		if (len != test->encoding_len || memcmp(out, test->encoding,
-		    len) != 0) {
-			free(out);
-			return 0;
-		}
+		CHECK_GOTO(len == test->encoding_len);
+		CHECK_GOTO(memcmp(out, test->encoding, len) == 0);
 		free(out);
+		out = NULL;
 	}
 
 	for (i = 0; i < sizeof(kAsn1InvalidUint64Tests)
@@ -664,11 +666,19 @@ test_asn1_uint64(void)
 
 		CBS_init(&cbs, (const uint8_t *)test->encoding,
 		    test->encoding_len);
-		if (CBS_get_asn1_uint64(&cbs, &value))
-			return 0;
+		CHECK(!CBS_get_asn1_uint64(&cbs, &value));
 	}
 
-	return 1;
+	ret = 1;
+
+	if (0) {
+err:
+		if (alloc)
+			CBB_cleanup(&cbb);
+	}
+	free(out);
+
+	return ret;
 }
 
 static int
@@ -679,27 +689,32 @@ test_offset(void)
 	CBS data;
 
 	CBS_init(&data, input, sizeof(input));
-	if (sizeof(input) != 5)
-		return 0;
-
-	if (!(CBS_len(&data) == 5 && CBS_offset(&data) == 0 &&
-	    CBS_get_u8(&data, &v) && v == 1 &&
-	    CBS_len(&data) == 4 && CBS_offset(&data) == 1 &&
-	    CBS_skip(&data, 2) &&
-	    CBS_len(&data) == 2 && CBS_offset(&data) == 3 &&
-	    CBS_get_u8(&data, &v) && v == 4 &&
-	    CBS_get_u8(&data, &v) && v == 5 &&
-	    CBS_len(&data) == 0 && CBS_offset(&data) == 5 &&
-	    !CBS_skip(&data, 1)))
-		return 0;
+	CHECK(sizeof(input) == 5);
+	CHECK(CBS_len(&data) == 5);
+	CHECK(CBS_offset(&data) == 0);
+	CHECK(CBS_get_u8(&data, &v));
+	CHECK(v == 1);
+	CHECK(CBS_len(&data) == 4);
+	CHECK(CBS_offset(&data) == 1);
+	CHECK(CBS_skip(&data, 2));
+	CHECK(CBS_len(&data) == 2);
+	CHECK(CBS_offset(&data) == 3);
+	CHECK(CBS_get_u8(&data, &v));
+	CHECK(v == 4);
+	CHECK(CBS_get_u8(&data, &v));
+	CHECK(v == 5);
+	CHECK(CBS_len(&data) == 0);
+	CHECK(CBS_offset(&data) == 5);
+	CHECK(!CBS_skip(&data, 1));
 
 	CBS_init(&data, input, sizeof(input));
-	if (!(CBS_skip(&data, 2) &&
-	    CBS_len(&data) == 3 && CBS_offset(&data) == 2 &&
-	    CBS_skip(&data, 3) &&
-	    CBS_len(&data) == 0 && CBS_offset(&data) == 5 &&
-	    !CBS_get_u8(&data, &v)))
-		return 0;
+	CHECK(CBS_skip(&data, 2));
+	CHECK(CBS_len(&data) == 3);
+	CHECK(CBS_offset(&data) == 2);
+	CHECK(CBS_skip(&data, 3));
+	CHECK(CBS_len(&data) == 0);
+	CHECK(CBS_offset(&data) == 5);
+	CHECK(!CBS_get_u8(&data, &v));
 
 	return 1;
 }
@@ -714,21 +729,20 @@ test_write_bytes(void)
 	CBS data;
 	char *tmp = NULL;
 
-	if ((tmp = malloc(sizeof(input))) == NULL) {
-		fprintf(stderr, "failed to malloc\n");
-		goto err;
-	}
+	CHECK_GOTO((tmp = malloc(sizeof(input))) != NULL);
 	memset(tmp, 100, sizeof(input));
 
 	CBS_init(&data, input, sizeof(input));
-	if (!(CBS_len(&data) == 6 && CBS_offset(&data) == 0 &&
-	    CBS_get_u8(&data, &v) && v == 102 /* f */ &&
-	    CBS_skip(&data, 1) &&
-	    !CBS_skip(&data, 15) &&
-	    CBS_write_bytes(&data, tmp, sizeof(input), &len) &&
-	    len == 4 && memcmp(input + 2, tmp, len) == 0 &&
-	    tmp[4] == 100 && tmp[5] == 100))
-		goto err;
+	CHECK_GOTO(CBS_len(&data) == 6);
+	CHECK_GOTO(CBS_offset(&data) == 0);
+	CHECK_GOTO(CBS_get_u8(&data, &v));
+	CHECK_GOTO(v == 102 /* f */);
+	CHECK_GOTO(CBS_skip(&data, 1));
+	CHECK_GOTO(!CBS_skip(&data, 15));
+	CHECK_GOTO(CBS_write_bytes(&data, tmp, sizeof(input), &len));
+	CHECK_GOTO(len == 4);
+	CHECK_GOTO(memcmp(input + 2, tmp, len) == 0);
+	CHECK_GOTO(tmp[4] == 100 && tmp[5] == 100);
 
 	ret = 1;
 
@@ -740,24 +754,26 @@ err:
 int
 main(void)
 {
-	if (!test_skip() ||
-	    !test_get_u() ||
-	    !test_get_prefixed() ||
-	    !test_get_prefixed_bad() ||
-	    !test_get_asn1() ||
-	    !test_cbb_basic() ||
-	    !test_cbb_fixed() ||
-	    !test_cbb_finish_child() ||
-	    !test_cbb_misuse() ||
-	    !test_cbb_prefixed() ||
-	    !test_cbb_asn1() ||
-	    !test_indefinite_convert() ||
-	    !test_asn1_uint64() ||
-	    !test_get_optional_asn1_bool() ||
-	    !test_offset() ||
-	    !test_write_bytes())
-		return 1;
-
-	printf("PASS\n");
-	return 0;
+	int failed = 0;
+
+	failed |= !test_skip();
+	failed |= !test_get_u();
+	failed |= !test_get_prefixed();
+	failed |= !test_get_prefixed_bad();
+	failed |= !test_get_asn1();
+	failed |= !test_cbb_basic();
+	failed |= !test_cbb_fixed();
+	failed |= !test_cbb_finish_child();
+	failed |= !test_cbb_misuse();
+	failed |= !test_cbb_prefixed();
+	failed |= !test_cbb_asn1();
+	failed |= !test_indefinite_convert();
+	failed |= !test_asn1_uint64();
+	failed |= !test_get_optional_asn1_bool();
+	failed |= !test_offset();
+	failed |= !test_write_bytes();
+
+	if (!failed)
+		printf("PASS\n");
+	return failed;
 }