summaryrefslogtreecommitdiff
path: root/common/tests
diff options
context:
space:
mode:
Diffstat (limited to 'common/tests')
-rw-r--r--common/tests/Makefile.am3
-rw-r--r--common/tests/test-array.c101
-rw-r--r--common/tests/test-asn1.c53
-rw-r--r--common/tests/test-attrs.c461
-rw-r--r--common/tests/test-base64.c67
-rw-r--r--common/tests/test-buffer.c113
-rw-r--r--common/tests/test-compat.c28
-rw-r--r--common/tests/test-constants.c45
-rw-r--r--common/tests/test-dict.c250
-rw-r--r--common/tests/test-hash.c74
-rw-r--r--common/tests/test-lexer.c126
-rw-r--r--common/tests/test-oid.c45
-rw-r--r--common/tests/test-path.c68
-rw-r--r--common/tests/test-pem.c76
-rw-r--r--common/tests/test-url.c93
-rw-r--r--common/tests/test-utf8.c60
-rw-r--r--common/tests/test-x509.c106
17 files changed, 765 insertions, 1004 deletions
diff --git a/common/tests/Makefile.am b/common/tests/Makefile.am
index 6959c4f..945ed70 100644
--- a/common/tests/Makefile.am
+++ b/common/tests/Makefile.am
@@ -7,7 +7,7 @@ INCLUDES = \
-I$(top_srcdir) \
-I$(srcdir)/.. \
-I$(COMMON) \
- $(CUTEST_CFLAGS)
+ $(TEST_CFLAGS)
LDADD = \
$(NULL)
@@ -61,5 +61,6 @@ endif # WITH_ASN1
TESTS = $(CHECK_PROGS)
LDADD += \
+ $(top_builddir)/common/libp11-test.la \
$(top_builddir)/common/libp11-common.la \
$(CUTEST_LIBS)
diff --git a/common/tests/test-array.c b/common/tests/test-array.c
index a796365..8e8f996 100644
--- a/common/tests/test-array.c
+++ b/common/tests/test-array.c
@@ -33,26 +33,26 @@
*/
#include "config.h"
-#include "CuTest.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "array.h"
+#include "test.h"
static void
-test_p11_array_create (CuTest *tc)
+test_create (void)
{
p11_array *array;
array = p11_array_new (NULL);
- CuAssertPtrNotNull (tc, array);
+ assert_ptr_not_null (array);
p11_array_free (array);
}
static void
-test_p11_array_free_null (CuTest *tc)
+test_free_null (void)
{
p11_array_free (NULL);
}
@@ -65,81 +65,81 @@ destroy_value (void *data)
}
static void
-test_p11_array_free_destroys (CuTest *tc)
+test_free_destroys (void)
{
p11_array *array;
int value = 0;
array = p11_array_new (destroy_value);
- CuAssertPtrNotNull (tc, array);
+ assert_ptr_not_null (array);
if (!p11_array_push (array, &value))
- CuFail (tc, "should not be reached");
+ assert_not_reached ();
p11_array_free (array);
- CuAssertIntEquals (tc, 2, value);
+ assert_num_eq (2, value);
}
static void
-test_p11_array_add (CuTest *tc)
+test_add (void)
{
char *value = "VALUE";
p11_array *array;
array = p11_array_new (NULL);
if (!p11_array_push (array, value))
- CuFail (tc, "should not be reached");
+ assert_not_reached ();
- CuAssertIntEquals (tc, 1, array->num);
- CuAssertPtrEquals (tc, array->elem[0], value);
+ assert_num_eq (1, array->num);
+ assert_ptr_eq (array->elem[0], value);
p11_array_free (array);
}
static void
-test_p11_array_add_remove (CuTest *tc)
+test_add_remove (void)
{
char *value = "VALUE";
p11_array *array;
array = p11_array_new (NULL);
if (!p11_array_push (array, value))
- CuFail (tc, "should not be reached");
+ assert_not_reached ();
- CuAssertIntEquals (tc, 1, array->num);
+ assert_num_eq (1, array->num);
- CuAssertPtrEquals (tc, array->elem[0], value);
+ assert_ptr_eq (array->elem[0], value);
p11_array_remove (array, 0);
- CuAssertIntEquals (tc, 0, array->num);
+ assert_num_eq (0, array->num);
p11_array_free (array);
}
static void
-test_p11_array_remove_destroys (CuTest *tc)
+test_remove_destroys (void)
{
p11_array *array;
int value = 0;
array = p11_array_new (destroy_value);
if (!p11_array_push (array, &value))
- CuFail (tc, "should not be reached");
+ assert_not_reached ();
p11_array_remove (array, 0);
- CuAssertIntEquals (tc, 2, value);
+ assert_num_eq (2, value);
/* should not be destroyed again */
value = 0;
p11_array_free (array);
- CuAssertIntEquals (tc, 0, value);
+ assert_num_eq (0, value);
}
static void
-test_p11_array_remove_and_count (CuTest *tc)
+test_remove_and_count (void)
{
p11_array *array;
int *value;
@@ -147,75 +147,62 @@ test_p11_array_remove_and_count (CuTest *tc)
array = p11_array_new (free);
- CuAssertIntEquals (tc, 0, array->num);
+ assert_num_eq (0, array->num);
for (i = 0; i < 20000; ++i) {
value = malloc (sizeof (int));
*value = i;
if (!p11_array_push (array, value))
- CuFail (tc, "should not be reached");
- CuAssertIntEquals (tc, i + 1, array->num);
+ assert_not_reached ();
+ assert_num_eq (i + 1, array->num);
}
for (i = 10; i < 20000; ++i) {
p11_array_remove (array, 10);
- CuAssertIntEquals (tc, 20010 - (i + 1), array->num);
+ assert_num_eq (20010 - (i + 1), array->num);
}
- CuAssertIntEquals (tc, 10, array->num);
+ assert_num_eq (10, array->num);
p11_array_free (array);
}
static void
-test_p11_array_clear_destroys (CuTest *tc)
+test_clear_destroys (void)
{
p11_array *array;
int value = 0;
array = p11_array_new (destroy_value);
if (!p11_array_push (array, &value))
- CuFail (tc, "should not be reached");
+ assert_not_reached ();
- CuAssertIntEquals (tc, 1, array->num);
+ assert_num_eq (1, array->num);
p11_array_clear (array);
- CuAssertIntEquals (tc, 2, value);
- CuAssertIntEquals (tc, 0, array->num);
+ assert_num_eq (2, value);
+ assert_num_eq (0, array->num);
/* should not be destroyed again */
value = 0;
p11_array_free (array);
- CuAssertIntEquals (tc, 0, value);
+ assert_num_eq (0, value);
}
-
int
-main (void)
+main (int argc,
+ char *argv[])
{
- CuString *output = CuStringNew ();
- CuSuite* suite = CuSuiteNew ();
- int ret;
-
- SUITE_ADD_TEST (suite, test_p11_array_create);
- SUITE_ADD_TEST (suite, test_p11_array_add);
- SUITE_ADD_TEST (suite, test_p11_array_add_remove);
- SUITE_ADD_TEST (suite, test_p11_array_remove_destroys);
- SUITE_ADD_TEST (suite, test_p11_array_remove_and_count);
- SUITE_ADD_TEST (suite, test_p11_array_free_null);
- SUITE_ADD_TEST (suite, test_p11_array_free_destroys);
- SUITE_ADD_TEST (suite, test_p11_array_clear_destroys);
-
- CuSuiteRun (suite);
- CuSuiteSummary (suite, output);
- CuSuiteDetails (suite, output);
- printf ("%s\n", output->buffer);
- ret = suite->failCount;
- CuSuiteDelete (suite);
- CuStringDelete (output);
-
- return ret;
+ p11_test (test_create, "/array/create");
+ p11_test (test_add, "/array/add");
+ p11_test (test_add_remove, "/array/add-remove");
+ p11_test (test_remove_destroys, "/array/remove-destroys");
+ p11_test (test_remove_and_count, "/array/remove-and-count");
+ p11_test (test_free_null, "/array/free-null");
+ p11_test (test_free_destroys, "/array/free-destroys");
+ p11_test (test_clear_destroys, "/array/clear-destroys");
+ return p11_test_run (argc, argv);
}
diff --git a/common/tests/test-asn1.c b/common/tests/test-asn1.c
index 0335fa6..710928c 100644
--- a/common/tests/test-asn1.c
+++ b/common/tests/test-asn1.c
@@ -33,7 +33,7 @@
*/
#include "config.h"
-#include "CuTest.h"
+#include "test.h"
#include "asn1.h"
#include "debug.h"
@@ -49,21 +49,21 @@ struct {
} test;
static void
-setup (CuTest *cu)
+setup (void *unused)
{
test.asn1_defs = p11_asn1_defs_load ();
- CuAssertPtrNotNull (cu, test.asn1_defs);
+ assert_ptr_not_null (test.asn1_defs);
}
static void
-teardown (CuTest *cu)
+teardown (void *unused)
{
p11_dict_free (test.asn1_defs);
memset (&test, 0, sizeof (test));
}
static void
-test_tlv_length (CuTest *cu)
+test_tlv_length (void)
{
struct {
const char *der;
@@ -79,14 +79,10 @@ test_tlv_length (CuTest *cu)
int length;
int i;
- setup (cu);
-
for (i = 0; tlv_lengths[i].der != NULL; i++) {
length = p11_asn1_tlv_length ((const unsigned char *)tlv_lengths[i].der, tlv_lengths[i].der_len);
- CuAssertIntEquals (cu, tlv_lengths[i].expected, length);
+ assert_num_eq (tlv_lengths[i].expected, length);
}
-
- teardown (cu);
}
static const unsigned char test_eku_server_and_client[] = {
@@ -95,7 +91,7 @@ static const unsigned char test_eku_server_and_client[] = {
};
static void
-test_asn1_cache (CuTest *cu)
+test_asn1_cache (void)
{
p11_asn1_cache *cache;
p11_dict *defs;
@@ -103,15 +99,15 @@ test_asn1_cache (CuTest *cu)
node_asn *check;
cache = p11_asn1_cache_new ();
- CuAssertPtrNotNull (cu, cache);
+ assert_ptr_not_null (cache);
defs = p11_asn1_cache_defs (cache);
- CuAssertPtrNotNull (cu, defs);
+ assert_ptr_not_null (defs);
asn = p11_asn1_decode (defs, "PKIX1.ExtKeyUsageSyntax",
test_eku_server_and_client,
sizeof (test_eku_server_and_client), NULL);
- CuAssertPtrNotNull (cu, defs);
+ assert_ptr_not_null (defs);
/* Place the parsed data in the cache */
p11_asn1_cache_take (cache, asn, "PKIX1.ExtKeyUsageSyntax",
@@ -122,38 +118,27 @@ test_asn1_cache (CuTest *cu)
check = p11_asn1_cache_get (cache, "PKIX1.ExtKeyUsageSyntax",
test_eku_server_and_client,
sizeof (test_eku_server_and_client));
- CuAssertPtrEquals (cu, asn, check);
+ assert_ptr_eq (asn, check);
/* Flush should remove it */
p11_asn1_cache_flush (cache);
check = p11_asn1_cache_get (cache, "PKIX1.ExtKeyUsageSyntax",
test_eku_server_and_client,
sizeof (test_eku_server_and_client));
- CuAssertPtrEquals (cu, NULL, check);
+ assert_ptr_eq (NULL, check);
p11_asn1_cache_free (cache);
}
int
-main (void)
+main (int argc,
+ char *argv[])
{
- CuString *output = CuStringNew ();
- CuSuite* suite = CuSuiteNew ();
- int ret;
-
- putenv ("P11_KIT_STRICT=1");
- p11_debug_init ();
-
- SUITE_ADD_TEST (suite, test_tlv_length);
- SUITE_ADD_TEST (suite, test_asn1_cache);
+ p11_fixture (setup, teardown);
+ p11_test (test_tlv_length, "/asn1/tlv_length");
- CuSuiteRun (suite);
- CuSuiteSummary (suite, output);
- CuSuiteDetails (suite, output);
- printf ("%s\n", output->buffer);
- ret = suite->failCount;
- CuSuiteDelete (suite);
- CuStringDelete (output);
+ p11_fixture (NULL, NULL);
+ p11_test (test_asn1_cache, "/asn1/asn1_cache");
- return ret;
+ return p11_test_run (argc, argv);
}
diff --git a/common/tests/test-attrs.c b/common/tests/test-attrs.c
index 324ed90..6087191 100644
--- a/common/tests/test-attrs.c
+++ b/common/tests/test-attrs.c
@@ -33,7 +33,7 @@
*/
#include "config.h"
-#include "CuTest.h"
+#include "test.h"
#include <stdlib.h>
#include <stdio.h>
@@ -43,7 +43,7 @@
#include "debug.h"
static void
-test_terminator (CuTest *tc)
+test_terminator (void)
{
CK_ATTRIBUTE attrs[] = {
{ CKA_LABEL, "label", 5 },
@@ -51,14 +51,14 @@ test_terminator (CuTest *tc)
{ CKA_INVALID },
};
- CuAssertIntEquals (tc, true, p11_attrs_terminator (attrs + 2));
- CuAssertIntEquals (tc, true, p11_attrs_terminator (NULL));
- CuAssertIntEquals (tc, false, p11_attrs_terminator (attrs));
- CuAssertIntEquals (tc, false, p11_attrs_terminator (attrs + 1));
+ assert_num_eq (true, p11_attrs_terminator (attrs + 2));
+ assert_num_eq (true, p11_attrs_terminator (NULL));
+ assert_num_eq (false, p11_attrs_terminator (attrs));
+ assert_num_eq (false, p11_attrs_terminator (attrs + 1));
}
static void
-test_count (CuTest *tc)
+test_count (void)
{
CK_BBOOL vtrue = CK_TRUE;
@@ -72,13 +72,13 @@ test_count (CuTest *tc)
{ CKA_INVALID },
};
- CuAssertIntEquals (tc, 2, p11_attrs_count (attrs));
- CuAssertIntEquals (tc, 0, p11_attrs_count (NULL));
- CuAssertIntEquals (tc, 0, p11_attrs_count (empty));
+ assert_num_eq (2, p11_attrs_count (attrs));
+ assert_num_eq (0, p11_attrs_count (NULL));
+ assert_num_eq (0, p11_attrs_count (empty));
}
static void
-test_build_one (CuTest *tc)
+test_build_one (void)
{
CK_ATTRIBUTE *attrs;
CK_ATTRIBUTE add = { CKA_LABEL, "yay", 3 };
@@ -86,18 +86,18 @@ test_build_one (CuTest *tc)
attrs = p11_attrs_build (NULL, &add, NULL);
/* Test the first attribute */
- CuAssertPtrNotNull (tc, attrs);
- CuAssertTrue (tc, attrs->type == CKA_LABEL);
- CuAssertIntEquals (tc, 3, attrs->ulValueLen);
- CuAssertTrue (tc, memcmp (attrs->pValue, "yay", 3) == 0);
+ assert_ptr_not_null (attrs);
+ assert (attrs->type == CKA_LABEL);
+ assert_num_eq (3, attrs->ulValueLen);
+ assert (memcmp (attrs->pValue, "yay", 3) == 0);
- CuAssertTrue (tc, attrs[1].type == CKA_INVALID);
+ assert (attrs[1].type == CKA_INVALID);
p11_attrs_free (attrs);
}
static void
-test_build_two (CuTest *tc)
+test_build_two (void)
{
CK_ATTRIBUTE *attrs;
CK_ATTRIBUTE one = { CKA_LABEL, "yay", 3 };
@@ -105,23 +105,23 @@ test_build_two (CuTest *tc)
attrs = p11_attrs_build (NULL, &one, &two, NULL);
- CuAssertPtrNotNull (tc, attrs);
- CuAssertTrue (tc, attrs[0].type == CKA_LABEL);
- CuAssertIntEquals (tc, 3, attrs[0].ulValueLen);
- CuAssertTrue (tc, memcmp (attrs[0].pValue, "yay", 3) == 0);
+ assert_ptr_not_null (attrs);
+ assert (attrs[0].type == CKA_LABEL);
+ assert_num_eq (3, attrs[0].ulValueLen);
+ assert (memcmp (attrs[0].pValue, "yay", 3) == 0);
- CuAssertPtrNotNull (tc, attrs);
- CuAssertTrue (tc, attrs[1].type == CKA_VALUE);
- CuAssertIntEquals (tc, 5, attrs[1].ulValueLen);
- CuAssertTrue (tc, memcmp (attrs[1].pValue, "eight", 5) == 0);
+ assert_ptr_not_null (attrs);
+ assert (attrs[1].type == CKA_VALUE);
+ assert_num_eq (5, attrs[1].ulValueLen);
+ assert (memcmp (attrs[1].pValue, "eight", 5) == 0);
- CuAssertTrue (tc, attrs[2].type == CKA_INVALID);
+ assert (attrs[2].type == CKA_INVALID);
p11_attrs_free (attrs);
}
static void
-test_build_invalid (CuTest *tc)
+test_build_invalid (void)
{
CK_ATTRIBUTE *attrs;
CK_ATTRIBUTE one = { CKA_LABEL, "yay", 3 };
@@ -130,23 +130,23 @@ test_build_invalid (CuTest *tc)
attrs = p11_attrs_build (NULL, &one, &invalid, &two, NULL);
- CuAssertPtrNotNull (tc, attrs);
- CuAssertTrue (tc, attrs[0].type == CKA_LABEL);
- CuAssertIntEquals (tc, 3, attrs[0].ulValueLen);
- CuAssertTrue (tc, memcmp (attrs[0].pValue, "yay", 3) == 0);
+ assert_ptr_not_null (attrs);
+ assert (attrs[0].type == CKA_LABEL);
+ assert_num_eq (3, attrs[0].ulValueLen);
+ assert (memcmp (attrs[0].pValue, "yay", 3) == 0);
- CuAssertPtrNotNull (tc, attrs);
- CuAssertTrue (tc, attrs[1].type == CKA_VALUE);
- CuAssertIntEquals (tc, 5, attrs[1].ulValueLen);
- CuAssertTrue (tc, memcmp (attrs[1].pValue, "eight", 5) == 0);
+ assert_ptr_not_null (attrs);
+ assert (attrs[1].type == CKA_VALUE);
+ assert_num_eq (5, attrs[1].ulValueLen);
+ assert (memcmp (attrs[1].pValue, "eight", 5) == 0);
- CuAssertTrue (tc, attrs[2].type == CKA_INVALID);
+ assert (attrs[2].type == CKA_INVALID);
p11_attrs_free (attrs);
}
static void
-test_buildn_two (CuTest *tc)
+test_buildn_two (void)
{
CK_ATTRIBUTE *attrs;
CK_ATTRIBUTE add[] = {
@@ -157,23 +157,23 @@ test_buildn_two (CuTest *tc)
attrs = p11_attrs_buildn (NULL, add, 2);
/* Test the first attribute */
- CuAssertPtrNotNull (tc, attrs);
- CuAssertTrue (tc, attrs->type == CKA_LABEL);
- CuAssertIntEquals (tc, 3, attrs->ulValueLen);
- CuAssertTrue (tc, memcmp (attrs->pValue, "yay", 3) == 0);
+ assert_ptr_not_null (attrs);
+ assert (attrs->type == CKA_LABEL);
+ assert_num_eq (3, attrs->ulValueLen);
+ assert (memcmp (attrs->pValue, "yay", 3) == 0);
- CuAssertPtrNotNull (tc, attrs);
- CuAssertTrue (tc, attrs[1].type == CKA_VALUE);
- CuAssertIntEquals (tc, 5, attrs[1].ulValueLen);
- CuAssertTrue (tc, memcmp (attrs[1].pValue, "eight", 5) == 0);
+ assert_ptr_not_null (attrs);
+ assert (attrs[1].type == CKA_VALUE);
+ assert_num_eq (5, attrs[1].ulValueLen);
+ assert (memcmp (attrs[1].pValue, "eight", 5) == 0);
- CuAssertTrue (tc, attrs[2].type == CKA_INVALID);
+ assert (attrs[2].type == CKA_INVALID);
p11_attrs_free (attrs);
}
static void
-test_buildn_one (CuTest *tc)
+test_buildn_one (void)
{
CK_ATTRIBUTE *attrs;
CK_ATTRIBUTE add = { CKA_LABEL, "yay", 3 };
@@ -181,18 +181,18 @@ test_buildn_one (CuTest *tc)
attrs = p11_attrs_buildn (NULL, &add, 1);
/* Test the first attribute */
- CuAssertPtrNotNull (tc, attrs);
- CuAssertTrue (tc, attrs->type == CKA_LABEL);
- CuAssertIntEquals (tc, 3, attrs->ulValueLen);
- CuAssertTrue (tc, memcmp (attrs->pValue, "yay", 3) == 0);
+ assert_ptr_not_null (attrs);
+ assert (attrs->type == CKA_LABEL);
+ assert_num_eq (3, attrs->ulValueLen);
+ assert (memcmp (attrs->pValue, "yay", 3) == 0);
- CuAssertTrue (tc, attrs[1].type == CKA_INVALID);
+ assert (attrs[1].type == CKA_INVALID);
p11_attrs_free (attrs);
}
static void
-test_build_add (CuTest *tc)
+test_build_add (void)
{
CK_ATTRIBUTE initial[] = {
{ CKA_LABEL, "label", 5 },
@@ -206,28 +206,28 @@ test_build_add (CuTest *tc)
attrs = p11_attrs_buildn (NULL, initial, 2);
attrs = p11_attrs_build (attrs, &one, &two, NULL);
- CuAssertPtrNotNull (tc, attrs);
- CuAssertTrue (tc, attrs[0].type == CKA_LABEL);
- CuAssertIntEquals (tc, 3, attrs[0].ulValueLen);
- CuAssertTrue (tc, memcmp (attrs[0].pValue, "yay", 3) == 0);
+ assert_ptr_not_null (attrs);
+ assert (attrs[0].type == CKA_LABEL);
+ assert_num_eq (3, attrs[0].ulValueLen);
+ assert (memcmp (attrs[0].pValue, "yay", 3) == 0);
- CuAssertPtrNotNull (tc, attrs);
- CuAssertTrue (tc, attrs[1].type == CKA_VALUE);
- CuAssertIntEquals (tc, 4, attrs[1].ulValueLen);
- CuAssertTrue (tc, memcmp (attrs[1].pValue, "nine", 4) == 0);
+ assert_ptr_not_null (attrs);
+ assert (attrs[1].type == CKA_VALUE);
+ assert_num_eq (4, attrs[1].ulValueLen);
+ assert (memcmp (attrs[1].pValue, "nine", 4) == 0);
- CuAssertPtrNotNull (tc, attrs);
- CuAssertTrue (tc, attrs[2].type == CKA_TOKEN);
- CuAssertIntEquals (tc, 1, attrs[2].ulValueLen);
- CuAssertTrue (tc, memcmp (attrs[2].pValue, "\x01", 1) == 0);
+ assert_ptr_not_null (attrs);
+ assert (attrs[2].type == CKA_TOKEN);
+ assert_num_eq (1, attrs[2].ulValueLen);
+ assert (memcmp (attrs[2].pValue, "\x01", 1) == 0);
- CuAssertTrue (tc, attrs[3].type == CKA_INVALID);
+ assert (attrs[3].type == CKA_INVALID);
p11_attrs_free (attrs);
}
static void
-test_build_null (CuTest *tc)
+test_build_null (void)
{
CK_ATTRIBUTE *attrs;
CK_ATTRIBUTE add = { CKA_LABEL, NULL, (CK_ULONG)-1 };
@@ -235,16 +235,16 @@ test_build_null (CuTest *tc)
attrs = p11_attrs_build (NULL, &add, NULL);
/* Test the first attribute */
- CuAssertPtrNotNull (tc, attrs);
- CuAssertTrue (tc, attrs->type == CKA_LABEL);
- CuAssertTrue (tc, attrs->ulValueLen == (CK_ULONG)-1);
- CuAssertPtrEquals (tc, NULL, attrs->pValue);
+ assert_ptr_not_null (attrs);
+ assert (attrs->type == CKA_LABEL);
+ assert (attrs->ulValueLen == (CK_ULONG)-1);
+ assert_ptr_eq (NULL, attrs->pValue);
p11_attrs_free (attrs);
}
static void
-test_dup (CuTest *tc)
+test_dup (void)
{
CK_ATTRIBUTE *attrs;
CK_ATTRIBUTE original[] = {
@@ -256,23 +256,23 @@ test_dup (CuTest *tc)
attrs = p11_attrs_dup (original);
/* Test the first attribute */
- CuAssertPtrNotNull (tc, attrs);
- CuAssertTrue (tc, attrs->type == CKA_LABEL);
- CuAssertIntEquals (tc, 3, attrs->ulValueLen);
- CuAssertTrue (tc, memcmp (attrs->pValue, "yay", 3) == 0);
+ assert_ptr_not_null (attrs);
+ assert (attrs->type == CKA_LABEL);
+ assert_num_eq (3, attrs->ulValueLen);
+ assert (memcmp (attrs->pValue, "yay", 3) == 0);
- CuAssertPtrNotNull (tc, attrs);
- CuAssertTrue (tc, attrs[1].type == CKA_VALUE);
- CuAssertIntEquals (tc, 5, attrs[1].ulValueLen);
- CuAssertTrue (tc, memcmp (attrs[1].pValue, "eight", 5) == 0);
+ assert_ptr_not_null (attrs);
+ assert (attrs[1].type == CKA_VALUE);
+ assert_num_eq (5, attrs[1].ulValueLen);
+ assert (memcmp (attrs[1].pValue, "eight", 5) == 0);
- CuAssertTrue (tc, attrs[2].type == CKA_INVALID);
+ assert (attrs[2].type == CKA_INVALID);
p11_attrs_free (attrs);
}
static void
-test_take (CuTest *tc)
+test_take (void)
{
CK_ATTRIBUTE initial[] = {
{ CKA_LABEL, "label", 5 },
@@ -284,30 +284,30 @@ test_take (CuTest *tc)
attrs = p11_attrs_buildn (NULL, initial, 2);
attrs = p11_attrs_take (attrs, CKA_LABEL, strdup ("boooyah"), 7);
attrs = p11_attrs_take (attrs, CKA_TOKEN, strdup ("\x01"), 1);
- CuAssertPtrNotNull (tc, attrs);
+ assert_ptr_not_null (attrs);
- CuAssertTrue (tc, attrs[0].type == CKA_LABEL);
- CuAssertIntEquals (tc, 7, attrs[0].ulValueLen);
- CuAssertTrue (tc, memcmp (attrs[0].pValue, "boooyah", 7) == 0);
+ assert (attrs[0].type == CKA_LABEL);
+ assert_num_eq (7, attrs[0].ulValueLen);
+ assert (memcmp (attrs[0].pValue, "boooyah", 7) == 0);
- CuAssertPtrNotNull (tc, attrs);
- CuAssertTrue (tc, attrs[1].type == CKA_VALUE);
- CuAssertIntEquals (tc, 4, attrs[1].ulValueLen);
- CuAssertTrue (tc, memcmp (attrs[1].pValue, "nine", 4) == 0);
+ assert_ptr_not_null (attrs);
+ assert (attrs[1].type == CKA_VALUE);
+ assert_num_eq (4, attrs[1].ulValueLen);
+ assert (memcmp (attrs[1].pValue, "nine", 4) == 0);
- CuAssertPtrNotNull (tc, attrs);
- CuAssertTrue (tc, attrs[2].type == CKA_TOKEN);
- CuAssertIntEquals (tc, 1, attrs[2].ulValueLen);
- CuAssertTrue (tc, memcmp (attrs[2].pValue, "\x01", 1) == 0);
+ assert_ptr_not_null (attrs);
+ assert (attrs[2].type == CKA_TOKEN);
+ assert_num_eq (1, attrs[2].ulValueLen);
+ assert (memcmp (attrs[2].pValue, "\x01", 1) == 0);
- CuAssertTrue (tc, attrs[3].type == CKA_INVALID);
+ assert (attrs[3].type == CKA_INVALID);
p11_attrs_free (attrs);
}
static void
-test_merge_replace (CuTest *tc)
+test_merge_replace (void)
{
CK_ATTRIBUTE initial[] = {
{ CKA_LABEL, "label", 5 },
@@ -325,29 +325,29 @@ test_merge_replace (CuTest *tc)
attrs = p11_attrs_buildn (NULL, initial, 2);
merge = p11_attrs_buildn (NULL, extra, 2);
attrs = p11_attrs_merge (attrs, merge, true);
- CuAssertPtrNotNull (tc, attrs);
+ assert_ptr_not_null (attrs);
- CuAssertTrue (tc, attrs[0].type == CKA_LABEL);
- CuAssertIntEquals (tc, 7, attrs[0].ulValueLen);
- CuAssertTrue (tc, memcmp (attrs[0].pValue, "boooyah", 7) == 0);
+ assert (attrs[0].type == CKA_LABEL);
+ assert_num_eq (7, attrs[0].ulValueLen);
+ assert (memcmp (attrs[0].pValue, "boooyah", 7) == 0);
- CuAssertPtrNotNull (tc, attrs);
- CuAssertTrue (tc, attrs[1].type == CKA_VALUE);
- CuAssertIntEquals (tc, 4, attrs[1].ulValueLen);
- CuAssertTrue (tc, memcmp (attrs[1].pValue, "nine", 4) == 0);
+ assert_ptr_not_null (attrs);
+ assert (attrs[1].type == CKA_VALUE);
+ assert_num_eq (4, attrs[1].ulValueLen);
+ assert (memcmp (attrs[1].pValue, "nine", 4) == 0);
- CuAssertPtrNotNull (tc, attrs);
- CuAssertTrue (tc, attrs[2].type == CKA_APPLICATION);
- CuAssertIntEquals (tc, 5, attrs[2].ulValueLen);
- CuAssertTrue (tc, memcmp (attrs[2].pValue, "disco", 5) == 0);
+ assert_ptr_not_null (attrs);
+ assert (attrs[2].type == CKA_APPLICATION);
+ assert_num_eq (5, attrs[2].ulValueLen);
+ assert (memcmp (attrs[2].pValue, "disco", 5) == 0);
- CuAssertTrue (tc, attrs[3].type == CKA_INVALID);
+ assert (attrs[3].type == CKA_INVALID);
p11_attrs_free (attrs);
}
static void
-test_merge_empty (CuTest *tc)
+test_merge_empty (void)
{
CK_ATTRIBUTE extra[] = {
{ CKA_LABEL, "boooyah", 7 },
@@ -359,14 +359,14 @@ test_merge_empty (CuTest *tc)
merge = p11_attrs_buildn (NULL, extra, 2);
attrs = p11_attrs_merge (attrs, merge, true);
- CuAssertPtrNotNull (tc, attrs);
- CuAssertPtrEquals (tc, merge, attrs);
+ assert_ptr_not_null (attrs);
+ assert_ptr_eq (merge, attrs);
p11_attrs_free (attrs);
}
static void
-test_merge_augment (CuTest *tc)
+test_merge_augment (void)
{
CK_ATTRIBUTE initial[] = {
{ CKA_LABEL, "label", 5 },
@@ -384,35 +384,35 @@ test_merge_augment (CuTest *tc)
attrs = p11_attrs_buildn (NULL, initial, 2);
merge = p11_attrs_buildn (NULL, extra, 2);
attrs = p11_attrs_merge (attrs, merge, false);
- CuAssertPtrNotNull (tc, attrs);
+ assert_ptr_not_null (attrs);
- CuAssertTrue (tc, attrs[0].type == CKA_LABEL);
- CuAssertIntEquals (tc, 5, attrs[0].ulValueLen);
- CuAssertTrue (tc, memcmp (attrs[0].pValue, "label", 5) == 0);
+ assert (attrs[0].type == CKA_LABEL);
+ assert_num_eq (5, attrs[0].ulValueLen);
+ assert (memcmp (attrs[0].pValue, "label", 5) == 0);
- CuAssertPtrNotNull (tc, attrs);
- CuAssertTrue (tc, attrs[1].type == CKA_VALUE);
- CuAssertIntEquals (tc, 4, attrs[1].ulValueLen);
- CuAssertTrue (tc, memcmp (attrs[1].pValue, "nine", 4) == 0);
+ assert_ptr_not_null (attrs);
+ assert (attrs[1].type == CKA_VALUE);
+ assert_num_eq (4, attrs[1].ulValueLen);
+ assert (memcmp (attrs[1].pValue, "nine", 4) == 0);
- CuAssertPtrNotNull (tc, attrs);
- CuAssertTrue (tc, attrs[2].type == CKA_APPLICATION);
- CuAssertIntEquals (tc, 5, attrs[2].ulValueLen);
- CuAssertTrue (tc, memcmp (attrs[2].pValue, "disco", 5) == 0);
+ assert_ptr_not_null (attrs);
+ assert (attrs[2].type == CKA_APPLICATION);
+ assert_num_eq (5, attrs[2].ulValueLen);
+ assert (memcmp (attrs[2].pValue, "disco", 5) == 0);
- CuAssertTrue (tc, attrs[3].type == CKA_INVALID);
+ assert (attrs[3].type == CKA_INVALID);
p11_attrs_free (attrs);
}
static void
-test_free_null (CuTest *tc)
+test_free_null (void)
{
p11_attrs_free (NULL);
}
static void
-test_equal (CuTest *tc)
+test_equal (void)
{
char *data = "extra attribute";
CK_ATTRIBUTE one = { CKA_LABEL, "yay", 3 };
@@ -422,19 +422,19 @@ test_equal (CuTest *tc)
CK_ATTRIBUTE overflow = { CKA_VALUE, data, 5 };
CK_ATTRIBUTE content = { CKA_VALUE, "conte", 5 };
- CuAssertTrue (tc, p11_attr_equal (&one, &one));
- CuAssertTrue (tc, !p11_attr_equal (&one, NULL));
- CuAssertTrue (tc, !p11_attr_equal (NULL, &one));
- CuAssertTrue (tc, !p11_attr_equal (&one, &two));
- CuAssertTrue (tc, !p11_attr_equal (&two, &other));
- CuAssertTrue (tc, p11_attr_equal (&other, &overflow));
- CuAssertTrue (tc, !p11_attr_equal (&one, &null));
- CuAssertTrue (tc, !p11_attr_equal (&one, &null));
- CuAssertTrue (tc, !p11_attr_equal (&other, &content));
+ assert (p11_attr_equal (&one, &one));
+ assert (!p11_attr_equal (&one, NULL));
+ assert (!p11_attr_equal (NULL, &one));
+ assert (!p11_attr_equal (&one, &two));
+ assert (!p11_attr_equal (&two, &other));
+ assert (p11_attr_equal (&other, &overflow));
+ assert (!p11_attr_equal (&one, &null));
+ assert (!p11_attr_equal (&one, &null));
+ assert (!p11_attr_equal (&other, &content));
}
static void
-test_hash (CuTest *tc)
+test_hash (void)
{
char *data = "extra attribute";
CK_ATTRIBUTE one = { CKA_LABEL, "yay", 3 };
@@ -446,18 +446,18 @@ test_hash (CuTest *tc)
unsigned int hash;
hash = p11_attr_hash (&one);
- CuAssertTrue (tc, hash != 0);
-
- CuAssertTrue (tc, p11_attr_hash (&one) == hash);
- CuAssertTrue (tc, p11_attr_hash (&two) != hash);
- CuAssertTrue (tc, p11_attr_hash (&other) != hash);
- CuAssertTrue (tc, p11_attr_hash (&overflow) != hash);
- CuAssertTrue (tc, p11_attr_hash (&null) != hash);
- CuAssertTrue (tc, p11_attr_hash (&content) != hash);
+ assert (hash != 0);
+
+ assert (p11_attr_hash (&one) == hash);
+ assert (p11_attr_hash (&two) != hash);
+ assert (p11_attr_hash (&other) != hash);
+ assert (p11_attr_hash (&overflow) != hash);
+ assert (p11_attr_hash (&null) != hash);
+ assert (p11_attr_hash (&content) != hash);
}
static void
-test_to_string (CuTest *tc)
+test_to_string (void)
{
char *data = "extra attribute";
CK_ATTRIBUTE one = { CKA_LABEL, "yay", 3 };
@@ -471,20 +471,20 @@ test_to_string (CuTest *tc)
string = p11_attr_to_string (&one, CKA_INVALID);
- CuAssertStrEquals (tc, "{ CKA_LABEL = (3) \"yay\" }", string);
+ assert_str_eq ("{ CKA_LABEL = (3) \"yay\" }", string);
free (string);
string = p11_attrs_to_string (attrs, -1);
- CuAssertStrEquals (tc, "(2) [ { CKA_LABEL = (3) \"yay\" }, { CKA_VALUE = (5) NOT-PRINTED } ]", string);
+ assert_str_eq ("(2) [ { CKA_LABEL = (3) \"yay\" }, { CKA_VALUE = (5) NOT-PRINTED } ]", string);
free (string);
string = p11_attrs_to_string (attrs, 1);
- CuAssertStrEquals (tc, "(1) [ { CKA_LABEL = (3) \"yay\" } ]", string);
+ assert_str_eq ("(1) [ { CKA_LABEL = (3) \"yay\" } ]", string);
free (string);
}
static void
-test_find (CuTest *tc)
+test_find (void)
{
CK_BBOOL vtrue = CK_TRUE;
CK_ATTRIBUTE *attr;
@@ -496,17 +496,17 @@ test_find (CuTest *tc)
};
attr = p11_attrs_find (attrs, CKA_LABEL);
- CuAssertPtrEquals (tc, attrs + 0, attr);
+ assert_ptr_eq (attrs + 0, attr);
attr = p11_attrs_find (attrs, CKA_TOKEN);
- CuAssertPtrEquals (tc, attrs + 1, attr);
+ assert_ptr_eq (attrs + 1, attr);
attr = p11_attrs_find (attrs, CKA_VALUE);
- CuAssertPtrEquals (tc, NULL, attr);
+ assert_ptr_eq (NULL, attr);
}
static void
-test_findn (CuTest *tc)
+test_findn (void)
{
CK_BBOOL vtrue = CK_TRUE;
CK_ATTRIBUTE *attr;
@@ -517,20 +517,20 @@ test_findn (CuTest *tc)
};
attr = p11_attrs_findn (attrs, 2, CKA_LABEL);
- CuAssertPtrEquals (tc, attrs + 0, attr);
+ assert_ptr_eq (attrs + 0, attr);
attr = p11_attrs_findn (attrs, 2, CKA_TOKEN);
- CuAssertPtrEquals (tc, attrs + 1, attr);
+ assert_ptr_eq (attrs + 1, attr);
attr = p11_attrs_findn (attrs, 2, CKA_VALUE);
- CuAssertPtrEquals (tc, NULL, attr);
+ assert_ptr_eq (NULL, attr);
attr = p11_attrs_findn (attrs, 1, CKA_TOKEN);
- CuAssertPtrEquals (tc, NULL, attr);
+ assert_ptr_eq (NULL, attr);
}
static void
-test_remove (CuTest *tc)
+test_remove (void)
{
CK_BBOOL vtrue = CK_TRUE;
CK_ATTRIBUTE *attr;
@@ -543,25 +543,25 @@ test_remove (CuTest *tc)
};
attrs = p11_attrs_buildn (NULL, initial, 2);
- CuAssertPtrNotNull (tc, attrs);
+ assert_ptr_not_null (attrs);
attr = p11_attrs_find (attrs, CKA_LABEL);
- CuAssertPtrEquals (tc, attrs + 0, attr);
+ assert_ptr_eq (attrs + 0, attr);
ret = p11_attrs_remove (attrs, CKA_LABEL);
- CuAssertIntEquals (tc, CK_TRUE, ret);
+ assert_num_eq (CK_TRUE, ret);
attr = p11_attrs_find (attrs, CKA_LABEL);
- CuAssertPtrEquals (tc, NULL, attr);
+ assert_ptr_eq (NULL, attr);
ret = p11_attrs_remove (attrs, CKA_LABEL);
- CuAssertIntEquals (tc, CK_FALSE, ret);
+ assert_num_eq (CK_FALSE, ret);
p11_attrs_free (attrs);
}
static void
-test_match (CuTest *tc)
+test_match (void)
{
CK_BBOOL vtrue = CK_TRUE;
@@ -588,14 +588,14 @@ test_match (CuTest *tc)
{ CKA_INVALID },
};
- CuAssertTrue (tc, p11_attrs_match (attrs, attrs));
- CuAssertTrue (tc, p11_attrs_match (attrs, subset));
- CuAssertTrue (tc, !p11_attrs_match (attrs, different));
- CuAssertTrue (tc, !p11_attrs_match (attrs, extra));
+ assert (p11_attrs_match (attrs, attrs));
+ assert (p11_attrs_match (attrs, subset));
+ assert (!p11_attrs_match (attrs, different));
+ assert (!p11_attrs_match (attrs, extra));
}
static void
-test_matchn (CuTest *tc)
+test_matchn (void)
{
CK_BBOOL vtrue = CK_TRUE;
@@ -620,13 +620,13 @@ test_matchn (CuTest *tc)
{ CKA_TOKEN, &vtrue, sizeof (vtrue) },
};
- CuAssertTrue (tc, p11_attrs_matchn (attrs, subset, 1));
- CuAssertTrue (tc, !p11_attrs_matchn (attrs, different, 2));
- CuAssertTrue (tc, !p11_attrs_matchn (attrs, extra, 3));
+ assert (p11_attrs_matchn (attrs, subset, 1));
+ assert (!p11_attrs_matchn (attrs, different, 2));
+ assert (!p11_attrs_matchn (attrs, extra, 3));
}
static void
-test_find_bool (CuTest *tc)
+test_find_bool (void)
{
CK_BBOOL vtrue = CK_TRUE;
CK_BBOOL vfalse = CK_FALSE;
@@ -640,13 +640,13 @@ test_find_bool (CuTest *tc)
{ CKA_INVALID },
};
- CuAssertTrue (tc, p11_attrs_find_bool (attrs, CKA_TOKEN, &value) && value == CK_TRUE);
- CuAssertTrue (tc, !p11_attrs_find_bool (attrs, CKA_LABEL, &value));
- CuAssertTrue (tc, !p11_attrs_find_bool (attrs, CKA_VALUE, &value));
+ assert (p11_attrs_find_bool (attrs, CKA_TOKEN, &value) && value == CK_TRUE);
+ assert (!p11_attrs_find_bool (attrs, CKA_LABEL, &value));
+ assert (!p11_attrs_find_bool (attrs, CKA_VALUE, &value));
}
static void
-test_find_ulong (CuTest *tc)
+test_find_ulong (void)
{
CK_ULONG v33 = 33UL;
CK_ULONG v45 = 45UL;
@@ -660,13 +660,13 @@ test_find_ulong (CuTest *tc)
{ CKA_INVALID },
};
- CuAssertTrue (tc, p11_attrs_find_ulong (attrs, CKA_BITS_PER_PIXEL, &value) && value == v33);
- CuAssertTrue (tc, !p11_attrs_find_ulong (attrs, CKA_LABEL, &value));
- CuAssertTrue (tc, !p11_attrs_find_ulong (attrs, CKA_VALUE, &value));
+ assert (p11_attrs_find_ulong (attrs, CKA_BITS_PER_PIXEL, &value) && value == v33);
+ assert (!p11_attrs_find_ulong (attrs, CKA_LABEL, &value));
+ assert (!p11_attrs_find_ulong (attrs, CKA_VALUE, &value));
}
static void
-test_find_value (CuTest *tc)
+test_find_value (void)
{
void *value;
size_t length;
@@ -681,21 +681,21 @@ test_find_value (CuTest *tc)
};
value = p11_attrs_find_value (attrs, CKA_LABEL, &length);
- CuAssertPtrEquals (tc, attrs[3].pValue, value);
- CuAssertIntEquals (tc, 4, length);
+ assert_ptr_eq (attrs[3].pValue, value);
+ assert_num_eq (4, length);
value = p11_attrs_find_value (attrs, CKA_LABEL, NULL);
- CuAssertPtrEquals (tc, attrs[3].pValue, value);
+ assert_ptr_eq (attrs[3].pValue, value);
value = p11_attrs_find_value (attrs, CKA_VALUE, &length);
- CuAssertPtrEquals (tc, NULL, value);
+ assert_ptr_eq (NULL, value);
value = p11_attrs_find_value (attrs, CKA_TOKEN, &length);
- CuAssertPtrEquals (tc, NULL, value);
+ assert_ptr_eq (NULL, value);
}
static void
-test_find_valid (CuTest *tc)
+test_find_valid (void)
{
CK_ATTRIBUTE *attr;
@@ -709,61 +709,46 @@ test_find_valid (CuTest *tc)
};
attr = p11_attrs_find_valid (attrs, CKA_LABEL);
- CuAssertPtrEquals (tc, attrs + 3, attr);
+ assert_ptr_eq (attrs + 3, attr);
attr = p11_attrs_find_valid (attrs, CKA_VALUE);
- CuAssertPtrEquals (tc, attrs + 4, attr);
+ assert_ptr_eq (attrs + 4, attr);
attr = p11_attrs_find_valid (attrs, CKA_TOKEN);
- CuAssertPtrEquals (tc, NULL, attr);
+ assert_ptr_eq (NULL, attr);
}
int
-main (void)
+main (int argc,
+ char *argv[])
{
- CuString *output = CuStringNew ();
- CuSuite* suite = CuSuiteNew ();
- int ret;
-
- putenv ("P11_KIT_STRICT=1");
- p11_debug_init ();
-
- SUITE_ADD_TEST (suite, test_equal);
- SUITE_ADD_TEST (suite, test_hash);
- SUITE_ADD_TEST (suite, test_to_string);
-
- SUITE_ADD_TEST (suite, test_terminator);
- SUITE_ADD_TEST (suite, test_count);
- SUITE_ADD_TEST (suite, test_build_one);
- SUITE_ADD_TEST (suite, test_build_two);
- SUITE_ADD_TEST (suite, test_build_invalid);
- SUITE_ADD_TEST (suite, test_buildn_one);
- SUITE_ADD_TEST (suite, test_buildn_two);
- SUITE_ADD_TEST (suite, test_build_add);
- SUITE_ADD_TEST (suite, test_build_null);
- SUITE_ADD_TEST (suite, test_dup);
- SUITE_ADD_TEST (suite, test_take);
- SUITE_ADD_TEST (suite, test_merge_replace);
- SUITE_ADD_TEST (suite, test_merge_augment);
- SUITE_ADD_TEST (suite, test_merge_empty);
- SUITE_ADD_TEST (suite, test_free_null);
- SUITE_ADD_TEST (suite, test_match);
- SUITE_ADD_TEST (suite, test_matchn);
- SUITE_ADD_TEST (suite, test_find);
- SUITE_ADD_TEST (suite, test_findn);
- SUITE_ADD_TEST (suite, test_find_bool);
- SUITE_ADD_TEST (suite, test_find_ulong);
- SUITE_ADD_TEST (suite, test_find_value);
- SUITE_ADD_TEST (suite, test_find_valid);
- SUITE_ADD_TEST (suite, test_remove);
-
- CuSuiteRun (suite);
- CuSuiteSummary (suite, output);
- CuSuiteDetails (suite, output);
- printf ("%s\n", output->buffer);
- ret = suite->failCount;
- CuSuiteDelete (suite);
- CuStringDelete (output);
-
- return ret;
+ p11_test (test_equal, "/attrs/equal");
+ p11_test (test_hash, "/attrs/hash");
+ p11_test (test_to_string, "/attrs/to-string");
+
+ p11_test (test_terminator, "/attrs/terminator");
+ p11_test (test_count, "/attrs/count");
+ p11_test (test_build_one, "/attrs/build-one");
+ p11_test (test_build_two, "/attrs/build-two");
+ p11_test (test_build_invalid, "/attrs/build-invalid");
+ p11_test (test_buildn_one, "/attrs/buildn-one");
+ p11_test (test_buildn_two, "/attrs/buildn-two");
+ p11_test (test_build_add, "/attrs/build-add");
+ p11_test (test_build_null, "/attrs/build-null");
+ p11_test (test_dup, "/attrs/dup");
+ p11_test (test_take, "/attrs/take");
+ p11_test (test_merge_replace, "/attrs/merge-replace");
+ p11_test (test_merge_augment, "/attrs/merge-augment");
+ p11_test (test_merge_empty, "/attrs/merge-empty");
+ p11_test (test_free_null, "/attrs/free-null");
+ p11_test (test_match, "/attrs/match");
+ p11_test (test_matchn, "/attrs/matchn");
+ p11_test (test_find, "/attrs/find");
+ p11_test (test_findn, "/attrs/findn");
+ p11_test (test_find_bool, "/attrs/find-bool");
+ p11_test (test_find_ulong, "/attrs/find-ulong");
+ p11_test (test_find_value, "/attrs/find-value");
+ p11_test (test_find_valid, "/attrs/find-valid");
+ p11_test (test_remove, "/attrs/remove");
+ return p11_test_run (argc, argv);
}
diff --git a/common/tests/test-base64.c b/common/tests/test-base64.c
index 90c1f49..ce303e8 100644
--- a/common/tests/test-base64.c
+++ b/common/tests/test-base64.c
@@ -33,7 +33,7 @@
*/
#include "config.h"
-#include "CuTest.h"
+#include "test.h"
#include "base64.h"
#include "debug.h"
@@ -45,9 +45,9 @@
#include <stdlib.h>
static void
-check_decode_msg (CuTest *tc,
- const char *file,
+check_decode_msg (const char *file,
int line,
+ const char *function,
const char *input,
ssize_t input_len,
const unsigned char *expected,
@@ -63,33 +63,38 @@ check_decode_msg (CuTest *tc,
length = p11_b64_pton (input, input_len, decoded, sizeof (decoded));
if (expected == NULL) {
- CuAssert_Line (tc, file, line, "decoding should have failed", length < 0);
+ if (length >= 0)
+ p11_test_fail (file, line, function, "decoding should have failed");
} else {
- CuAssert_Line (tc, file, line, "decoding failed", length >= 0);
- CuAssertIntEquals_LineMsg (tc, file, line, "wrong length", expected_len, length);
- CuAssert_Line (tc, file, line, "decoded wrong", memcmp (decoded, expected, length) == 0);
+ if (length < 0)
+ p11_test_fail (file, line, function, "decoding failed");
+ if (expected_len != length)
+ p11_test_fail (file, line, function, "wrong length: (%lu != %lu)",
+ (unsigned long)expected_len, (unsigned long)length);
+ if (memcmp (decoded, expected, length) != 0)
+ p11_test_fail (file, line, function, "decoded wrong");
}
}
-#define check_decode_success(tc, input, input_len, expected, expected_len) \
- check_decode_msg (tc, __FILE__, __LINE__, input, input_len, expected, expected_len)
+#define check_decode_success(input, input_len, expected, expected_len) \
+ check_decode_msg (__FILE__, __LINE__, __FUNCTION__, input, input_len, expected, expected_len)
-#define check_decode_failure(tc, input, input_len) \
- check_decode_msg (tc, __FILE__, __LINE__, input, input_len, NULL, 0)
+#define check_decode_failure(input, input_len) \
+ check_decode_msg (__FILE__, __LINE__, __FUNCTION__, input, input_len, NULL, 0)
static void
-test_decode_simple (CuTest *tc)
+test_decode_simple (void)
{
- check_decode_success (tc, "", 0, (unsigned char *)"", 0);
- check_decode_success (tc, "MQ==", 0, (unsigned char *)"1", 0);
- check_decode_success (tc, "YmxhaAo=", -1, (unsigned char *)"blah\n", -1);
- check_decode_success (tc, "bGVlbGEK", -1, (unsigned char *)"leela\n", -1);
- check_decode_success (tc, "bGVlbG9vCg==", -1, (unsigned char *)"leeloo\n", -1);
+ check_decode_success ("", 0, (unsigned char *)"", 0);
+ check_decode_success ("MQ==", 0, (unsigned char *)"1", 0);
+ check_decode_success ("YmxhaAo=", -1, (unsigned char *)"blah\n", -1);
+ check_decode_success ("bGVlbGEK", -1, (unsigned char *)"leela\n", -1);
+ check_decode_success ("bGVlbG9vCg==", -1, (unsigned char *)"leeloo\n", -1);
}
static void
-test_decode_thawte (CuTest *tc)
+test_decode_thawte (void)
{
const char *input =
"MIIEKjCCAxKgAwIBAgIQYAGXt0an6rS0mtZLL/eQ+zANBgkqhkiG9w0BAQsFADCB"
@@ -186,28 +191,14 @@ test_decode_thawte (CuTest *tc)
0x31, 0xd4, 0x40, 0x1a, 0x62, 0x34, 0x36, 0x3f, 0x35, 0x01, 0xae, 0xac, 0x63, 0xa0,
};
- check_decode_success (tc, input, -1, output, sizeof (output));
+ check_decode_success (input, -1, output, sizeof (output));
}
int
-main (void)
+main (int argc,
+ char *argv[])
{
- CuString *output = CuStringNew ();
- CuSuite* suite = CuSuiteNew ();
- int ret;
-
- putenv ("P11_KIT_STRICT=1");
- p11_debug_init ();
-
- SUITE_ADD_TEST (suite, test_decode_simple);
- SUITE_ADD_TEST (suite, test_decode_thawte);
-
- CuSuiteRun (suite);
- CuSuiteSummary (suite, output);
- CuSuiteDetails (suite, output);
- printf ("%s\n", output->buffer);
- ret = suite->failCount;
- CuSuiteDelete (suite);
- CuStringDelete (output);
- return ret;
+ p11_test (test_decode_simple, "/base64/decode-simple");
+ p11_test (test_decode_thawte, "/base64/decode-thawte");
+ return p11_test_run (argc, argv);
}
diff --git a/common/tests/test-buffer.c b/common/tests/test-buffer.c
index baf7b73..4fd060d 100644
--- a/common/tests/test-buffer.c
+++ b/common/tests/test-buffer.c
@@ -33,7 +33,7 @@
*/
#include "config.h"
-#include "CuTest.h"
+#include "test.h"
#include <stdlib.h>
#include <stdio.h>
@@ -43,41 +43,41 @@
#include "buffer.h"
static void
-test_init_uninit (CuTest *tc)
+test_init_uninit (void)
{
p11_buffer buffer;
p11_buffer_init (&buffer, 10);
- CuAssertPtrNotNull (tc, buffer.data);
- CuAssertIntEquals (tc, 0, buffer.len);
- CuAssertIntEquals (tc, 0, buffer.flags);
- CuAssertTrue (tc, buffer.size >= 10);
- CuAssertPtrNotNull (tc, buffer.ffree);
- CuAssertPtrNotNull (tc, buffer.frealloc);
+ assert_ptr_not_null (buffer.data);
+ assert_num_eq (0, buffer.len);
+ assert_num_eq (0, buffer.flags);
+ assert (buffer.size >= 10);
+ assert_ptr_not_null (buffer.ffree);
+ assert_ptr_not_null (buffer.frealloc);
p11_buffer_uninit (&buffer);
}
static void
-test_append (CuTest *tc)
+test_append (void)
{
p11_buffer buffer;
p11_buffer_init (&buffer, 10);
buffer.len = 5;
p11_buffer_append (&buffer, 35);
- CuAssertIntEquals (tc, 5 + 35, buffer.len);
- CuAssertTrue (tc, buffer.size >= 35 + 5);
+ assert_num_eq (5 + 35, buffer.len);
+ assert (buffer.size >= 35 + 5);
p11_buffer_append (&buffer, 15);
- CuAssertIntEquals (tc, 5 + 35 + 15, buffer.len);
- CuAssertTrue (tc, buffer.size >= 5 + 35 + 15);
+ assert_num_eq (5 + 35 + 15, buffer.len);
+ assert (buffer.size >= 5 + 35 + 15);
p11_buffer_uninit (&buffer);
}
static void
-test_null (CuTest *tc)
+test_null (void)
{
p11_buffer buffer;
@@ -85,7 +85,7 @@ test_null (CuTest *tc)
p11_buffer_add (&buffer, "Blah", -1);
p11_buffer_add (&buffer, " blah", -1);
- CuAssertStrEquals (tc, "Blah blah", buffer.data);
+ assert_str_eq ("Blah blah", buffer.data);
p11_buffer_uninit (&buffer);
}
@@ -109,7 +109,7 @@ mock_free (void *data)
}
static void
-test_init_for_data (CuTest *tc)
+test_init_for_data (void)
{
p11_buffer buffer;
unsigned char *ret;
@@ -121,29 +121,29 @@ test_init_for_data (CuTest *tc)
p11_buffer_init_full (&buffer, (unsigned char *)strdup ("blah"), 4, 0,
mock_realloc, mock_free);
- CuAssertPtrNotNull (tc, buffer.data);
- CuAssertStrEquals (tc, "blah", (char *)buffer.data);
- CuAssertIntEquals (tc, 4, buffer.len);
- CuAssertIntEquals (tc, 0, buffer.flags);
- CuAssertIntEquals (tc, 4, buffer.size);
- CuAssertPtrEquals (tc, mock_free, buffer.ffree);
- CuAssertPtrEquals (tc, mock_realloc, buffer.frealloc);
+ assert_ptr_not_null (buffer.data);
+ assert_str_eq ("blah", (char *)buffer.data);
+ assert_num_eq (4, buffer.len);
+ assert_num_eq (0, buffer.flags);
+ assert_num_eq (4, buffer.size);
+ assert_ptr_eq (mock_free, buffer.ffree);
+ assert_ptr_eq (mock_realloc, buffer.frealloc);
- CuAssertIntEquals (tc, 0, mock_realloced);
- CuAssertIntEquals (tc, 0, mock_freed);
+ assert_num_eq (0, mock_realloced);
+ assert_num_eq (0, mock_freed);
len = buffer.len;
ret = p11_buffer_append (&buffer, 1024);
- CuAssertPtrEquals (tc, (char *)buffer.data + len, ret);
- CuAssertIntEquals (tc, 1, mock_realloced);
+ assert_ptr_eq ((char *)buffer.data + len, ret);
+ assert_num_eq (1, mock_realloced);
p11_buffer_uninit (&buffer);
- CuAssertIntEquals (tc, 1, mock_realloced);
- CuAssertIntEquals (tc, 1, mock_freed);
+ assert_num_eq (1, mock_realloced);
+ assert_num_eq (1, mock_freed);
}
static void
-test_steal (CuTest *tc)
+test_steal (void)
{
p11_buffer buffer;
char *string;
@@ -154,61 +154,46 @@ test_steal (CuTest *tc)
p11_buffer_init_full (&buffer, (unsigned char *)strdup ("blah"), 4,
P11_BUFFER_NULL, mock_realloc, mock_free);
- CuAssertPtrNotNull (tc, buffer.data);
- CuAssertStrEquals (tc, "blah", buffer.data);
+ assert_ptr_not_null (buffer.data);
+ assert_str_eq ("blah", buffer.data);
p11_buffer_add (&buffer, " yada", -1);
- CuAssertStrEquals (tc, "blah yada", buffer.data);
+ assert_str_eq ("blah yada", buffer.data);
string = p11_buffer_steal (&buffer, &length);
p11_buffer_uninit (&buffer);
- CuAssertStrEquals (tc, "blah yada", string);
- CuAssertIntEquals (tc, 9, length);
- CuAssertIntEquals (tc, 0, mock_freed);
+ assert_str_eq ("blah yada", string);
+ assert_num_eq (9, length);
+ assert_num_eq (0, mock_freed);
free (string);
}
static void
-test_add (CuTest *tc)
+test_add (void)
{
p11_buffer buffer;
p11_buffer_init (&buffer, 10);
p11_buffer_add (&buffer, (unsigned char *)"Planet Express", 15);
- CuAssertIntEquals (tc, 15, buffer.len);
- CuAssertStrEquals (tc, "Planet Express", (char *)buffer.data);
- CuAssertTrue (tc, p11_buffer_ok (&buffer));
+ assert_num_eq (15, buffer.len);
+ assert_str_eq ("Planet Express", (char *)buffer.data);
+ assert (p11_buffer_ok (&buffer));
p11_buffer_uninit (&buffer);
}
int
-main (void)
+main (int argc,
+ char *argv[])
{
- CuString *output = CuStringNew ();
- CuSuite* suite = CuSuiteNew ();
- int ret;
-
- putenv ("P11_KIT_STRICT=1");
- p11_debug_init ();
-
- SUITE_ADD_TEST (suite, test_init_uninit);
- SUITE_ADD_TEST (suite, test_init_for_data);
- SUITE_ADD_TEST (suite, test_append);
- SUITE_ADD_TEST (suite, test_null);
- SUITE_ADD_TEST (suite, test_add);
- SUITE_ADD_TEST (suite, test_steal);
-
- CuSuiteRun (suite);
- CuSuiteSummary (suite, output);
- CuSuiteDetails (suite, output);
- printf ("%s\n", output->buffer);
- ret = suite->failCount;
- CuSuiteDelete (suite);
- CuStringDelete (output);
-
- return ret;
+ p11_test (test_init_uninit, "/buffer/init-uninit");
+ p11_test (test_init_for_data, "/buffer/init-for-data");
+ p11_test (test_append, "/buffer/append");
+ p11_test (test_null, "/buffer/null");
+ p11_test (test_add, "/buffer/add");
+ p11_test (test_steal, "/buffer/steal");
+ return p11_test_run (argc, argv);
}
diff --git a/common/tests/test-compat.c b/common/tests/test-compat.c
index 066e723..f1960ce 100644
--- a/common/tests/test-compat.c
+++ b/common/tests/test-compat.c
@@ -33,7 +33,7 @@
*/
#include "config.h"
-#include "CuTest.h"
+#include "test.h"
#include <stdlib.h>
#include <stdio.h>
@@ -42,36 +42,24 @@
#include "compat.h"
static void
-test_strndup (CuTest *tc)
+test_strndup (void)
{
char unterminated[] = { 't', 'e', 's', 't', 'e', 'r', 'o', 'n', 'i', 'o' };
char *res;
res = strndup (unterminated, 6);
- CuAssertStrEquals (tc, res, "tester");
+ assert_str_eq (res, "tester");
free (res);
res = strndup ("test", 6);
- CuAssertStrEquals (tc, res, "test");
+ assert_str_eq (res, "test");
free (res);
}
int
-main (void)
+main (int argc,
+ char *argv[])
{
- CuString *output = CuStringNew ();
- CuSuite* suite = CuSuiteNew ();
- int ret;
-
- SUITE_ADD_TEST (suite, test_strndup);
-
- CuSuiteRun (suite);
- CuSuiteSummary (suite, output);
- CuSuiteDetails (suite, output);
- printf ("%s\n", output->buffer);
- ret = suite->failCount;
- CuSuiteDelete (suite);
- CuStringDelete (output);
-
- return ret;
+ p11_test (test_strndup, "/test/strndup");
+ return p11_test_run (argc, argv);
}
diff --git a/common/tests/test-constants.c b/common/tests/test-constants.c
index 4c2f3eb..76c44d2 100644
--- a/common/tests/test-constants.c
+++ b/common/tests/test-constants.c
@@ -33,7 +33,7 @@
*/
#include "config.h"
-#include "CuTest.h"
+#include "test.h"
#include <stdlib.h>
#include <stdio.h>
@@ -44,7 +44,7 @@
#include "debug.h"
static void
-test_constants (CuTest *tc)
+test_constants (void)
{
const p11_constant *constant;
p11_dict *nicks, *names;
@@ -72,29 +72,27 @@ test_constants (CuTest *tc)
for (j = 0; constants[j] != NULL; j++) {
constant = constants[j];
for (i = 1; constant[i].value != CKA_INVALID; i++) {
- if (constant[i].value < constant[i - 1].value) {
- CuFail_Line (tc, __FILE__, __LINE__,
- "attr constant out of order", constant[i].name);
- }
+ if (constant[i].value < constant[i - 1].value)
+ assert_fail ("attr constant out of order", constant[i].name);
}
for (i = 0; constant[i].value != CKA_INVALID; i++) {
- CuAssertPtrNotNull (tc, constant[i].name);
+ assert_ptr_not_null (constant[i].name);
if (constant[i].nick) {
- CuAssertStrEquals (tc, constant[i].nick,
- p11_constant_nick (constant, constant[i].value));
+ assert_str_eq (constant[i].nick,
+ p11_constant_nick (constant, constant[i].value));
}
- CuAssertStrEquals (tc, constant[i].name,
- p11_constant_name (constant, constant[i].value));
+ assert_str_eq (constant[i].name,
+ p11_constant_name (constant, constant[i].value));
if (constant[i].nick) {
check = p11_constant_resolve (nicks, constant[i].nick);
- CuAssertIntEquals (tc, constant[i].value, check);
+ assert_num_eq (constant[i].value, check);
}
check = p11_constant_resolve (names, constant[i].name);
- CuAssertIntEquals (tc, constant[i].value, check);
+ assert_num_eq (constant[i].value, check);
}
}
@@ -103,23 +101,10 @@ test_constants (CuTest *tc)
}
int
-main (void)
+main (int argc,
+ char *argv[])
{
- CuString *output = CuStringNew ();
- CuSuite* suite = CuSuiteNew ();
- int ret;
-
- putenv ("P11_KIT_STRICT=1");
- p11_debug_init ();
- SUITE_ADD_TEST (suite, test_constants);
-
- CuSuiteRun (suite);
- CuSuiteSummary (suite, output);
- CuSuiteDetails (suite, output);
- printf ("%s\n", output->buffer);
- ret = suite->failCount;
- CuSuiteDelete (suite);
- CuStringDelete (output);
+ p11_test (test_constants, "/constants/all");
- return ret;
+ return p11_test_run (argc, argv);
}
diff --git a/common/tests/test-dict.c b/common/tests/test-dict.c
index fc40b07..7c6f851 100644
--- a/common/tests/test-dict.c
+++ b/common/tests/test-dict.c
@@ -33,7 +33,7 @@
*/
#include "config.h"
-#include "CuTest.h"
+#include "test.h"
#include <assert.h>
#include <stdlib.h>
@@ -43,17 +43,17 @@
#include "dict.h"
static void
-test_create (CuTest *tc)
+test_create (void)
{
p11_dict *map;
map = p11_dict_new (p11_dict_direct_hash, p11_dict_direct_equal, NULL, NULL);
- CuAssertPtrNotNull (tc, map);
+ assert_ptr_not_null (map);
p11_dict_free (map);
}
static void
-test_free_null (CuTest *tc)
+test_free_null (void)
{
p11_dict_free (NULL);
}
@@ -98,24 +98,24 @@ value_destroy (void *data)
}
static void
-test_free_destroys (CuTest *tc)
+test_free_destroys (void)
{
p11_dict *map;
Key key = { 8, 0 };
int value = 0;
map = p11_dict_new (key_hash, key_equal, key_destroy, value_destroy);
- CuAssertPtrNotNull (tc, map);
+ assert_ptr_not_null (map);
if (!p11_dict_set (map, &key, &value))
- CuFail (tc, "should not be reached");
+ assert_not_reached ();
p11_dict_free (map);
- CuAssertIntEquals (tc, true, key.freed);
- CuAssertIntEquals (tc, 2, value);
+ assert_num_eq (true, key.freed);
+ assert_num_eq (2, value);
}
static void
-test_iterate (CuTest *tc)
+test_iterate (void)
{
p11_dict *map;
p11_dictiter iter;
@@ -126,19 +126,19 @@ test_iterate (CuTest *tc)
int ret;
map = p11_dict_new (p11_dict_direct_hash, p11_dict_direct_equal, NULL, NULL);
- CuAssertPtrNotNull (tc, map);
+ assert_ptr_not_null (map);
if (!p11_dict_set (map, &key, &value))
- CuFail (tc, "should not be reached");
+ assert_not_reached ();
p11_dict_iterate (map, &iter);
ret = p11_dict_next (&iter, &pkey, &pvalue);
- CuAssertIntEquals (tc, 1, ret);
- CuAssertPtrEquals (tc, pkey, &key);
- CuAssertPtrEquals (tc, pvalue, &value);
+ assert_num_eq (1, ret);
+ assert_ptr_eq (pkey, &key);
+ assert_ptr_eq (pvalue, &value);
ret = p11_dict_next (&iter, &pkey, &pvalue);
- CuAssertIntEquals (tc, 0, ret);
+ assert_num_eq (0, ret);
p11_dict_free (map);
}
@@ -153,7 +153,7 @@ compar_strings (const void *one,
}
static void
-test_iterate_remove (CuTest *tc)
+test_iterate_remove (void)
{
p11_dict *map;
p11_dictiter iter;
@@ -165,45 +165,45 @@ test_iterate_remove (CuTest *tc)
int i;
map = p11_dict_new (p11_dict_str_hash, p11_dict_str_equal, NULL, NULL);
- CuAssertPtrNotNull (tc, map);
+ assert_ptr_not_null (map);
for (i = 0; i < 3; i++) {
if (!p11_dict_set (map, keys[i], values[i]))
- CuFail (tc, "should not be reached");
+ assert_not_reached ();
}
p11_dict_iterate (map, &iter);
ret = p11_dict_next (&iter, &okeys[0], &ovalues[0]);
- CuAssertIntEquals (tc, true, ret);
+ assert_num_eq (true, ret);
ret = p11_dict_next (&iter, &okeys[1], &ovalues[1]);
- CuAssertIntEquals (tc, true, ret);
+ assert_num_eq (true, ret);
if (!p11_dict_remove (map, okeys[1]))
- CuFail (tc, "should not be reached");
+ assert_not_reached ();
ret = p11_dict_next (&iter, &okeys[2], &ovalues[2]);
- CuAssertIntEquals (tc, true, ret);
+ assert_num_eq (true, ret);
ret = p11_dict_next (&iter, NULL, NULL);
- CuAssertIntEquals (tc, false, ret);
+ assert_num_eq (false, ret);
- CuAssertIntEquals (tc, 2, p11_dict_size (map));
+ assert_num_eq (2, p11_dict_size (map));
p11_dict_free (map);
qsort (okeys, 3, sizeof (void *), compar_strings);
qsort (ovalues, 3, sizeof (void *), compar_strings);
for (i = 0; i < 3; i++) {
- CuAssertStrEquals (tc, keys[i], okeys[i]);
- CuAssertPtrEquals (tc, keys[i], okeys[i]);
- CuAssertStrEquals (tc, values[i], ovalues[i]);
- CuAssertPtrEquals (tc, values[i], ovalues[i]);
+ assert_str_eq (keys[i], okeys[i]);
+ assert_ptr_eq (keys[i], okeys[i]);
+ assert_str_eq (values[i], ovalues[i]);
+ assert_ptr_eq (values[i], ovalues[i]);
}
}
static void
-test_set_get (CuTest *tc)
+test_set_get (void)
{
char *key = "KEY";
char *value = "VALUE";
@@ -213,13 +213,13 @@ test_set_get (CuTest *tc)
map = p11_dict_new (p11_dict_str_hash, p11_dict_str_equal, NULL, NULL);
p11_dict_set (map, key, value);
check = p11_dict_get (map, key);
- CuAssertPtrEquals (tc, check, value);
+ assert_ptr_eq (check, value);
p11_dict_free (map);
}
static void
-test_set_get_remove (CuTest *tc)
+test_set_get_remove (void)
{
char *key = "KEY";
char *value = "VALUE";
@@ -230,24 +230,24 @@ test_set_get_remove (CuTest *tc)
map = p11_dict_new (p11_dict_str_hash, p11_dict_str_equal, NULL, NULL);
if (!p11_dict_set (map, key, value))
- CuFail (tc, "should not be reached");
+ assert_not_reached ();
check = p11_dict_get (map, key);
- CuAssertPtrEquals (tc, check, value);
+ assert_ptr_eq (check, value);
ret = p11_dict_remove (map, key);
- CuAssertIntEquals (tc, true, ret);
+ assert_num_eq (true, ret);
ret = p11_dict_remove (map, key);
- CuAssertIntEquals (tc, false, ret);
+ assert_num_eq (false, ret);
check = p11_dict_get (map, key);
- CuAssert (tc, "should be null", check == NULL);
+ assert (check == NULL);
p11_dict_free (map);
}
static void
-test_set_clear (CuTest *tc)
+test_set_clear (void)
{
char *key = "KEY";
char *value = "VALUE";
@@ -257,18 +257,18 @@ test_set_clear (CuTest *tc)
map = p11_dict_new (p11_dict_direct_hash, p11_dict_direct_equal, NULL, NULL);
if (!p11_dict_set (map, key, value))
- CuFail (tc, "should not be reached");
+ assert_not_reached ();
p11_dict_clear (map);
check = p11_dict_get (map, key);
- CuAssert (tc, "should be null", check == NULL);
+ assert (check == NULL);
p11_dict_free (map);
}
static void
-test_remove_destroys (CuTest *tc)
+test_remove_destroys (void)
{
p11_dict *map;
Key key = { 8, 0 };
@@ -276,23 +276,23 @@ test_remove_destroys (CuTest *tc)
bool ret;
map = p11_dict_new (key_hash, key_equal, key_destroy, value_destroy);
- CuAssertPtrNotNull (tc, map);
+ assert_ptr_not_null (map);
if (!p11_dict_set (map, &key, &value))
- CuFail (tc, "should not be reached");
+ assert_not_reached ();
ret = p11_dict_remove (map, &key);
- CuAssertIntEquals (tc, true, ret);
- CuAssertIntEquals (tc, true, key.freed);
- CuAssertIntEquals (tc, 2, value);
+ assert_num_eq (true, ret);
+ assert_num_eq (true, key.freed);
+ assert_num_eq (2, value);
/* should not be destroyed again */
key.freed = false;
value = 0;
ret = p11_dict_remove (map, &key);
- CuAssertIntEquals (tc, false, ret);
- CuAssertIntEquals (tc, false, key.freed);
- CuAssertIntEquals (tc, 0, value);
+ assert_num_eq (false, ret);
+ assert_num_eq (false, key.freed);
+ assert_num_eq (0, value);
/* should not be destroyed again */
key.freed = false;
@@ -300,12 +300,12 @@ test_remove_destroys (CuTest *tc)
p11_dict_free (map);
- CuAssertIntEquals (tc, false, key.freed);
- CuAssertIntEquals (tc, 0, value);
+ assert_num_eq (false, key.freed);
+ assert_num_eq (0, value);
}
static void
-test_set_destroys (CuTest *tc)
+test_set_destroys (void)
{
p11_dict *map;
Key key = { 8, 0 };
@@ -314,88 +314,88 @@ test_set_destroys (CuTest *tc)
bool ret;
map = p11_dict_new (key_hash, key_equal, key_destroy, value_destroy);
- CuAssertPtrNotNull (tc, map);
+ assert_ptr_not_null (map);
if (!p11_dict_set (map, &key, &value))
- CuFail (tc, "should not be reached");
+ assert_not_reached ();
key.freed = key2.freed = false;
value = value2 = 0;
/* Setting same key and value, should not be destroyed */
ret = p11_dict_set (map, &key, &value);
- CuAssertIntEquals (tc, true, ret);
- CuAssertIntEquals (tc, false, key.freed);
- CuAssertIntEquals (tc, false, key2.freed);
- CuAssertIntEquals (tc, 0, value);
- CuAssertIntEquals (tc, 0, value2);
+ assert_num_eq (true, ret);
+ assert_num_eq (false, key.freed);
+ assert_num_eq (false, key2.freed);
+ assert_num_eq (0, value);
+ assert_num_eq (0, value2);
key.freed = key2.freed = false;
value = value2 = 0;
/* Setting a new key same value, key should be destroyed */
ret = p11_dict_set (map, &key2, &value);
- CuAssertIntEquals (tc, true, ret);
- CuAssertIntEquals (tc, true, key.freed);
- CuAssertIntEquals (tc, false, key2.freed);
- CuAssertIntEquals (tc, 0, value);
- CuAssertIntEquals (tc, 0, value2);
+ assert_num_eq (true, ret);
+ assert_num_eq (true, key.freed);
+ assert_num_eq (false, key2.freed);
+ assert_num_eq (0, value);
+ assert_num_eq (0, value2);
key.freed = key2.freed = false;
value = value2 = 0;
/* Setting same key, new value, value should be destroyed */
ret = p11_dict_set (map, &key2, &value2);
- CuAssertIntEquals (tc, true, ret);
- CuAssertIntEquals (tc, false, key.freed);
- CuAssertIntEquals (tc, false, key2.freed);
- CuAssertIntEquals (tc, 2, value);
- CuAssertIntEquals (tc, 0, value2);
+ assert_num_eq (true, ret);
+ assert_num_eq (false, key.freed);
+ assert_num_eq (false, key2.freed);
+ assert_num_eq (2, value);
+ assert_num_eq (0, value2);
key.freed = key2.freed = false;
value = value2 = 0;
/* Setting new key new value, both should be destroyed */
ret = p11_dict_set (map, &key, &value);
- CuAssertIntEquals (tc, true, ret);
- CuAssertIntEquals (tc, false, key.freed);
- CuAssertIntEquals (tc, true, key2.freed);
- CuAssertIntEquals (tc, 0, value);
- CuAssertIntEquals (tc, 2, value2);
+ assert_num_eq (true, ret);
+ assert_num_eq (false, key.freed);
+ assert_num_eq (true, key2.freed);
+ assert_num_eq (0, value);
+ assert_num_eq (2, value2);
key.freed = key2.freed = false;
value = value2 = 0;
p11_dict_free (map);
- CuAssertIntEquals (tc, true, key.freed);
- CuAssertIntEquals (tc, 2, value);
- CuAssertIntEquals (tc, false, key2.freed);
- CuAssertIntEquals (tc, 0, value2);
+ assert_num_eq (true, key.freed);
+ assert_num_eq (2, value);
+ assert_num_eq (false, key2.freed);
+ assert_num_eq (0, value2);
}
static void
-test_clear_destroys (CuTest *tc)
+test_clear_destroys (void)
{
p11_dict *map;
Key key = { 18, 0 };
int value = 0;
map = p11_dict_new (key_hash, key_equal, key_destroy, value_destroy);
- CuAssertPtrNotNull (tc, map);
+ assert_ptr_not_null (map);
if (!p11_dict_set (map, &key, &value))
- CuFail (tc, "should not be reached");
+ assert_not_reached ();
p11_dict_clear (map);
- CuAssertIntEquals (tc, true, key.freed);
- CuAssertIntEquals (tc, 2, value);
+ assert_num_eq (true, key.freed);
+ assert_num_eq (2, value);
/* should not be destroyed again */
key.freed = false;
value = 0;
p11_dict_clear (map);
- CuAssertIntEquals (tc, false, key.freed);
- CuAssertIntEquals (tc, 0, value);
+ assert_num_eq (false, key.freed);
+ assert_num_eq (0, value);
/* should not be destroyed again */
key.freed = false;
@@ -403,8 +403,8 @@ test_clear_destroys (CuTest *tc)
p11_dict_free (map);
- CuAssertIntEquals (tc, false, key.freed);
- CuAssertIntEquals (tc, 0, value);
+ assert_num_eq (false, key.freed);
+ assert_num_eq (0, value);
}
static unsigned int
@@ -415,7 +415,7 @@ test_hash_intptr_with_collisions (const void *data)
}
static void
-test_hash_add_check_lots_and_collisions (CuTest *tc)
+test_hash_add_check_lots_and_collisions (void)
{
p11_dict *map;
int *value;
@@ -428,20 +428,20 @@ test_hash_add_check_lots_and_collisions (CuTest *tc)
value = malloc (sizeof (int));
*value = i;
if (!p11_dict_set (map, value, value))
- CuFail (tc, "should not be reached");
+ assert_not_reached ();
}
for (i = 0; i < 20000; ++i) {
value = p11_dict_get (map, &i);
- CuAssertPtrNotNull (tc, value);
- CuAssertIntEquals (tc, i, *value);
+ assert_ptr_not_null (value);
+ assert_num_eq (i, *value);
}
p11_dict_free (map);
}
static void
-test_hash_count (CuTest *tc)
+test_hash_count (void)
{
p11_dict *map;
int *value;
@@ -450,30 +450,30 @@ test_hash_count (CuTest *tc)
map = p11_dict_new (p11_dict_intptr_hash, p11_dict_intptr_equal, NULL, free);
- CuAssertIntEquals (tc, 0, p11_dict_size (map));
+ assert_num_eq (0, p11_dict_size (map));
for (i = 0; i < 20000; ++i) {
value = malloc (sizeof (int));
*value = i;
if (!p11_dict_set (map, value, value))
- CuFail (tc, "should not be reached");
- CuAssertIntEquals (tc, i + 1, p11_dict_size (map));
+ assert_not_reached ();
+ assert_num_eq (i + 1, p11_dict_size (map));
}
for (i = 0; i < 20000; ++i) {
ret = p11_dict_remove (map, &i);
- CuAssertIntEquals (tc, true, ret);
- CuAssertIntEquals (tc, 20000 - (i + 1), p11_dict_size (map));
+ assert_num_eq (true, ret);
+ assert_num_eq (20000 - (i + 1), p11_dict_size (map));
}
p11_dict_clear (map);
- CuAssertIntEquals (tc, 0, p11_dict_size (map));
+ assert_num_eq (0, p11_dict_size (map));
p11_dict_free (map);
}
static void
-test_hash_ulongptr (CuTest *tc)
+test_hash_ulongptr (void)
{
p11_dict *map;
unsigned long *value;
@@ -485,47 +485,35 @@ test_hash_ulongptr (CuTest *tc)
value = malloc (sizeof (unsigned long));
*value = i;
if (!p11_dict_set (map, value, value))
- CuFail (tc, "should not be reached");
+ assert_not_reached ();
}
for (i = 0; i < 20000; ++i) {
value = p11_dict_get (map, &i);
- CuAssertPtrNotNull (tc, value);
- CuAssertIntEquals (tc, i, *value);
+ assert_ptr_not_null (value);
+ assert_num_eq (i, *value);
}
p11_dict_free (map);
}
int
-main (void)
+main (int argc,
+ char *argv[])
{
- CuString *output = CuStringNew ();
- CuSuite* suite = CuSuiteNew ();
- int ret;
-
- SUITE_ADD_TEST (suite, test_create);
- SUITE_ADD_TEST (suite, test_set_get);
- SUITE_ADD_TEST (suite, test_set_get_remove);
- SUITE_ADD_TEST (suite, test_remove_destroys);
- SUITE_ADD_TEST (suite, test_set_clear);
- SUITE_ADD_TEST (suite, test_set_destroys);
- SUITE_ADD_TEST (suite, test_clear_destroys);
- SUITE_ADD_TEST (suite, test_free_null);
- SUITE_ADD_TEST (suite, test_free_destroys);
- SUITE_ADD_TEST (suite, test_iterate);
- SUITE_ADD_TEST (suite, test_iterate_remove);
- SUITE_ADD_TEST (suite, test_hash_add_check_lots_and_collisions);
- SUITE_ADD_TEST (suite, test_hash_count);
- SUITE_ADD_TEST (suite, test_hash_ulongptr);
-
- CuSuiteRun (suite);
- CuSuiteSummary (suite, output);
- CuSuiteDetails (suite, output);
- printf ("%s\n", output->buffer);
- ret = suite->failCount;
- CuSuiteDelete (suite);
- CuStringDelete (output);
-
- return ret;
+ p11_test (test_create, "/dict/create");
+ p11_test (test_set_get, "/dict/set-get");
+ p11_test (test_set_get_remove, "/dict/set-get-remove");
+ p11_test (test_remove_destroys, "/dict/remove-destroys");
+ p11_test (test_set_clear, "/dict/set-clear");
+ p11_test (test_set_destroys, "/dict/set-destroys");
+ p11_test (test_clear_destroys, "/dict/clear-destroys");
+ p11_test (test_free_null, "/dict/free-null");
+ p11_test (test_free_destroys, "/dict/free-destroys");
+ p11_test (test_iterate, "/dict/iterate");
+ p11_test (test_iterate_remove, "/dict/iterate-remove");
+ p11_test (test_hash_add_check_lots_and_collisions, "/dict/add-check-lots-and-collisions");
+ p11_test (test_hash_count, "/dict/count");
+ p11_test (test_hash_ulongptr, "/dict/ulongptr");
+ return p11_test_run (argc, argv);
}
diff --git a/common/tests/test-hash.c b/common/tests/test-hash.c
index eecf09b..c679cad 100644
--- a/common/tests/test-hash.c
+++ b/common/tests/test-hash.c
@@ -33,7 +33,7 @@
*/
#include "config.h"
-#include "CuTest.h"
+#include "test.h"
#include <assert.h>
#include <stdint.h>
@@ -56,7 +56,7 @@ const char *sha1_checksum[] = {
};
static void
-test_sha1 (CuTest *cu)
+test_sha1 (void)
{
unsigned char checksum[P11_HASH_SHA1_LEN];
size_t len;
@@ -67,28 +67,28 @@ test_sha1 (CuTest *cu)
len = strlen (sha1_input[i]);
p11_hash_sha1 (checksum, sha1_input[i], len, NULL);
- CuAssertTrue (cu, memcmp (sha1_checksum[i], checksum, P11_HASH_SHA1_LEN) == 0);
+ assert (memcmp (sha1_checksum[i], checksum, P11_HASH_SHA1_LEN) == 0);
if (len > 6) {
p11_hash_sha1 (checksum, sha1_input[i], 6, sha1_input[i] + 6, len - 6, NULL);
- CuAssertTrue (cu, memcmp (sha1_checksum[i], checksum, P11_HASH_SHA1_LEN) == 0);
+ assert (memcmp (sha1_checksum[i], checksum, P11_HASH_SHA1_LEN) == 0);
}
}
}
static void
-test_sha1_long (CuTest *cu)
+test_sha1_long (void)
{
unsigned char checksum[P11_HASH_SHA1_LEN];
char *expected = "\x34\xAA\x97\x3C\xD4\xC4\xDA\xA4\xF6\x1E\xEB\x2B\xDB\xAD\x27\x31\x65\x34\x01\x6F";
char *input;
input = malloc (1000000);
- CuAssertTrue (cu, input != NULL);
+ assert (input != NULL);
memset (input, 'a', 1000000);
p11_hash_sha1 (checksum, input, 1000000, NULL);
- CuAssertTrue (cu, memcmp (expected, checksum, P11_HASH_SHA1_LEN) == 0);
+ assert (memcmp (expected, checksum, P11_HASH_SHA1_LEN) == 0);
free (input);
}
@@ -112,7 +112,7 @@ const char *md5_checksum[] = {
};
static void
-test_md5 (CuTest *cu)
+test_md5 (void)
{
unsigned char checksum[P11_HASH_MD5_LEN];
size_t len;
@@ -123,17 +123,17 @@ test_md5 (CuTest *cu)
len = strlen (md5_input[i]);
p11_hash_md5 (checksum, md5_input[i], len, NULL);
- CuAssertTrue (cu, memcmp (md5_checksum[i], checksum, P11_HASH_MD5_LEN) == 0);
+ assert (memcmp (md5_checksum[i], checksum, P11_HASH_MD5_LEN) == 0);
if (len > 5) {
p11_hash_md5 (checksum, md5_input[i], 5, md5_input[i] + 5, len - 5, NULL);
- CuAssertTrue (cu, memcmp (md5_checksum[i], checksum, P11_HASH_MD5_LEN) == 0);
+ assert (memcmp (md5_checksum[i], checksum, P11_HASH_MD5_LEN) == 0);
}
}
}
static void
-test_murmur2 (CuTest *cu)
+test_murmur3 (void)
{
uint32_t one, two, four, seven, eleven, split;
@@ -146,23 +146,23 @@ test_murmur2 (CuTest *cu)
p11_hash_murmur3 ((unsigned char *)&eleven, "eleven", 6, NULL);
p11_hash_murmur3 ((unsigned char *)&split, "ele", 3, "ven", 3, NULL);
- CuAssertTrue (cu, one != two);
- CuAssertTrue (cu, one != four);
- CuAssertTrue (cu, one != seven);
- CuAssertTrue (cu, one != eleven);
+ assert (one != two);
+ assert (one != four);
+ assert (one != seven);
+ assert (one != eleven);
- CuAssertTrue (cu, two != four);
- CuAssertTrue (cu, two != seven);
- CuAssertTrue (cu, two != eleven);
+ assert (two != four);
+ assert (two != seven);
+ assert (two != eleven);
- CuAssertTrue (cu, four != seven);
- CuAssertTrue (cu, four != eleven);
+ assert (four != seven);
+ assert (four != eleven);
- CuAssertTrue (cu, split == eleven);
+ assert (split == eleven);
}
static void
-test_murmur2_incr (CuTest *cu)
+test_murmur3_incr (void)
{
uint32_t first, second;
@@ -182,29 +182,17 @@ test_murmur2_incr (CuTest *cu)
"!", (size_t)1,
NULL);
- CuAssertIntEquals (cu, first, second);
+ assert_num_eq (first, second);
}
int
-main (void)
+main (int argc,
+ char *argv[])
{
- CuString *output = CuStringNew ();
- CuSuite* suite = CuSuiteNew ();
- int ret;
-
- SUITE_ADD_TEST (suite, test_sha1);
- SUITE_ADD_TEST (suite, test_sha1_long);
- SUITE_ADD_TEST (suite, test_md5);
- SUITE_ADD_TEST (suite, test_murmur2);
- SUITE_ADD_TEST (suite, test_murmur2_incr);
-
- CuSuiteRun (suite);
- CuSuiteSummary (suite, output);
- CuSuiteDetails (suite, output);
- printf ("%s\n", output->buffer);
- ret = suite->failCount;
- CuSuiteDelete (suite);
- CuStringDelete (output);
-
- return ret;
+ p11_test (test_sha1, "/hash/sha1");
+ p11_test (test_sha1_long, "/hash/sha1-long");
+ p11_test (test_md5, "/hash/md5");
+ p11_test (test_murmur3, "/hash/murmur3");
+ p11_test (test_murmur3_incr, "/hash/murmur3-incr");
+ return p11_test_run (argc, argv);
}
diff --git a/common/tests/test-lexer.c b/common/tests/test-lexer.c
index 58d5d65..ff18a89 100644
--- a/common/tests/test-lexer.c
+++ b/common/tests/test-lexer.c
@@ -33,7 +33,7 @@
*/
#include "config.h"
-#include "CuTest.h"
+#include "test.h"
#include <stdlib.h>
#include <stdio.h>
@@ -62,9 +62,9 @@ on_pem_get_type (const char *type,
}
static void
-check_lex_msg (CuTest *tc,
- const char *file,
+check_lex_msg (const char *file,
int line,
+ const char *function,
const expected_tok *expected,
const char *input,
bool failure)
@@ -77,60 +77,63 @@ check_lex_msg (CuTest *tc,
p11_lexer_init (&lexer, "test", input, strlen (input));
for (i = 0; p11_lexer_next (&lexer, &failed); i++) {
- CuAssertIntEquals_LineMsg (tc, file, line,
- "lexer token type does not match",
- expected[i].tok_type, lexer.tok_type);
+ if (expected[i].tok_type != lexer.tok_type)
+ p11_test_fail (file, line, function,
+ "lexer token type does not match: (%d != %d)",
+ expected[i].tok_type, lexer.tok_type);
switch (lexer.tok_type) {
case TOK_FIELD:
- CuAssertStrEquals_LineMsg (tc, file, line,
- "field name doesn't match",
- expected[i].name, lexer.tok.field.name);
- CuAssertStrEquals_LineMsg (tc, file, line,
- "field value doesn't match",
- expected[i].value, lexer.tok.field.value);
+ if (strcmp (expected[i].name, lexer.tok.field.name) != 0)
+ p11_test_fail (file, line, function,
+ "field name doesn't match: (%s != %s)",
+ expected[i].name, lexer.tok.field.name);
+ if (strcmp (expected[i].value, lexer.tok.field.value) != 0)
+ p11_test_fail (file, line, function,
+ "field value doesn't match: (%s != %s)",
+ expected[i].value, lexer.tok.field.value);
break;
case TOK_SECTION:
- CuAssertStrEquals_LineMsg (tc, file, line,
- "section name doesn't match",
- expected[i].name, lexer.tok.field.name);
+ if (strcmp (expected[i].name, lexer.tok.field.name) != 0)
+ p11_test_fail (file, line, function,
+ "section name doesn't match: (%s != %s)",
+ expected[i].name, lexer.tok.field.name);
break;
case TOK_PEM:
type = NULL;
count = p11_pem_parse (lexer.tok.pem.begin, lexer.tok.pem.length,
on_pem_get_type, &type);
- CuAssertIntEquals_LineMsg (tc, file, line,
- "wrong number of PEM blocks",
- 1, count);
- CuAssertStrEquals_LineMsg (tc, file, line,
- "wrong type of PEM block",
- expected[i].name, type);
+ if (count != 1)
+ p11_test_fail (file, line, function, "more than one PEM block: %d", count);
+ if (strcmp (expected[i].name, type) != 0)
+ p11_test_fail (file, line, function,
+ "wrong type of PEM block: (%s != %s)",
+ expected[i].name, type);
free (type);
break;
case TOK_EOF:
- CuFail_Line (tc, file, line, NULL, "eof should not be recieved");
+ p11_test_fail (file, line, function, "eof should not be recieved");
break;
}
}
- if (failure)
- CuAssert_Line (tc, file, line, "lexing didn't fail", failed);
- else
- CuAssert_Line (tc, file, line, "lexing failed", !failed);
- CuAssertIntEquals_LineMsg (tc, file, line,
- "premature end of lexing",
- TOK_EOF, expected[i].tok_type);
+ if (failure && !failed)
+ p11_test_fail (file, line, function, "lexing didn't fail");
+ else if (!failure && failed)
+ p11_test_fail (file, line, function, "lexing failed");
+ if (TOK_EOF != expected[i].tok_type)
+ p11_test_fail (file, line, function, "premature end of lexing");
p11_lexer_done (&lexer);
}
-#define check_lex_success(tc, expected, input) \
- check_lex_msg (tc, __FILE__, __LINE__, expected, input, false)
+#define check_lex_success(expected, input) \
+ check_lex_msg (__FILE__, __LINE__, __FUNCTION__, expected, input, false)
-#define check_lex_failure(tc, expected, input) \
- check_lex_msg (tc, __FILE__, __LINE__, expected, input, true)
+#define check_lex_failure(expected, input) \
+ check_lex_msg (__FILE__, __LINE__, __FUNCTION__, expected, input, true)
static void
-test_basic (CuTest *tc)
+test_basic (void)
{
const char *input = "[the header]\n"
"field: value\n"
@@ -145,11 +148,11 @@ test_basic (CuTest *tc)
{ TOK_EOF }
};
- check_lex_success (tc, expected, input);
+ check_lex_success (expected, input);
}
static void
-test_corners (CuTest *tc)
+test_corners (void)
{
const char *input = "\r\n" /* blankline */
" [the header]\r\n" /* bad line endings */
@@ -175,11 +178,11 @@ test_corners (CuTest *tc)
{ TOK_EOF }
};
- check_lex_success (tc, expected, input);
+ check_lex_success (expected, input);
}
static void
-test_following (CuTest *tc)
+test_following (void)
{
const char *input = "-----BEGIN BLOCK1-----\n"
"aYNNXqshlVxCdo8QfKeXh3GUzd/yn4LYIVgQrx4a\n"
@@ -192,11 +195,11 @@ test_following (CuTest *tc)
{ TOK_EOF }
};
- check_lex_success (tc, expected, input);
+ check_lex_success (expected, input);
}
static void
-test_bad_pem (CuTest *tc)
+test_bad_pem (void)
{
const char *input = "field: value\n"
"-----BEGIN BLOCK1-----\n"
@@ -209,13 +212,13 @@ test_bad_pem (CuTest *tc)
p11_message_quiet ();
- check_lex_failure (tc, expected, input);
+ check_lex_failure (expected, input);
p11_message_loud ();
}
static void
-test_bad_section (CuTest *tc)
+test_bad_section (void)
{
const char *input = "field: value\n"
"[section\n"
@@ -228,13 +231,13 @@ test_bad_section (CuTest *tc)
p11_message_quiet ();
- check_lex_failure (tc, expected, input);
+ check_lex_failure (expected, input);
p11_message_loud ();
}
static void
-test_bad_value (CuTest *tc)
+test_bad_value (void)
{
const char *input = "field_value\n"
"[section\n"
@@ -246,35 +249,20 @@ test_bad_value (CuTest *tc)
p11_message_quiet ();
- check_lex_failure (tc, expected, input);
+ check_lex_failure (expected, input);
p11_message_loud ();
}
int
-main (void)
+main (int argc,
+ char *argv[])
{
- CuString *output = CuStringNew ();
- CuSuite* suite = CuSuiteNew ();
- int ret;
-
- putenv ("P11_KIT_STRICT=1");
- p11_debug_init ();
-
- SUITE_ADD_TEST (suite, test_basic);
- SUITE_ADD_TEST (suite, test_corners);
- SUITE_ADD_TEST (suite, test_following);
- SUITE_ADD_TEST (suite, test_bad_pem);
- SUITE_ADD_TEST (suite, test_bad_section);
- SUITE_ADD_TEST (suite, test_bad_value);
-
- CuSuiteRun (suite);
- CuSuiteSummary (suite, output);
- CuSuiteDetails (suite, output);
- printf ("%s\n", output->buffer);
- ret = suite->failCount;
- CuSuiteDelete (suite);
- CuStringDelete (output);
-
- return ret;
+ p11_test (test_basic, "/lexer/basic");
+ p11_test (test_corners, "/lexer/corners");
+ p11_test (test_following, "/lexer/following");
+ p11_test (test_bad_pem, "/lexer/bad-pem");
+ p11_test (test_bad_section, "/lexer/bad-section");
+ p11_test (test_bad_value, "/lexer/bad-value");
+ return p11_test_run (argc, argv);
}
diff --git a/common/tests/test-oid.c b/common/tests/test-oid.c
index 71b8278..05945d9 100644
--- a/common/tests/test-oid.c
+++ b/common/tests/test-oid.c
@@ -33,7 +33,7 @@
*/
#include "config.h"
-#include "CuTest.h"
+#include "test.h"
#include <stdlib.h>
#include <stdio.h>
@@ -47,7 +47,7 @@
#include "pkix.asn.h"
static void
-test_known_oids (CuTest *cu)
+test_known_oids (void)
{
char buffer[128];
node_asn *definitions = NULL;
@@ -79,29 +79,29 @@ test_known_oids (CuTest *cu)
};
ret = asn1_array2tree (pkix_asn1_tab, &definitions, NULL);
- CuAssertTrue (cu, ret == ASN1_SUCCESS);
+ assert (ret == ASN1_SUCCESS);
for (i = 0; known_oids[i].oid != NULL; i++) {
- CuAssertTrue (cu, p11_oid_simple (known_oids[i].oid, known_oids[i].length));
- CuAssertIntEquals (cu, known_oids[i].length, p11_oid_length (known_oids[i].oid));
- CuAssertTrue (cu, p11_oid_equal (known_oids[i].oid, known_oids[i].oid));
+ assert (p11_oid_simple (known_oids[i].oid, known_oids[i].length));
+ assert_num_eq (known_oids[i].length, p11_oid_length (known_oids[i].oid));
+ assert (p11_oid_equal (known_oids[i].oid, known_oids[i].oid));
if (i > 0)
- CuAssertTrue (cu, !p11_oid_equal (known_oids[i].oid, known_oids[i - 1].oid));
+ assert (!p11_oid_equal (known_oids[i].oid, known_oids[i - 1].oid));
/* AttributeType is a OBJECT IDENTIFIER */
ret = asn1_create_element (definitions, "PKIX1.AttributeType", &node);
- CuAssertTrue (cu, ret == ASN1_SUCCESS);
+ assert (ret == ASN1_SUCCESS);
ret = asn1_der_decoding (&node, known_oids[i].oid, known_oids[i].length, NULL);
- CuAssertTrue (cu, ret == ASN1_SUCCESS);
+ assert (ret == ASN1_SUCCESS);
len = sizeof (buffer);
ret = asn1_read_value (node, "", buffer, &len);
- CuAssertTrue (cu, ret == ASN1_SUCCESS);
+ assert (ret == ASN1_SUCCESS);
- CuAssertStrEquals (cu, known_oids[i].string, buffer);
+ assert_str_eq (known_oids[i].string, buffer);
asn1_delete_structure (&node);
}
@@ -110,24 +110,9 @@ test_known_oids (CuTest *cu)
}
int
-main (void)
+main (int argc,
+ char *argv[])
{
- CuString *output = CuStringNew ();
- CuSuite* suite = CuSuiteNew ();
- int ret;
-
- putenv ("P11_KIT_STRICT=1");
- p11_debug_init ();
-
- SUITE_ADD_TEST (suite, test_known_oids);
-
- CuSuiteRun (suite);
- CuSuiteSummary (suite, output);
- CuSuiteDetails (suite, output);
- printf ("%s\n", output->buffer);
- ret = suite->failCount;
- CuSuiteDelete (suite);
- CuStringDelete (output);
-
- return ret;
+ p11_test (test_known_oids, "/oids/known");
+ return p11_test_run (argc, argv);
}
diff --git a/common/tests/test-path.c b/common/tests/test-path.c
index def4199..54d6f29 100644
--- a/common/tests/test-path.c
+++ b/common/tests/test-path.c
@@ -33,7 +33,7 @@
*/
#include "config.h"
-#include "CuTest.h"
+#include "test.h"
#include <stdlib.h>
#include <stdio.h>
@@ -43,7 +43,7 @@
#include "path.h"
static void
-test_base (CuTest *tc)
+test_base (void)
{
struct {
const char *in;
@@ -70,27 +70,16 @@ test_base (CuTest *tc)
for (i = 0; fixtures[i].in != NULL; i++) {
out = p11_path_base (fixtures[i].in);
- CuAssertStrEquals (tc, fixtures[i].out, out);
+ assert_str_eq (fixtures[i].out, out);
free (out);
}
}
-static void
-check_equals_and_free_msg (CuTest *tc,
- const char *file,
- int line,
- const char *ex,
- char *ac)
-{
- CuAssertStrEquals_LineMsg (tc, file, line, NULL, ex, ac);
- free (ac);
-}
-
#define check_equals_and_free(tc, ex, ac) \
- check_equals_and_free_msg ((tc), __FILE__, __LINE__, (ex), (ac))
+ do { assert_str_eq (ex, ac); free (ac); } while (0)
static void
-test_build (CuTest *tc)
+test_build (void)
{
#ifdef OS_UNIX
check_equals_and_free (tc, "/root/second",
@@ -118,7 +107,7 @@ test_build (CuTest *tc)
}
static void
-test_expand (CuTest *tc)
+test_expand (void)
{
char *path;
@@ -151,52 +140,41 @@ test_expand (CuTest *tc)
putenv("HOME=");
path = p11_path_expand ("$HOME/this/is/my/path");
- CuAssertTrue (tc, strstr (path, "this/is/my/path") != NULL);
+ assert (strstr (path, "this/is/my/path") != NULL);
free (path);
putenv("HOME=");
path = p11_path_expand ("~/this/is/my/path");
- CuAssertTrue (tc, strstr (path, "this/is/my/path") != NULL);
+ assert (strstr (path, "this/is/my/path") != NULL);
free (path);
putenv("TEMP=");
path = p11_path_expand ("$TEMP/this/is/my/path");
- CuAssertTrue (tc, strstr (path, "this/is/my/path") != NULL);
+ assert (strstr (path, "this/is/my/path") != NULL);
free (path);
}
static void
-test_absolute (CuTest *tc)
+test_absolute (void)
{
#ifdef OS_UNIX
- CuAssertTrue (tc, p11_path_absolute ("/home"));
- CuAssertTrue (tc, !p11_path_absolute ("home"));
+ assert (p11_path_absolute ("/home"));
+ assert (!p11_path_absolute ("home"));
#else /* OS_WIN32 */
- CuAssertTrue (tc, p11_path_absolute ("C:\\home"));
- CuAssertTrue (tc, !p11_path_absolute ("home"));
- CuAssertTrue (tc, p11_path_absolute ("/home"));
+ assert (p11_path_absolute ("C:\\home"));
+ assert (!p11_path_absolute ("home"));
+ assert (p11_path_absolute ("/home"));
#endif
}
int
-main (void)
+main (int argc,
+ char *argv[])
{
- CuString *output = CuStringNew ();
- CuSuite* suite = CuSuiteNew ();
- int ret;
-
- SUITE_ADD_TEST (suite, test_base);
- SUITE_ADD_TEST (suite, test_build);
- SUITE_ADD_TEST (suite, test_expand);
- SUITE_ADD_TEST (suite, test_absolute);
-
- CuSuiteRun (suite);
- CuSuiteSummary (suite, output);
- CuSuiteDetails (suite, output);
- printf ("%s\n", output->buffer);
- ret = suite->failCount;
- CuSuiteDelete (suite);
- CuStringDelete (output);
-
- return ret;
+ p11_test (test_base, "/path/base");
+ p11_test (test_build, "/path/build");
+ p11_test (test_expand, "/path/expand");
+ p11_test (test_absolute, "/path/absolute");
+
+ return p11_test_run (argc, argv);
}
diff --git a/common/tests/test-pem.c b/common/tests/test-pem.c
index 54a59d6..7dd7fb2 100644
--- a/common/tests/test-pem.c
+++ b/common/tests/test-pem.c
@@ -33,7 +33,7 @@
*/
#include "config.h"
-#include "CuTest.h"
+#include "test.h"
#include <stdlib.h>
#include <stdio.h>
@@ -125,7 +125,6 @@ struct {
};
typedef struct {
- CuTest *cu;
int input_index;
int output_index;
int parsed;
@@ -139,8 +138,8 @@ on_parse_pem_success (const char *type,
{
Closure *cl = user_data;
- CuAssertIntEquals (cl->cu, success_fixtures[cl->input_index].output[cl->output_index].length, length);
- CuAssertTrue (cl->cu, memcmp (success_fixtures[cl->input_index].output[cl->output_index].data, contents,
+ assert_num_eq (success_fixtures[cl->input_index].output[cl->output_index].length, length);
+ assert (memcmp (success_fixtures[cl->input_index].output[cl->output_index].data, contents,
success_fixtures[cl->input_index].output[cl->output_index].length) == 0);
cl->output_index++;
@@ -148,7 +147,7 @@ on_parse_pem_success (const char *type,
}
static void
-test_pem_success (CuTest *cu)
+test_pem_success (void)
{
Closure cl;
int ret;
@@ -156,7 +155,6 @@ test_pem_success (CuTest *cu)
int j;
for (i = 0; success_fixtures[i].input != NULL; i++) {
- cl.cu = cu;
cl.input_index = i;
cl.output_index = 0;
cl.parsed = 0;
@@ -164,12 +162,12 @@ test_pem_success (CuTest *cu)
ret = p11_pem_parse (success_fixtures[i].input, strlen (success_fixtures[i].input),
on_parse_pem_success, &cl);
- CuAssertTrue (cu, success_fixtures[i].output[cl.output_index].type == NULL);
+ assert (success_fixtures[i].output[cl.output_index].type == NULL);
/* Count number of outputs, return from p11_pem_parse() should match */
for (j = 0; success_fixtures[i].output[j].type != NULL; j++);
- CuAssertIntEquals (cu, j, ret);
- CuAssertIntEquals (cu, ret, cl.parsed);
+ assert_num_eq (j, ret);
+ assert_num_eq (ret, cl.parsed);
}
}
@@ -215,20 +213,19 @@ on_parse_pem_failure (const char *type,
size_t length,
void *user_data)
{
- CuTest *cu = user_data;
- CuAssertTrue (cu, false && "not reached");
+ assert (false && "not reached");
}
static void
-test_pem_failure (CuTest *cu)
+test_pem_failure (void)
{
int ret;
int i;
for (i = 0; failure_fixtures[i] != NULL; i++) {
ret = p11_pem_parse (failure_fixtures[i], strlen (failure_fixtures[i]),
- on_parse_pem_failure, cu);
- CuAssertIntEquals (cu, 0, ret);
+ on_parse_pem_failure, NULL);
+ assert_num_eq (0, ret);
}
}
@@ -239,11 +236,6 @@ typedef struct {
const char *output;
} WriteFixture;
-typedef struct {
- CuTest *cu;
- WriteFixture *fixture;
-} WriteClosure;
-
static WriteFixture write_fixtures[] = {
{
"\x69\x83\x4d\x5e\xab\x21\x95\x5c\x42\x76\x8f\x10\x7c\xa7\x97\x87"
@@ -303,18 +295,17 @@ on_parse_written (const char *type,
size_t length,
void *user_data)
{
- WriteClosure *cl = user_data;
+ WriteFixture *fixture = user_data;
- CuAssertStrEquals (cl->cu, cl->fixture->type, type);
- CuAssertIntEquals (cl->cu, cl->fixture->length, length);
- CuAssertTrue (cl->cu, memcmp (contents, cl->fixture->input, length) == 0);
+ assert_str_eq (fixture->type, type);
+ assert_num_eq (fixture->length, length);
+ assert (memcmp (contents, fixture->input, length) == 0);
}
static void
-test_pem_write (CuTest *cu)
+test_pem_write (void)
{
WriteFixture *fixture;
- WriteClosure cl;
size_t length;
char *output;
unsigned int count;
@@ -326,37 +317,22 @@ test_pem_write (CuTest *cu)
output = p11_pem_write ((unsigned char *)fixture->input,
fixture->length,
fixture->type, &length);
- CuAssertStrEquals (cu, fixture->output, output);
- CuAssertIntEquals (cu, strlen (fixture->output), length);
-
- cl.fixture = fixture;
- cl.cu = cu;
+ assert_str_eq (fixture->output, output);
+ assert_num_eq (strlen (fixture->output), length);
- count = p11_pem_parse (output, length, on_parse_written, &cl);
- CuAssertIntEquals (cu, 1, count);
+ count = p11_pem_parse (output, length, on_parse_written, fixture);
+ assert_num_eq (1, count);
free (output);
}
}
int
-main (void)
+main (int argc,
+ char *argv[])
{
- CuString *output = CuStringNew ();
- CuSuite* suite = CuSuiteNew ();
- int ret;
-
- SUITE_ADD_TEST (suite, test_pem_success);
- SUITE_ADD_TEST (suite, test_pem_failure);
- SUITE_ADD_TEST (suite, test_pem_write);
-
- CuSuiteRun (suite);
- CuSuiteSummary (suite, output);
- CuSuiteDetails (suite, output);
- printf ("%s\n", output->buffer);
- ret = suite->failCount;
- CuSuiteDelete (suite);
- CuStringDelete (output);
-
- return ret;
+ p11_test (test_pem_success, "/pem/success");
+ p11_test (test_pem_failure, "/pem/failure");
+ p11_test (test_pem_write, "/pem/write");
+ return p11_test_run (argc, argv);
}
diff --git a/common/tests/test-url.c b/common/tests/test-url.c
index ed84f0c..4c62594 100644
--- a/common/tests/test-url.c
+++ b/common/tests/test-url.c
@@ -33,7 +33,7 @@
*/
#include "config.h"
-#include "CuTest.h"
+#include "test.h"
#include "debug.h"
#include "message.h"
@@ -46,9 +46,9 @@
#include "url.h"
static void
-check_decode_msg (CuTest *tc,
- const char *file,
+check_decode_msg (const char *file,
int line,
+ const char *function,
const char *input,
ssize_t input_len,
const char *expected,
@@ -62,106 +62,97 @@ check_decode_msg (CuTest *tc,
decoded = p11_url_decode (input, input + input_len, "", &length);
if (expected == NULL) {
- CuAssert_Line (tc, file, line, "decoding should have failed", decoded == NULL);
+ if (decoded != NULL)
+ p11_test_fail (file, line, function, "decoding should have failed");
} else {
- CuAssert_Line (tc, file, line, "decoding failed", decoded != NULL);
- CuAssertIntEquals_LineMsg (tc, file, line, "wrong length", expected_len, length);
- CuAssert_Line (tc, file, line, "decoded wrong", memcmp (decoded, expected, length) == 0);
+ if (decoded == NULL)
+ p11_test_fail (file, line, function, "decoding failed");
+ if (expected_len != length)
+ p11_test_fail (file, line, function, "wrong length: (%lu != %lu)",
+ (unsigned long)expected_len, (unsigned long)length);
+ if (memcmp (decoded, expected, length) != 0)
+ p11_test_fail (file, line, function, "decoding wrong");
free (decoded);
}
}
-#define check_decode_success(tc, input, input_len, expected, expected_len) \
- check_decode_msg (tc, __FILE__, __LINE__, input, input_len, expected, expected_len)
+#define check_decode_success(input, input_len, expected, expected_len) \
+ check_decode_msg (__FILE__, __LINE__, __FUNCTION__, input, input_len, expected, expected_len)
-#define check_decode_failure(tc, input, input_len) \
- check_decode_msg (tc, __FILE__, __LINE__, input, input_len, NULL, 0)
+#define check_decode_failure(input, input_len) \
+ check_decode_msg (__FILE__, __LINE__, __FUNCTION__, input, input_len, NULL, 0)
static void
-test_decode_success (CuTest *tc)
+test_decode_success (void)
{
- check_decode_success (tc, "%54%45%53%54%00", -1, "TEST", 5);
- check_decode_success (tc, "%54%45%53%54%00", 6, "TE", 2);
- check_decode_success (tc, "%54est%00", -1, "Test", 5);
+ check_decode_success ("%54%45%53%54%00", -1, "TEST", 5);
+ check_decode_success ("%54%45%53%54%00", 6, "TE", 2);
+ check_decode_success ("%54est%00", -1, "Test", 5);
}
static void
-test_decode_skip (CuTest *tc)
+test_decode_skip (void)
{
const char *input = "%54 %45 %53 %54 %00";
unsigned char *decoded;
size_t length;
decoded = p11_url_decode (input, input + strlen (input), P11_URL_WHITESPACE, &length);
- CuAssertStrEquals (tc, "TEST", (char *)decoded);
- CuAssertIntEquals (tc, 5, length);
+ assert_str_eq ("TEST", (char *)decoded);
+ assert_num_eq (5, length);
free (decoded);
}
static void
-test_decode_failure (CuTest *tc)
+test_decode_failure (void)
{
/* Early termination */
- check_decode_failure (tc, "%54%45%53%5", -1);
- check_decode_failure (tc, "%54%45%53%", -1);
+ check_decode_failure ("%54%45%53%5", -1);
+ check_decode_failure ("%54%45%53%", -1);
/* Not hex characters */
- check_decode_failure (tc, "%54%XX%53%54%00", -1);
+ check_decode_failure ("%54%XX%53%54%00", -1);
}
static void
-test_encode (CuTest *tc)
+test_encode (void)
{
const unsigned char *input = (unsigned char *)"TEST";
char *encoded;
size_t length;
encoded = p11_url_encode (input, input + 5, "", &length);
- CuAssertStrEquals (tc, "%54%45%53%54%00", (char *)encoded);
- CuAssertIntEquals (tc, 15, length);
+ assert_str_eq ("%54%45%53%54%00", (char *)encoded);
+ assert_num_eq (15, length);
free (encoded);
}
static void
-test_encode_verbatim (CuTest *tc)
+test_encode_verbatim (void)
{
const unsigned char *input = (unsigned char *)"TEST";
char *encoded;
size_t length;
encoded = p11_url_encode (input, input + 5, "ES", &length);
- CuAssertStrEquals (tc, "%54ES%54%00", (char *)encoded);
- CuAssertIntEquals (tc, 11, length);
+ assert_str_eq ("%54ES%54%00", (char *)encoded);
+ assert_num_eq (11, length);
free (encoded);
}
int
-main (void)
+main (int argc,
+ char *argv[])
{
- CuString *output = CuStringNew ();
- CuSuite* suite = CuSuiteNew ();
- int ret;
-
- putenv ("P11_KIT_STRICT=1");
- p11_debug_init ();
-
- SUITE_ADD_TEST (suite, test_decode_success);
- SUITE_ADD_TEST (suite, test_decode_skip);
- SUITE_ADD_TEST (suite, test_decode_failure);
-
- SUITE_ADD_TEST (suite, test_encode);
- SUITE_ADD_TEST (suite, test_encode_verbatim);
-
- CuSuiteRun (suite);
- CuSuiteSummary (suite, output);
- CuSuiteDetails (suite, output);
- printf ("%s\n", output->buffer);
- ret = suite->failCount;
- CuSuiteDelete (suite);
- CuStringDelete (output);
- return ret;
+ p11_test (test_decode_success, "/url/decode-success");
+ p11_test (test_decode_skip, "/url/decode-skip");
+ p11_test (test_decode_failure, "/url/decode-failure");
+
+ p11_test (test_encode, "/url/encode");
+ p11_test (test_encode_verbatim, "/url/encode-verbatim");
+ return p11_test_run (argc, argv);
}
diff --git a/common/tests/test-utf8.c b/common/tests/test-utf8.c
index ed13fa2..9b2c3d5 100644
--- a/common/tests/test-utf8.c
+++ b/common/tests/test-utf8.c
@@ -33,7 +33,7 @@
*/
#include "config.h"
-#include "CuTest.h"
+#include "test.h"
#include "utf8.h"
@@ -43,7 +43,7 @@
#define ELEMS(x) (sizeof (x) / sizeof (x[0]))
static void
-test_ucs2be (CuTest *cu)
+test_ucs2be (void)
{
char *output;
size_t length;
@@ -73,14 +73,14 @@ test_ucs2be (CuTest *cu)
fixtures[i].input_len,
&length);
- CuAssertIntEquals (cu, fixtures[i].output_len, length);
- CuAssertStrEquals (cu, fixtures[i].output, output);
+ assert_num_eq (fixtures[i].output_len, length);
+ assert_str_eq (fixtures[i].output, output);
free (output);
}
}
static void
-test_ucs2be_fail (CuTest *cu)
+test_ucs2be_fail (void)
{
char *output;
size_t length;
@@ -97,12 +97,12 @@ test_ucs2be_fail (CuTest *cu)
output = p11_utf8_for_ucs2be (fixtures[i].input,
fixtures[i].input_len,
&length);
- CuAssertPtrEquals (cu, NULL, output);
+ assert_ptr_eq (NULL, output);
}
}
static void
-test_ucs4be (CuTest *cu)
+test_ucs4be (void)
{
char *output;
size_t length;
@@ -146,15 +146,15 @@ test_ucs4be (CuTest *cu)
fixtures[i].input_len,
&length);
- CuAssertIntEquals (cu, fixtures[i].output_len, length);
- CuAssertStrEquals (cu, fixtures[i].output, output);
+ assert_num_eq (fixtures[i].output_len, length);
+ assert_str_eq (fixtures[i].output, output);
free (output);
}
}
static void
-test_ucs4be_fail (CuTest *cu)
+test_ucs4be_fail (void)
{
char *output;
size_t length;
@@ -179,12 +179,12 @@ test_ucs4be_fail (CuTest *cu)
output = p11_utf8_for_ucs4be (fixtures[i].input,
fixtures[i].input_len,
&length);
- CuAssertPtrEquals (cu, NULL, output);
+ assert_ptr_eq (NULL, output);
}
}
static void
-test_utf8 (CuTest *cu)
+test_utf8 (void)
{
bool ret;
int i;
@@ -203,12 +203,12 @@ test_utf8 (CuTest *cu)
for (i = 0; i < ELEMS (fixtures); i++) {
ret = p11_utf8_validate (fixtures[i].input,
fixtures[i].input_len);
- CuAssertIntEquals (cu, true, ret);
+ assert_num_eq (true, ret);
}
}
static void
-test_utf8_fail (CuTest *cu)
+test_utf8_fail (void)
{
bool ret;
int i;
@@ -226,31 +226,19 @@ test_utf8_fail (CuTest *cu)
for (i = 0; i < ELEMS (fixtures); i++) {
ret = p11_utf8_validate (fixtures[i].input,
fixtures[i].input_len);
- CuAssertIntEquals (cu, false, ret);
+ assert_num_eq (false, ret);
}
}
int
-main (void)
+main (int argc,
+ char *argv[])
{
- CuString *output = CuStringNew ();
- CuSuite* suite = CuSuiteNew ();
- int ret;
-
- SUITE_ADD_TEST (suite, test_ucs2be);
- SUITE_ADD_TEST (suite, test_ucs2be_fail);
- SUITE_ADD_TEST (suite, test_ucs4be);
- SUITE_ADD_TEST (suite, test_ucs4be_fail);
- SUITE_ADD_TEST (suite, test_utf8);
- SUITE_ADD_TEST (suite, test_utf8_fail);
-
- CuSuiteRun (suite);
- CuSuiteSummary (suite, output);
- CuSuiteDetails (suite, output);
- printf ("%s\n", output->buffer);
- ret = suite->failCount;
- CuSuiteDelete (suite);
- CuStringDelete (output);
-
- return ret;
+ p11_test (test_ucs2be, "/utf8/ucs2be");
+ p11_test (test_ucs2be_fail, "/utf8/ucs2be_fail");
+ p11_test (test_ucs4be, "/utf8/ucs4be");
+ p11_test (test_ucs4be_fail, "/utf8/ucs4be_fail");
+ p11_test (test_utf8, "/utf8/utf8");
+ p11_test (test_utf8_fail, "/utf8/utf8_fail");
+ return p11_test_run (argc, argv);
}
diff --git a/common/tests/test-x509.c b/common/tests/test-x509.c
index 2596c9c..9f7d258 100644
--- a/common/tests/test-x509.c
+++ b/common/tests/test-x509.c
@@ -33,7 +33,7 @@
*/
#include "config.h"
-#include "CuTest.h"
+#include "test.h"
#include "asn1.h"
#include "debug.h"
@@ -51,14 +51,14 @@ struct {
} test;
static void
-setup (CuTest *cu)
+setup (void *unused)
{
test.asn1_defs = p11_asn1_defs_load ();
- CuAssertPtrNotNull (cu, test.asn1_defs);
+ assert_ptr_not_null (test.asn1_defs);
}
static void
-teardown (CuTest *cu)
+teardown (void *unused)
{
p11_dict_free (test.asn1_defs);
memset (&test, 0, sizeof (test));
@@ -226,29 +226,25 @@ struct {
};
static void
-test_parse_extended_key_usage (CuTest *cu)
+test_parse_extended_key_usage (void)
{
p11_array *ekus;
int i, j, count;
- setup (cu);
-
for (i = 0; extended_key_usage_fixtures[i].eku != NULL; i++) {
ekus = p11_x509_parse_extended_key_usage (test.asn1_defs,
(const unsigned char *)extended_key_usage_fixtures[i].eku,
extended_key_usage_fixtures[i].length);
- CuAssertPtrNotNull (cu, ekus);
+ assert_ptr_not_null (ekus);
for (count = 0; extended_key_usage_fixtures[i].expected[count] != NULL; count++);
- CuAssertIntEquals (cu, count, ekus->num);
+ assert_num_eq (count, ekus->num);
for (j = 0; j < count; j++)
- CuAssertStrEquals (cu, ekus->elem[j], extended_key_usage_fixtures[i].expected[j]);
+ assert_str_eq (ekus->elem[j], extended_key_usage_fixtures[i].expected[j]);
p11_array_free (ekus);
}
-
- teardown (cu);
}
struct {
@@ -263,82 +259,70 @@ struct {
};
static void
-test_parse_key_usage (CuTest *cu)
+test_parse_key_usage (void)
{
unsigned int ku;
int i;
bool ret;
- setup (cu);
-
for (i = 0; key_usage_fixtures[i].ku != NULL; i++) {
ku = 0;
ret = p11_x509_parse_key_usage (test.asn1_defs,
(const unsigned char *)key_usage_fixtures[i].ku,
key_usage_fixtures[i].length, &ku);
- CuAssertIntEquals (cu, true, ret);
+ assert_num_eq (true, ret);
- CuAssertIntEquals (cu, key_usage_fixtures[i].expected, ku);
+ assert_num_eq (key_usage_fixtures[i].expected, ku);
}
-
- teardown (cu);
}
static void
-test_parse_extension (CuTest *cu)
+test_parse_extension (void)
{
node_asn *cert;
unsigned char *ext;
size_t length;
bool is_ca;
- setup (cu);
-
cert = p11_asn1_decode (test.asn1_defs, "PKIX1.Certificate",
test_cacert3_ca_der, sizeof (test_cacert3_ca_der), NULL);
- CuAssertPtrNotNull (cu, cert);
+ assert_ptr_not_null (cert);
ext = p11_x509_find_extension (cert, P11_OID_BASIC_CONSTRAINTS,
test_cacert3_ca_der, sizeof (test_cacert3_ca_der),
&length);
- CuAssertPtrNotNull (cu, ext);
- CuAssertTrue (cu, length > 0);
+ assert_ptr_not_null (ext);
+ assert (length > 0);
asn1_delete_structure (&cert);
if (!p11_x509_parse_basic_constraints (test.asn1_defs, ext, length, &is_ca))
- CuFail (cu, "failed to parse message");
+ assert_fail ("failed to parse message", "basic constraints");
free (ext);
-
- teardown (cu);
}
static void
-test_parse_extension_not_found (CuTest *cu)
+test_parse_extension_not_found (void)
{
node_asn *cert;
unsigned char *ext;
size_t length;
- setup (cu);
-
cert = p11_asn1_decode (test.asn1_defs, "PKIX1.Certificate",
test_cacert3_ca_der, sizeof (test_cacert3_ca_der), NULL);
- CuAssertPtrNotNull (cu, cert);
+ assert_ptr_not_null (cert);
ext = p11_x509_find_extension (cert, P11_OID_OPENSSL_REJECT,
test_cacert3_ca_der, sizeof (test_cacert3_ca_der),
&length);
- CuAssertPtrEquals (cu, NULL, ext);
+ assert_ptr_eq (NULL, ext);
asn1_delete_structure (&cert);
-
- teardown (cu);
}
static void
-test_directory_string (CuTest *tc)
+test_directory_string (void)
{
struct {
unsigned char input[100];
@@ -392,17 +376,17 @@ test_directory_string (CuTest *tc)
string = p11_x509_parse_directory_string (fixtures[i].input,
fixtures[i].input_len,
&unknown, &length);
- CuAssertPtrNotNull (tc, string);
- CuAssertIntEquals (tc, false, unknown);
+ assert_ptr_not_null (string);
+ assert_num_eq (false, unknown);
- CuAssertIntEquals (tc, fixtures[i].output_len, length);
- CuAssertStrEquals (tc, fixtures[i].output, string);
+ assert_num_eq (fixtures[i].output_len, length);
+ assert_str_eq (fixtures[i].output, string);
free (string);
}
}
static void
-test_directory_string_unknown (CuTest *tc)
+test_directory_string_unknown (void)
{
/* Not a valid choice in DirectoryString */
unsigned char input[] = { 0x05, 0x07, 'A', ' ', ' ', 'n', 'i', 'c', 'e' };
@@ -411,34 +395,22 @@ test_directory_string_unknown (CuTest *tc)
size_t length;
string = p11_x509_parse_directory_string (input, sizeof (input), &unknown, &length);
- CuAssertPtrEquals (tc, NULL, string);
- CuAssertIntEquals (tc, true, unknown);
+ assert_ptr_eq (NULL, string);
+ assert_num_eq (true, unknown);
}
int
-main (void)
+main (int argc,
+ char *argv[])
{
- CuString *output = CuStringNew ();
- CuSuite* suite = CuSuiteNew ();
- int ret;
-
- putenv ("P11_KIT_STRICT=1");
- p11_debug_init ();
-
- SUITE_ADD_TEST (suite, test_parse_extended_key_usage);
- SUITE_ADD_TEST (suite, test_parse_key_usage);
- SUITE_ADD_TEST (suite, test_parse_extension);
- SUITE_ADD_TEST (suite, test_parse_extension_not_found);
- SUITE_ADD_TEST (suite, test_directory_string);
- SUITE_ADD_TEST (suite, test_directory_string_unknown);
-
- CuSuiteRun (suite);
- CuSuiteSummary (suite, output);
- CuSuiteDetails (suite, output);
- printf ("%s\n", output->buffer);
- ret = suite->failCount;
- CuSuiteDelete (suite);
- CuStringDelete (output);
-
- return ret;
+ p11_fixture (setup, teardown);
+ p11_test (test_parse_extended_key_usage, "/x509/parse-extended-key-usage");
+ p11_test (test_parse_key_usage, "/x509/parse-key-usage");
+ p11_test (test_parse_extension, "/x509/parse-extension");
+ p11_test (test_parse_extension_not_found, "/x509/parse-extension-not-found");
+
+ p11_fixture (NULL, NULL);
+ p11_test (test_directory_string, "/x509/directory-string");
+ p11_test (test_directory_string_unknown, "/x509/directory-string-unknown");
+ return p11_test_run (argc, argv);
}
generated by cgit v1.1 at 2024-12-27 05:32:06 +0000