diff options
Diffstat (limited to 'p11-kit/tests/test-mock.c')
| -rw-r--r-- | p11-kit/tests/test-mock.c | 1012 |
1 files changed, 506 insertions, 506 deletions
diff --git a/p11-kit/tests/test-mock.c b/p11-kit/tests/test-mock.c index 3bc5406..5fba7ec 100644 --- a/p11-kit/tests/test-mock.c +++ b/p11-kit/tests/test-mock.c @@ -33,7 +33,7 @@ * Author: Stef Walter <stef@thewalter.net> */ -#include "CuTest.h" +#include "test.h" #include "library.h" #include "mock.h" @@ -46,222 +46,222 @@ #include <stdlib.h> static void -test_get_info (CuTest *tc) +test_get_info (void) { CK_FUNCTION_LIST_PTR module; CK_INFO info; CK_RV rv; - module = setup_mock_module (tc, NULL); + module = setup_mock_module (NULL); rv = (module->C_GetInfo) (&info); - CuAssertTrue (tc, rv == CKR_OK); - CuAssertTrue (tc, memcmp (&info, &MOCK_INFO, sizeof (CK_INFO)) == 0); + assert (rv == CKR_OK); + assert (memcmp (&info, &MOCK_INFO, sizeof (CK_INFO)) == 0); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_get_slot_list (CuTest *tc) +test_get_slot_list (void) { CK_FUNCTION_LIST_PTR module; CK_SLOT_ID slot_list[8]; CK_ULONG count = 0; CK_RV rv; - module = setup_mock_module (tc, NULL); + module = setup_mock_module (NULL); /* Normal module has 2 slots, one with token present */ rv = (module->C_GetSlotList) (CK_TRUE, NULL, &count); - CuAssertTrue (tc, rv == CKR_OK); - CuAssertIntEquals (tc, MOCK_SLOTS_PRESENT, count); + assert (rv == CKR_OK); + assert_num_eq (MOCK_SLOTS_PRESENT, count); rv = (module->C_GetSlotList) (CK_FALSE, NULL, &count); - CuAssertTrue (tc, rv == CKR_OK); - CuAssertIntEquals (tc, MOCK_SLOTS_ALL, count); + assert (rv == CKR_OK); + assert_num_eq (MOCK_SLOTS_ALL, count); count = 8; rv = (module->C_GetSlotList) (CK_TRUE, slot_list, &count); - CuAssertTrue (tc, rv == CKR_OK); - CuAssertIntEquals (tc, MOCK_SLOTS_PRESENT, count); - CuAssertIntEquals (tc, MOCK_SLOT_ONE_ID, slot_list[0]); + assert (rv == CKR_OK); + assert_num_eq (MOCK_SLOTS_PRESENT, count); + assert_num_eq (MOCK_SLOT_ONE_ID, slot_list[0]); count = 8; rv = (module->C_GetSlotList) (CK_FALSE, slot_list, &count); - CuAssertTrue (tc, rv == CKR_OK); - CuAssertIntEquals (tc, MOCK_SLOTS_ALL, count); - CuAssertIntEquals (tc, MOCK_SLOT_ONE_ID, slot_list[0]); - CuAssertIntEquals (tc, MOCK_SLOT_TWO_ID, slot_list[1]); + assert (rv == CKR_OK); + assert_num_eq (MOCK_SLOTS_ALL, count); + assert_num_eq (MOCK_SLOT_ONE_ID, slot_list[0]); + assert_num_eq (MOCK_SLOT_TWO_ID, slot_list[1]); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_get_slot_info (CuTest *tc) +test_get_slot_info (void) { CK_FUNCTION_LIST_PTR module; CK_SLOT_INFO info; char *string; CK_RV rv; - module = setup_mock_module (tc, NULL); + module = setup_mock_module (NULL); rv = (module->C_GetSlotInfo) (MOCK_SLOT_ONE_ID, &info); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); string = p11_kit_space_strdup (info.slotDescription, sizeof (info.slotDescription)); - CuAssertStrEquals (tc, "TEST SLOT", string); + assert_str_eq ("TEST SLOT", string); free (string); string = p11_kit_space_strdup (info.manufacturerID, sizeof (info.manufacturerID)); - CuAssertStrEquals (tc, "TEST MANUFACTURER", string); + assert_str_eq ("TEST MANUFACTURER", string); free (string); - CuAssertIntEquals (tc, CKF_TOKEN_PRESENT | CKF_REMOVABLE_DEVICE, info.flags); - CuAssertIntEquals (tc, 55, info.hardwareVersion.major); - CuAssertIntEquals (tc, 155, info.hardwareVersion.minor); - CuAssertIntEquals (tc, 65, info.firmwareVersion.major); - CuAssertIntEquals (tc, 165, info.firmwareVersion.minor); + assert_num_eq (CKF_TOKEN_PRESENT | CKF_REMOVABLE_DEVICE, info.flags); + assert_num_eq (55, info.hardwareVersion.major); + assert_num_eq (155, info.hardwareVersion.minor); + assert_num_eq (65, info.firmwareVersion.major); + assert_num_eq (165, info.firmwareVersion.minor); rv = (module->C_GetSlotInfo) (MOCK_SLOT_TWO_ID, &info); - CuAssertTrue (tc, rv == CKR_OK); - CuAssertIntEquals (tc, CKF_REMOVABLE_DEVICE, info.flags); + assert (rv == CKR_OK); + assert_num_eq (CKF_REMOVABLE_DEVICE, info.flags); rv = (module->C_GetSlotInfo) (0, &info); - CuAssertTrue (tc, rv == CKR_SLOT_ID_INVALID); + assert (rv == CKR_SLOT_ID_INVALID); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_get_token_info (CuTest *tc) +test_get_token_info (void) { CK_FUNCTION_LIST_PTR module; CK_TOKEN_INFO info; char *string; CK_RV rv; - module = setup_mock_module (tc, NULL); + module = setup_mock_module (NULL); rv = (module->C_GetTokenInfo) (MOCK_SLOT_ONE_ID, &info); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); string = p11_kit_space_strdup (info.label, sizeof (info.label)); - CuAssertStrEquals (tc, "TEST LABEL", string); + assert_str_eq ("TEST LABEL", string); free (string); string = p11_kit_space_strdup (info.manufacturerID, sizeof (info.manufacturerID)); - CuAssertStrEquals (tc, "TEST MANUFACTURER", string); + assert_str_eq ("TEST MANUFACTURER", string); free (string); string = p11_kit_space_strdup (info.model, sizeof (info.model)); - CuAssertStrEquals (tc, "TEST MODEL", string); + assert_str_eq ("TEST MODEL", string); free (string); string = p11_kit_space_strdup (info.serialNumber, sizeof (info.serialNumber)); - CuAssertStrEquals (tc, "TEST SERIAL", string); + assert_str_eq ("TEST SERIAL", string); free (string); - CuAssertIntEquals (tc, CKF_LOGIN_REQUIRED | CKF_USER_PIN_INITIALIZED | CKF_CLOCK_ON_TOKEN | CKF_TOKEN_INITIALIZED, info.flags); - CuAssertIntEquals (tc, 1, info.ulMaxSessionCount); - CuAssertIntEquals (tc, 2, info.ulSessionCount); - CuAssertIntEquals (tc, 3, info.ulMaxRwSessionCount); - CuAssertIntEquals (tc, 4, info.ulRwSessionCount); - CuAssertIntEquals (tc, 5, info.ulMaxPinLen); - CuAssertIntEquals (tc, 6, info.ulMinPinLen); - CuAssertIntEquals (tc, 7, info.ulTotalPublicMemory); - CuAssertIntEquals (tc, 8, info.ulFreePublicMemory); - CuAssertIntEquals (tc, 9, info.ulTotalPrivateMemory); - CuAssertIntEquals (tc, 10, info.ulFreePrivateMemory); - CuAssertIntEquals (tc, 75, info.hardwareVersion.major); - CuAssertIntEquals (tc, 175, info.hardwareVersion.minor); - CuAssertIntEquals (tc, 85, info.firmwareVersion.major); - CuAssertIntEquals (tc, 185, info.firmwareVersion.minor); - CuAssertTrue (tc, memcmp (info.utcTime, "1999052509195900", sizeof (info.utcTime)) == 0); + assert_num_eq (CKF_LOGIN_REQUIRED | CKF_USER_PIN_INITIALIZED | CKF_CLOCK_ON_TOKEN | CKF_TOKEN_INITIALIZED, info.flags); + assert_num_eq (1, info.ulMaxSessionCount); + assert_num_eq (2, info.ulSessionCount); + assert_num_eq (3, info.ulMaxRwSessionCount); + assert_num_eq (4, info.ulRwSessionCount); + assert_num_eq (5, info.ulMaxPinLen); + assert_num_eq (6, info.ulMinPinLen); + assert_num_eq (7, info.ulTotalPublicMemory); + assert_num_eq (8, info.ulFreePublicMemory); + assert_num_eq (9, info.ulTotalPrivateMemory); + assert_num_eq (10, info.ulFreePrivateMemory); + assert_num_eq (75, info.hardwareVersion.major); + assert_num_eq (175, info.hardwareVersion.minor); + assert_num_eq (85, info.firmwareVersion.major); + assert_num_eq (185, info.firmwareVersion.minor); + assert (memcmp (info.utcTime, "1999052509195900", sizeof (info.utcTime)) == 0); rv = (module->C_GetTokenInfo) (MOCK_SLOT_TWO_ID, &info); - CuAssertTrue (tc, rv == CKR_TOKEN_NOT_PRESENT); + assert (rv == CKR_TOKEN_NOT_PRESENT); rv = (module->C_GetTokenInfo) (0, &info); - CuAssertTrue (tc, rv == CKR_SLOT_ID_INVALID); + assert (rv == CKR_SLOT_ID_INVALID); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_get_mechanism_list (CuTest *tc) +test_get_mechanism_list (void) { CK_FUNCTION_LIST_PTR module; CK_MECHANISM_TYPE mechs[8]; CK_ULONG count = 0; CK_RV rv; - module = setup_mock_module (tc, NULL); + module = setup_mock_module (NULL); rv = (module->C_GetMechanismList) (MOCK_SLOT_ONE_ID, NULL, &count); - CuAssertTrue (tc, rv == CKR_OK); - CuAssertIntEquals (tc, 2, count); + assert (rv == CKR_OK); + assert_num_eq (2, count); rv = (module->C_GetMechanismList) (MOCK_SLOT_TWO_ID, NULL, &count); - CuAssertTrue (tc, rv == CKR_TOKEN_NOT_PRESENT); + assert (rv == CKR_TOKEN_NOT_PRESENT); rv = (module->C_GetMechanismList) (0, NULL, &count); - CuAssertTrue (tc, rv == CKR_SLOT_ID_INVALID); + assert (rv == CKR_SLOT_ID_INVALID); count = 8; rv = (module->C_GetMechanismList) (MOCK_SLOT_ONE_ID, mechs, &count); - CuAssertTrue (tc, rv == CKR_OK); - CuAssertIntEquals (tc, 2, count); - CuAssertIntEquals (tc, mechs[0], CKM_MOCK_CAPITALIZE); - CuAssertIntEquals (tc, mechs[1], CKM_MOCK_PREFIX); + assert (rv == CKR_OK); + assert_num_eq (2, count); + assert_num_eq (mechs[0], CKM_MOCK_CAPITALIZE); + assert_num_eq (mechs[1], CKM_MOCK_PREFIX); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_get_mechanism_info (CuTest *tc) +test_get_mechanism_info (void) { CK_FUNCTION_LIST_PTR module; CK_MECHANISM_INFO info; CK_RV rv; - module = setup_mock_module (tc, NULL); + module = setup_mock_module (NULL); rv = (module->C_GetMechanismInfo) (MOCK_SLOT_ONE_ID, CKM_MOCK_CAPITALIZE, &info); - CuAssertTrue (tc, rv == CKR_OK); - CuAssertIntEquals (tc, 512, info.ulMinKeySize); - CuAssertIntEquals (tc, 4096, info.ulMaxKeySize); - CuAssertIntEquals (tc, CKF_ENCRYPT | CKF_DECRYPT, info.flags); + assert (rv == CKR_OK); + assert_num_eq (512, info.ulMinKeySize); + assert_num_eq (4096, info.ulMaxKeySize); + assert_num_eq (CKF_ENCRYPT | CKF_DECRYPT, info.flags); rv = (module->C_GetMechanismInfo) (MOCK_SLOT_ONE_ID, CKM_MOCK_PREFIX, &info); - CuAssertTrue (tc, rv == CKR_OK); - CuAssertIntEquals (tc, 2048, info.ulMinKeySize); - CuAssertIntEquals (tc, 2048, info.ulMaxKeySize); - CuAssertIntEquals (tc, CKF_SIGN | CKF_VERIFY, info.flags); + assert (rv == CKR_OK); + assert_num_eq (2048, info.ulMinKeySize); + assert_num_eq (2048, info.ulMaxKeySize); + assert_num_eq (CKF_SIGN | CKF_VERIFY, info.flags); rv = (module->C_GetMechanismInfo) (MOCK_SLOT_TWO_ID, CKM_MOCK_PREFIX, &info); - CuAssertTrue (tc, rv == CKR_TOKEN_NOT_PRESENT); + assert (rv == CKR_TOKEN_NOT_PRESENT); rv = (module->C_GetMechanismInfo) (MOCK_SLOT_ONE_ID, 0, &info); - CuAssertTrue (tc, rv == CKR_MECHANISM_INVALID); + assert (rv == CKR_MECHANISM_INVALID); rv = (module->C_GetMechanismInfo) (0, CKM_MOCK_PREFIX, &info); - CuAssertTrue (tc, rv == CKR_SLOT_ID_INVALID); + assert (rv == CKR_SLOT_ID_INVALID); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_init_token (CuTest *tc) +test_init_token (void) { CK_FUNCTION_LIST_PTR module; CK_RV rv; - module = setup_mock_module (tc, NULL); + module = setup_mock_module (NULL); rv = (module->C_InitToken) (MOCK_SLOT_ONE_ID, (CK_UTF8CHAR_PTR)"TEST PIN", 8, (CK_UTF8CHAR_PTR)"TEST LABEL"); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_InitToken) (MOCK_SLOT_ONE_ID, (CK_UTF8CHAR_PTR)"OTHER", 5, (CK_UTF8CHAR_PTR)"TEST LABEL"); - CuAssertTrue (tc, rv == CKR_PIN_INVALID); + assert (rv == CKR_PIN_INVALID); rv = (module->C_InitToken) (MOCK_SLOT_TWO_ID, (CK_UTF8CHAR_PTR)"TEST PIN", 8, (CK_UTF8CHAR_PTR)"TEST LABEL"); - CuAssertTrue (tc, rv == CKR_TOKEN_NOT_PRESENT); + assert (rv == CKR_TOKEN_NOT_PRESENT); rv = (module->C_InitToken) (0, (CK_UTF8CHAR_PTR)"TEST PIN", 8, (CK_UTF8CHAR_PTR)"TEST LABEL"); - CuAssertTrue (tc, rv == CKR_SLOT_ID_INVALID); + assert (rv == CKR_SLOT_ID_INVALID); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_wait_for_slot_event (CuTest *tc) +test_wait_for_slot_event (void) { CK_FUNCTION_LIST_PTR module; CK_SLOT_ID slot; @@ -271,179 +271,179 @@ test_wait_for_slot_event (CuTest *tc) return; #endif - module = setup_mock_module (tc, NULL); + module = setup_mock_module (NULL); rv = (module->C_WaitForSlotEvent) (0, &slot, NULL); - CuAssertTrue (tc, rv == CKR_OK); - CuAssertIntEquals (tc, slot, MOCK_SLOT_TWO_ID); + assert (rv == CKR_OK); + assert_num_eq (slot, MOCK_SLOT_TWO_ID); rv = (module->C_WaitForSlotEvent) (CKF_DONT_BLOCK, &slot, NULL); - CuAssertTrue (tc, rv == CKR_NO_EVENT); + assert (rv == CKR_NO_EVENT); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_open_close_session (CuTest *tc) +test_open_close_session (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; CK_RV rv; - module = setup_mock_module (tc, NULL); + module = setup_mock_module (NULL); rv = (module->C_OpenSession) (MOCK_SLOT_TWO_ID, CKF_SERIAL_SESSION, NULL, NULL, &session); - CuAssertTrue (tc, rv == CKR_TOKEN_NOT_PRESENT); + assert (rv == CKR_TOKEN_NOT_PRESENT); rv = (module->C_OpenSession) (0, CKF_SERIAL_SESSION, NULL, NULL, &session); - CuAssertTrue (tc, rv == CKR_SLOT_ID_INVALID); + assert (rv == CKR_SLOT_ID_INVALID); rv = (module->C_OpenSession) (MOCK_SLOT_ONE_ID, CKF_SERIAL_SESSION, NULL, NULL, &session); - CuAssertTrue (tc, rv == CKR_OK); - CuAssertTrue (tc, session != 0); + assert (rv == CKR_OK); + assert (session != 0); rv = (module->C_CloseSession) (session); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_CloseSession) (session); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_close_all_sessions (CuTest *tc) +test_close_all_sessions (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; CK_RV rv; - module = setup_mock_module (tc, NULL); + module = setup_mock_module (NULL); rv = (module->C_OpenSession) (MOCK_SLOT_ONE_ID, CKF_SERIAL_SESSION, NULL, NULL, &session); - CuAssertTrue (tc, rv == CKR_OK); - CuAssertTrue (tc, session != 0); + assert (rv == CKR_OK); + assert (session != 0); rv = (module->C_CloseAllSessions) (MOCK_SLOT_ONE_ID); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_CloseSession) (session); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_get_function_status (CuTest *tc) +test_get_function_status (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); rv = (module->C_GetFunctionStatus) (session); - CuAssertTrue (tc, rv == CKR_FUNCTION_NOT_PARALLEL); + assert (rv == CKR_FUNCTION_NOT_PARALLEL); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_cancel_function (CuTest *tc) +test_cancel_function (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); rv = (module->C_CancelFunction) (session); - CuAssertTrue (tc, rv == CKR_FUNCTION_NOT_PARALLEL); + assert (rv == CKR_FUNCTION_NOT_PARALLEL); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_get_session_info (CuTest *tc) +test_get_session_info (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; CK_SESSION_INFO info; CK_RV rv; - module = setup_mock_module (tc, NULL); + module = setup_mock_module (NULL); rv = (module->C_GetSessionInfo) (0, &info); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); rv = (module->C_OpenSession) (MOCK_SLOT_ONE_ID, CKF_SERIAL_SESSION, NULL, NULL, &session); - CuAssertTrue (tc, rv == CKR_OK); - CuAssertTrue (tc, session != 0); + assert (rv == CKR_OK); + assert (session != 0); rv = (module->C_GetSessionInfo) (session, &info); - CuAssertTrue (tc, rv == CKR_OK); - CuAssertIntEquals (tc, MOCK_SLOT_ONE_ID, info.slotID); - CuAssertIntEquals (tc, CKS_RO_PUBLIC_SESSION, info.state); - CuAssertIntEquals (tc, CKF_SERIAL_SESSION, info.flags); - CuAssertIntEquals (tc, 1414, info.ulDeviceError); + assert (rv == CKR_OK); + assert_num_eq (MOCK_SLOT_ONE_ID, info.slotID); + assert_num_eq (CKS_RO_PUBLIC_SESSION, info.state); + assert_num_eq (CKF_SERIAL_SESSION, info.flags); + assert_num_eq (1414, info.ulDeviceError); rv = (module->C_OpenSession) (MOCK_SLOT_ONE_ID, CKF_RW_SESSION | CKF_SERIAL_SESSION, NULL, NULL, &session); - CuAssertTrue (tc, rv == CKR_OK); - CuAssertTrue (tc, session != 0); + assert (rv == CKR_OK); + assert (session != 0); rv = (module->C_GetSessionInfo) (session, &info); - CuAssertTrue (tc, rv == CKR_OK); - CuAssertIntEquals (tc, MOCK_SLOT_ONE_ID, info.slotID); - CuAssertIntEquals (tc, CKS_RW_PUBLIC_SESSION, info.state); - CuAssertIntEquals (tc, CKF_SERIAL_SESSION | CKF_RW_SESSION, info.flags); - CuAssertIntEquals (tc, 1414, info.ulDeviceError); + assert (rv == CKR_OK); + assert_num_eq (MOCK_SLOT_ONE_ID, info.slotID); + assert_num_eq (CKS_RW_PUBLIC_SESSION, info.state); + assert_num_eq (CKF_SERIAL_SESSION | CKF_RW_SESSION, info.flags); + assert_num_eq (1414, info.ulDeviceError); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_init_pin (CuTest *tc) +test_init_pin (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); rv = (module->C_InitPIN) (0, (CK_UTF8CHAR_PTR)"TEST PIN", 8); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); rv = (module->C_InitPIN) (session, (CK_UTF8CHAR_PTR)"TEST PIN", 8); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_InitPIN) (session, (CK_UTF8CHAR_PTR)"OTHER", 5); - CuAssertTrue (tc, rv == CKR_PIN_INVALID); + assert (rv == CKR_PIN_INVALID); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_set_pin (CuTest *tc) +test_set_pin (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); rv = (module->C_SetPIN) (0, (CK_UTF8CHAR_PTR)"booo", 4, (CK_UTF8CHAR_PTR)"TEST PIN", 8); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); rv = (module->C_SetPIN) (session, (CK_UTF8CHAR_PTR)"booo", 4, (CK_UTF8CHAR_PTR)"TEST PIN", 8); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_SetPIN) (session, (CK_UTF8CHAR_PTR)"other", 5, (CK_UTF8CHAR_PTR)"OTHER", 5); - CuAssertTrue (tc, rv == CKR_PIN_INCORRECT); + assert (rv == CKR_PIN_INCORRECT); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_operation_state (CuTest *tc) +test_operation_state (void) { CK_FUNCTION_LIST_PTR module; CK_BYTE state[128]; @@ -451,54 +451,54 @@ test_operation_state (CuTest *tc) CK_SESSION_HANDLE session = 0; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); state_len = sizeof (state); rv = (module->C_GetOperationState) (0, state, &state_len); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); state_len = sizeof (state); rv = (module->C_GetOperationState) (session, state, &state_len); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_SetOperationState) (session, state, state_len, 355, 455); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_SetOperationState) (0, state, state_len, 355, 455); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_login_logout (CuTest *tc) +test_login_logout (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); rv = (module->C_Login) (0, CKU_USER, (CK_UTF8CHAR_PTR)"booo", 4); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); rv = (module->C_Login) (session, CKU_USER, (CK_UTF8CHAR_PTR)"bo", 2); - CuAssertTrue (tc, rv == CKR_PIN_INCORRECT); + assert (rv == CKR_PIN_INCORRECT); rv = (module->C_Login) (session, CKU_USER, (CK_UTF8CHAR_PTR)"booo", 4); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_Logout) (session); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_Logout) (session); - CuAssertTrue (tc, rv == CKR_USER_NOT_LOGGED_IN); + assert (rv == CKR_USER_NOT_LOGGED_IN); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_get_attribute_value (CuTest *tc) +test_get_attribute_value (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; @@ -507,7 +507,7 @@ test_get_attribute_value (CuTest *tc) CK_OBJECT_CLASS klass; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); attrs[0].type = CKA_CLASS; attrs[0].pValue = &klass; @@ -520,44 +520,44 @@ test_get_attribute_value (CuTest *tc) attrs[2].ulValueLen = 0; rv = (module->C_GetAttributeValue) (session, MOCK_PRIVATE_KEY_CAPITALIZE, attrs, 3); - CuAssertTrue (tc, rv == CKR_USER_NOT_LOGGED_IN); + assert (rv == CKR_USER_NOT_LOGGED_IN); rv = (module->C_GetAttributeValue) (session, MOCK_PUBLIC_KEY_CAPITALIZE, attrs, 2); - CuAssertTrue (tc, rv == CKR_BUFFER_TOO_SMALL); + assert (rv == CKR_BUFFER_TOO_SMALL); /* Get right size */ attrs[1].pValue = NULL; attrs[1].ulValueLen = 0; rv = (module->C_GetAttributeValue) (session, MOCK_PUBLIC_KEY_CAPITALIZE, attrs, 2); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_GetAttributeValue) (session, MOCK_PUBLIC_KEY_CAPITALIZE, attrs, 3); - CuAssertTrue (tc, rv == CKR_ATTRIBUTE_TYPE_INVALID); + assert (rv == CKR_ATTRIBUTE_TYPE_INVALID); - CuAssertIntEquals (tc, CKO_PUBLIC_KEY, klass); - CuAssertIntEquals (tc, 21, attrs[1].ulValueLen); - CuAssertPtrEquals (tc, NULL, attrs[1].pValue); + assert_num_eq (CKO_PUBLIC_KEY, klass); + assert_num_eq (21, attrs[1].ulValueLen); + assert_ptr_eq (NULL, attrs[1].pValue); attrs[1].pValue = label; attrs[1].ulValueLen = sizeof (label); - CuAssertTrue (tc, (CK_ULONG)-1 == attrs[2].ulValueLen); - CuAssertPtrEquals (tc, NULL, attrs[2].pValue); + assert ((CK_ULONG)-1 == attrs[2].ulValueLen); + assert_ptr_eq (NULL, attrs[2].pValue); rv = (module->C_GetAttributeValue) (session, MOCK_PUBLIC_KEY_CAPITALIZE, attrs, 3); - CuAssertTrue (tc, rv == CKR_ATTRIBUTE_TYPE_INVALID); + assert (rv == CKR_ATTRIBUTE_TYPE_INVALID); - CuAssertIntEquals (tc, CKO_PUBLIC_KEY, klass); - CuAssertIntEquals (tc, 21, attrs[1].ulValueLen); - CuAssertPtrEquals (tc, label, attrs[1].pValue); - CuAssertTrue (tc, memcmp (label, "Public Capitalize Key", attrs[1].ulValueLen) == 0); - CuAssertTrue (tc, (CK_ULONG)-1 == attrs[2].ulValueLen); - CuAssertPtrEquals (tc, NULL, attrs[2].pValue); + assert_num_eq (CKO_PUBLIC_KEY, klass); + assert_num_eq (21, attrs[1].ulValueLen); + assert_ptr_eq (label, attrs[1].pValue); + assert (memcmp (label, "Public Capitalize Key", attrs[1].ulValueLen) == 0); + assert ((CK_ULONG)-1 == attrs[2].ulValueLen); + assert_ptr_eq (NULL, attrs[2].pValue); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_set_attribute_value (CuTest *tc) +test_set_attribute_value (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; @@ -566,7 +566,7 @@ test_set_attribute_value (CuTest *tc) CK_ULONG bits; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); strcpy (label, "Blahooo"); bits = 1555; @@ -579,26 +579,26 @@ test_set_attribute_value (CuTest *tc) attrs[1].ulValueLen = sizeof (bits); rv = (module->C_SetAttributeValue) (session, MOCK_PRIVATE_KEY_CAPITALIZE, attrs, 2); - CuAssertTrue (tc, rv == CKR_USER_NOT_LOGGED_IN); + assert (rv == CKR_USER_NOT_LOGGED_IN); rv = (module->C_SetAttributeValue) (session, MOCK_PUBLIC_KEY_CAPITALIZE, attrs, 2); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); memset (label, 0, sizeof (label)); bits = 0; rv = (module->C_GetAttributeValue) (session, MOCK_PUBLIC_KEY_CAPITALIZE, attrs, 2); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - CuAssertIntEquals (tc, bits, 1555); - CuAssertIntEquals (tc, 7, attrs[0].ulValueLen); - CuAssertTrue (tc, memcmp (label, "Blahooo", attrs[0].ulValueLen) == 0); + assert_num_eq (bits, 1555); + assert_num_eq (7, attrs[0].ulValueLen); + assert (memcmp (label, "Blahooo", attrs[0].ulValueLen) == 0); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_create_object (CuTest *tc) +test_create_object (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; @@ -608,7 +608,7 @@ test_create_object (CuTest *tc) CK_ULONG bits; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); strcpy (label, "Blahooo"); bits = 1555; @@ -621,27 +621,27 @@ test_create_object (CuTest *tc) attrs[1].ulValueLen = sizeof (bits); rv = (module->C_CreateObject) (0, attrs, 2, &object); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); rv = (module->C_CreateObject) (session, attrs, 2, &object); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); attrs[0].ulValueLen = sizeof (label); memset (label, 0, sizeof (label)); bits = 0; rv = (module->C_GetAttributeValue) (session, object, attrs, 2); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - CuAssertIntEquals (tc, bits, 1555); - CuAssertIntEquals (tc, 7, attrs[0].ulValueLen); - CuAssertTrue (tc, memcmp (label, "Blahooo", attrs[0].ulValueLen) == 0); + assert_num_eq (bits, 1555); + assert_num_eq (7, attrs[0].ulValueLen); + assert (memcmp (label, "Blahooo", attrs[0].ulValueLen) == 0); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_copy_object (CuTest *tc) +test_copy_object (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; @@ -651,7 +651,7 @@ test_copy_object (CuTest *tc) CK_ULONG bits; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); bits = 1555; @@ -660,10 +660,10 @@ test_copy_object (CuTest *tc) attrs[0].ulValueLen = sizeof (bits); rv = (module->C_CopyObject) (session, 1333, attrs, 1, &object); - CuAssertTrue (tc, rv == CKR_OBJECT_HANDLE_INVALID); + assert (rv == CKR_OBJECT_HANDLE_INVALID); rv = (module->C_CopyObject) (session, MOCK_PUBLIC_KEY_CAPITALIZE, attrs, 1, &object); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); attrs[1].type = CKA_LABEL; attrs[1].pValue = label; @@ -671,17 +671,17 @@ test_copy_object (CuTest *tc) bits = 0; rv = (module->C_GetAttributeValue) (session, object, attrs, 2); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - CuAssertIntEquals (tc, bits, 1555); - CuAssertIntEquals (tc, 21, attrs[1].ulValueLen); - CuAssertTrue (tc, memcmp (label, "Public Capitalize Key", attrs[1].ulValueLen) == 0); + assert_num_eq (bits, 1555); + assert_num_eq (21, attrs[1].ulValueLen); + assert (memcmp (label, "Public Capitalize Key", attrs[1].ulValueLen) == 0); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_destroy_object (CuTest *tc) +test_destroy_object (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; @@ -689,51 +689,51 @@ test_destroy_object (CuTest *tc) char label[32]; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); attrs[0].type = CKA_LABEL; attrs[0].pValue = label; attrs[0].ulValueLen = sizeof (label); rv = (module->C_GetAttributeValue) (session, MOCK_PUBLIC_KEY_CAPITALIZE, attrs, 1); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_DestroyObject) (0, MOCK_PUBLIC_KEY_CAPITALIZE); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); rv = (module->C_DestroyObject) (session, MOCK_PUBLIC_KEY_CAPITALIZE); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_GetAttributeValue) (session, MOCK_PUBLIC_KEY_CAPITALIZE, attrs, 1); - CuAssertTrue (tc, rv == CKR_OBJECT_HANDLE_INVALID); + assert (rv == CKR_OBJECT_HANDLE_INVALID); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_get_object_size (CuTest *tc) +test_get_object_size (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; CK_ULONG size; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); rv = (module->C_GetObjectSize) (session, 1333, &size); - CuAssertTrue (tc, rv == CKR_OBJECT_HANDLE_INVALID); + assert (rv == CKR_OBJECT_HANDLE_INVALID); rv = (module->C_GetObjectSize) (session, MOCK_PUBLIC_KEY_CAPITALIZE, &size); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); /* The number here is the length of all attributes added up */ - CuAssertIntEquals (tc, sizeof (CK_ULONG) == 8 ? 44 : 36, size); + assert_num_eq (sizeof (CK_ULONG) == 8 ? 44 : 36, size); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_find_objects (CuTest *tc) +test_find_objects (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; @@ -744,55 +744,55 @@ test_find_objects (CuTest *tc) CK_ULONG i; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); rv = (module->C_FindObjectsInit) (0, &attr, 1); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); rv = (module->C_FindObjectsInit) (session, &attr, 1); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_FindObjects) (0, objects, 16, &count); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); rv = (module->C_FindObjects) (session, objects, 16, &count); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - CuAssertTrue (tc, count < 16); + assert (count < 16); /* Make sure we get the capitalize public key */ for (i = 0; i < count; i++) { if (objects[i] == MOCK_PUBLIC_KEY_CAPITALIZE) break; } - CuAssertTrue (tc, i != count); + assert (i != count); /* Make sure we get the prefix public key */ for (i = 0; i < count; i++) { if (objects[i] == MOCK_PUBLIC_KEY_PREFIX) break; } - CuAssertTrue (tc, i != count); + assert (i != count); /* Make sure all public keys */ for (i = 0; i < count; i++) { klass = (CK_ULONG)-1; rv = (module->C_GetAttributeValue) (session, objects[i], &attr, 1); - CuAssertTrue (tc, rv == CKR_OK); - CuAssertIntEquals (tc, CKO_PUBLIC_KEY, klass); + assert (rv == CKR_OK); + assert_num_eq (CKO_PUBLIC_KEY, klass); } rv = (module->C_FindObjectsFinal) (session); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_FindObjectsFinal) (session); - CuAssertTrue (tc, rv == CKR_OPERATION_NOT_INITIALIZED); + assert (rv == CKR_OPERATION_NOT_INITIALIZED); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_encrypt (CuTest *tc) +test_encrypt (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; @@ -801,52 +801,52 @@ test_encrypt (CuTest *tc) CK_ULONG length; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); rv = (module->C_EncryptInit) (session, &mech, MOCK_PUBLIC_KEY_PREFIX); - CuAssertTrue (tc, rv == CKR_KEY_HANDLE_INVALID); + assert (rv == CKR_KEY_HANDLE_INVALID); rv = (module->C_EncryptInit) (session, &mech, MOCK_PUBLIC_KEY_CAPITALIZE); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); length = sizeof (data); rv = (module->C_Encrypt) (0, (CK_BYTE_PTR)"blah", 4, data, &length); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); length = sizeof (data); rv = (module->C_Encrypt) (session, (CK_BYTE_PTR)"blah", 4, data, &length); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - CuAssertIntEquals (tc, 4, length); - CuAssertTrue (tc, memcmp (data, "BLAH", 4) == 0); + assert_num_eq (4, length); + assert (memcmp (data, "BLAH", 4) == 0); rv = (module->C_EncryptInit) (session, &mech, MOCK_PUBLIC_KEY_CAPITALIZE); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); length = sizeof (data); rv = (module->C_EncryptUpdate) (0, (CK_BYTE_PTR)"blah", 4, data, &length); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); length = sizeof (data); rv = (module->C_EncryptUpdate) (session, (CK_BYTE_PTR)"sLurm", 5, data, &length); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - CuAssertIntEquals (tc, 5, length); - CuAssertTrue (tc, memcmp (data, "SLURM", 5) == 0); + assert_num_eq (5, length); + assert (memcmp (data, "SLURM", 5) == 0); length = sizeof (data); rv = (module->C_EncryptFinal) (0, data, &length); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); length = sizeof (data); rv = (module->C_EncryptFinal) (session, data, &length); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_decrypt (CuTest *tc) +test_decrypt (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; @@ -855,55 +855,55 @@ test_decrypt (CuTest *tc) CK_ULONG length; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); rv = (module->C_Login) (session, CKU_USER, (CK_BYTE_PTR)"booo", 4); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_DecryptInit) (session, &mech, MOCK_PRIVATE_KEY_PREFIX); - CuAssertTrue (tc, rv == CKR_KEY_HANDLE_INVALID); + assert (rv == CKR_KEY_HANDLE_INVALID); rv = (module->C_DecryptInit) (session, &mech, MOCK_PRIVATE_KEY_CAPITALIZE); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); length = sizeof (data); rv = (module->C_Decrypt) (0, (CK_BYTE_PTR)"bLAH", 4, data, &length); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); length = sizeof (data); rv = (module->C_Decrypt) (session, (CK_BYTE_PTR)"BLAh", 4, data, &length); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - CuAssertIntEquals (tc, 4, length); - CuAssertTrue (tc, memcmp (data, "blah", 4) == 0); + assert_num_eq (4, length); + assert (memcmp (data, "blah", 4) == 0); rv = (module->C_DecryptInit) (session, &mech, MOCK_PRIVATE_KEY_CAPITALIZE); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); length = sizeof (data); rv = (module->C_DecryptUpdate) (0, (CK_BYTE_PTR)"blah", 4, data, &length); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); length = sizeof (data); rv = (module->C_DecryptUpdate) (session, (CK_BYTE_PTR)"sLuRM", 5, data, &length); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - CuAssertIntEquals (tc, 5, length); - CuAssertTrue (tc, memcmp (data, "slurm", 5) == 0); + assert_num_eq (5, length); + assert (memcmp (data, "slurm", 5) == 0); length = sizeof (data); rv = (module->C_DecryptFinal) (0, data, &length); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); length = sizeof (data); rv = (module->C_DecryptFinal) (session, data, &length); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_digest (CuTest *tc) +test_digest (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; @@ -912,58 +912,58 @@ test_digest (CuTest *tc) CK_ULONG length; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); rv = (module->C_DigestInit) (0, &mech); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); rv = (module->C_DigestInit) (session, &mech); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); length = sizeof (digest); rv = (module->C_Digest) (0, (CK_BYTE_PTR)"bLAH", 4, digest, &length); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); length = sizeof (digest); rv = (module->C_Digest) (session, (CK_BYTE_PTR)"BLAh", 4, digest, &length); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - CuAssertIntEquals (tc, 1, length); - CuAssertTrue (tc, memcmp (digest, "4", 1) == 0); + assert_num_eq (1, length); + assert (memcmp (digest, "4", 1) == 0); rv = (module->C_DigestInit) (session, &mech); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_DigestUpdate) (0, (CK_BYTE_PTR)"blah", 4); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); rv = (module->C_DigestUpdate) (session, (CK_BYTE_PTR)"sLuRM", 5); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); /* Adds the the value of object handle to hash: 6 */ - CuAssertIntEquals (tc, 6, MOCK_PUBLIC_KEY_PREFIX); + assert_num_eq (6, MOCK_PUBLIC_KEY_PREFIX); rv = (module->C_DigestKey) (session, MOCK_PUBLIC_KEY_PREFIX); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_DigestUpdate) (session, (CK_BYTE_PTR)"Other", 5); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); length = sizeof (digest); rv = (module->C_DigestFinal) (0, digest, &length); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); length = sizeof (digest); rv = (module->C_DigestFinal) (session, digest, &length); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - CuAssertIntEquals (tc, 2, length); - CuAssertTrue (tc, memcmp (digest, "16", 2) == 0); + assert_num_eq (2, length); + assert (memcmp (digest, "16", 2) == 0); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_sign (CuTest *tc) +test_sign (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; @@ -972,62 +972,62 @@ test_sign (CuTest *tc) CK_ULONG length; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); rv = (module->C_Login) (session, CKU_USER, (CK_BYTE_PTR)"booo", 4); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_SignInit) (0, &mech, MOCK_PRIVATE_KEY_PREFIX); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); rv = (module->C_SignInit) (session, &mech, MOCK_PRIVATE_KEY_PREFIX); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_Login) (session, CKU_CONTEXT_SPECIFIC, (CK_BYTE_PTR)"booo", 4); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); length = sizeof (signature); rv = (module->C_Sign) (0, (CK_BYTE_PTR)"bLAH", 4, signature, &length); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); length = sizeof (signature); rv = (module->C_Sign) (session, (CK_BYTE_PTR)"BLAh", 4, signature, &length); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - CuAssertIntEquals (tc, 13, length); - CuAssertTrue (tc, memcmp (signature, "prefix:value4", 13) == 0); + assert_num_eq (13, length); + assert (memcmp (signature, "prefix:value4", 13) == 0); rv = (module->C_SignInit) (session, &mech, MOCK_PRIVATE_KEY_PREFIX); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_Login) (session, CKU_CONTEXT_SPECIFIC, (CK_BYTE_PTR)"booo", 4); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_SignUpdate) (0, (CK_BYTE_PTR)"blah", 4); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); rv = (module->C_SignUpdate) (session, (CK_BYTE_PTR)"sLuRM", 5); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_SignUpdate) (session, (CK_BYTE_PTR)"Other", 5); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); length = sizeof (signature); rv = (module->C_SignFinal) (0, signature, &length); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); length = sizeof (signature); rv = (module->C_SignFinal) (session, signature, &length); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - CuAssertIntEquals (tc, 14, length); - CuAssertTrue (tc, memcmp (signature, "prefix:value10", 2) == 0); + assert_num_eq (14, length); + assert (memcmp (signature, "prefix:value10", 2) == 0); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_sign_recover (CuTest *tc) +test_sign_recover (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; @@ -1036,36 +1036,36 @@ test_sign_recover (CuTest *tc) CK_ULONG length; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); rv = (module->C_Login) (session, CKU_USER, (CK_BYTE_PTR)"booo", 4); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_SignRecoverInit) (0, &mech, MOCK_PRIVATE_KEY_PREFIX); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); rv = (module->C_SignRecoverInit) (session, &mech, MOCK_PRIVATE_KEY_PREFIX); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_Login) (session, CKU_CONTEXT_SPECIFIC, (CK_BYTE_PTR)"booo", 4); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); length = sizeof (signature); rv = (module->C_SignRecover) (0, (CK_BYTE_PTR)"bLAH", 4, signature, &length); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); length = sizeof (signature); rv = (module->C_SignRecover) (session, (CK_BYTE_PTR)"BLAh", 4, signature, &length); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - CuAssertIntEquals (tc, 16, length); - CuAssertTrue (tc, memcmp (signature, "prefix:valueBLAh", 16) == 0); + assert_num_eq (16, length); + assert (memcmp (signature, "prefix:valueBLAh", 16) == 0); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_verify (CuTest *tc) +test_verify (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; @@ -1074,48 +1074,48 @@ test_verify (CuTest *tc) CK_ULONG length; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); rv = (module->C_VerifyInit) (0, &mech, MOCK_PUBLIC_KEY_PREFIX); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); rv = (module->C_VerifyInit) (session, &mech, MOCK_PUBLIC_KEY_PREFIX); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); length = 13; memcpy (signature, "prefix:value4", length); rv = (module->C_Verify) (0, (CK_BYTE_PTR)"bLAH", 4, signature, 5); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); rv = (module->C_Verify) (session, (CK_BYTE_PTR)"BLAh", 4, signature, length); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_VerifyInit) (session, &mech, MOCK_PUBLIC_KEY_PREFIX); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_VerifyUpdate) (0, (CK_BYTE_PTR)"blah", 4); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); rv = (module->C_VerifyUpdate) (session, (CK_BYTE_PTR)"sLuRM", 5); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_VerifyUpdate) (session, (CK_BYTE_PTR)"Other", 5); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); length = 14; memcpy (signature, "prefix:value10", length); rv = (module->C_VerifyFinal) (session, signature, 5); - CuAssertTrue (tc, rv == CKR_SIGNATURE_LEN_RANGE); + assert (rv == CKR_SIGNATURE_LEN_RANGE); rv = (module->C_VerifyFinal) (session, signature, length); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_verify_recover (CuTest *tc) +test_verify_recover (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; @@ -1124,30 +1124,30 @@ test_verify_recover (CuTest *tc) CK_ULONG length; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); rv = (module->C_VerifyRecoverInit) (0, &mech, MOCK_PUBLIC_KEY_PREFIX); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); rv = (module->C_VerifyRecoverInit) (session, &mech, MOCK_PUBLIC_KEY_PREFIX); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); length = sizeof (data); rv = (module->C_VerifyRecover) (0, (CK_BYTE_PTR)"prefix:valueBLah", 16, data, &length); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); length = sizeof (data); rv = (module->C_VerifyRecover) (session, (CK_BYTE_PTR)"prefix:valueBLah", 16, data, &length); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - CuAssertIntEquals (tc, 4, length); - CuAssertTrue (tc, memcmp (data, "BLah", 4) == 0); + assert_num_eq (4, length); + assert (memcmp (data, "BLah", 4) == 0); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_digest_encrypt (CuTest *tc) +test_digest_encrypt (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; @@ -1157,41 +1157,41 @@ test_digest_encrypt (CuTest *tc) CK_ULONG length; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); rv = (module->C_EncryptInit) (session, &mech, MOCK_PUBLIC_KEY_CAPITALIZE); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_DigestInit) (session, &dmech); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); length = sizeof (data); rv = (module->C_DigestEncryptUpdate) (0, (CK_BYTE_PTR)"blah", 4, data, &length); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); length = sizeof (data); rv = (module->C_DigestEncryptUpdate) (session, (CK_BYTE_PTR)"blah", 4, data, &length); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - CuAssertIntEquals (tc, 4, length); - CuAssertTrue (tc, memcmp (data, "BLAH", 4) == 0); + assert_num_eq (4, length); + assert (memcmp (data, "BLAH", 4) == 0); length = sizeof (data); rv = (module->C_EncryptFinal) (session, data, &length); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); length = sizeof (data); rv = (module->C_DigestFinal) (session, data, &length); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - CuAssertIntEquals (tc, 1, length); - CuAssertTrue (tc, memcmp (data, "4", 1) == 0); + assert_num_eq (1, length); + assert (memcmp (data, "4", 1) == 0); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_decrypt_digest (CuTest *tc) +test_decrypt_digest (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; @@ -1201,44 +1201,44 @@ test_decrypt_digest (CuTest *tc) CK_ULONG length; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); rv = (module->C_Login) (session, CKU_USER, (CK_BYTE_PTR)"booo", 4); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_DecryptInit) (session, &mech, MOCK_PRIVATE_KEY_CAPITALIZE); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_DigestInit) (session, &dmech); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); length = sizeof (data); rv = (module->C_DecryptDigestUpdate) (0, (CK_BYTE_PTR)"BLAH", 4, data, &length); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); length = sizeof (data); rv = (module->C_DecryptDigestUpdate) (session, (CK_BYTE_PTR)"BLAH", 4, data, &length); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - CuAssertIntEquals (tc, 4, length); - CuAssertTrue (tc, memcmp (data, "blah", 4) == 0); + assert_num_eq (4, length); + assert (memcmp (data, "blah", 4) == 0); length = sizeof (data); rv = (module->C_DecryptFinal) (session, data, &length); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); length = sizeof (data); rv = (module->C_DigestFinal) (session, data, &length); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - CuAssertIntEquals (tc, 1, length); - CuAssertTrue (tc, memcmp (data, "4", 1) == 0); + assert_num_eq (1, length); + assert (memcmp (data, "4", 1) == 0); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_sign_encrypt (CuTest *tc) +test_sign_encrypt (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; @@ -1248,47 +1248,47 @@ test_sign_encrypt (CuTest *tc) CK_ULONG length; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); rv = (module->C_Login) (session, CKU_USER, (CK_BYTE_PTR)"booo", 4); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_EncryptInit) (session, &mech, MOCK_PUBLIC_KEY_CAPITALIZE); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_SignInit) (session, &smech, MOCK_PRIVATE_KEY_PREFIX); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_Login) (session, CKU_CONTEXT_SPECIFIC, (CK_BYTE_PTR)"booo", 4); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); length = sizeof (data); rv = (module->C_SignEncryptUpdate) (0, (CK_BYTE_PTR)"blah", 4, data, &length); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); length = sizeof (data); rv = (module->C_SignEncryptUpdate) (session, (CK_BYTE_PTR)"blah", 4, data, &length); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - CuAssertIntEquals (tc, 4, length); - CuAssertTrue (tc, memcmp (data, "BLAH", 4) == 0); + assert_num_eq (4, length); + assert (memcmp (data, "BLAH", 4) == 0); length = sizeof (data); rv = (module->C_EncryptFinal) (session, data, &length); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); length = sizeof (data); rv = (module->C_SignFinal) (session, data, &length); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - CuAssertIntEquals (tc, 8, length); - CuAssertTrue (tc, memcmp (data, "p:value4", 1) == 0); + assert_num_eq (8, length); + assert (memcmp (data, "p:value4", 1) == 0); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_decrypt_verify (CuTest *tc) +test_decrypt_verify (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; @@ -1298,40 +1298,40 @@ test_decrypt_verify (CuTest *tc) CK_ULONG length; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); rv = (module->C_Login) (session, CKU_USER, (CK_BYTE_PTR)"booo", 4); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_DecryptInit) (session, &mech, MOCK_PRIVATE_KEY_CAPITALIZE); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_VerifyInit) (session, &vmech, MOCK_PUBLIC_KEY_PREFIX); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); length = sizeof (data); rv = (module->C_DecryptVerifyUpdate) (0, (CK_BYTE_PTR)"BLAH", 4, data, &length); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); length = sizeof (data); rv = (module->C_DecryptVerifyUpdate) (session, (CK_BYTE_PTR)"BLAH", 4, data, &length); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - CuAssertIntEquals (tc, 4, length); - CuAssertTrue (tc, memcmp (data, "blah", 4) == 0); + assert_num_eq (4, length); + assert (memcmp (data, "blah", 4) == 0); length = sizeof (data); rv = (module->C_DecryptFinal) (session, data, &length); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_VerifyFinal) (session, (CK_BYTE_PTR)"p:value4", 8); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_generate_key (CuTest *tc) +test_generate_key (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; @@ -1343,7 +1343,7 @@ test_generate_key (CuTest *tc) CK_ULONG bits; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); strcpy (label, "Blahooo"); bits = 1555; @@ -1356,13 +1356,13 @@ test_generate_key (CuTest *tc) attrs[1].ulValueLen = sizeof (bits); rv = (module->C_GenerateKey) (session, &mech, attrs, 2, &object); - CuAssertTrue (tc, rv == CKR_MECHANISM_PARAM_INVALID); + assert (rv == CKR_MECHANISM_PARAM_INVALID); mech.pParameter = "generate"; mech.ulParameterLen = 9; rv = (module->C_GenerateKey) (session, &mech, attrs, 2, &object); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); attrs[0].ulValueLen = sizeof (label); memset (label, 0, sizeof (label)); @@ -1372,19 +1372,19 @@ test_generate_key (CuTest *tc) attrs[2].ulValueLen = sizeof (value); rv = (module->C_GetAttributeValue) (session, object, attrs, 3); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - CuAssertIntEquals (tc, bits, 1555); - CuAssertIntEquals (tc, 7, attrs[0].ulValueLen); - CuAssertTrue (tc, memcmp (label, "Blahooo", attrs[0].ulValueLen) == 0); - CuAssertIntEquals (tc, 9, attrs[2].ulValueLen); - CuAssertTrue (tc, memcmp (value, "generated", attrs[2].ulValueLen) == 0); + assert_num_eq (bits, 1555); + assert_num_eq (7, attrs[0].ulValueLen); + assert (memcmp (label, "Blahooo", attrs[0].ulValueLen) == 0); + assert_num_eq (9, attrs[2].ulValueLen); + assert (memcmp (value, "generated", attrs[2].ulValueLen) == 0); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_generate_key_pair (CuTest *tc) +test_generate_key_pair (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; @@ -1401,7 +1401,7 @@ test_generate_key_pair (CuTest *tc) CK_ULONG priv_bits; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); strcpy (pub_label, "Blahooo"); pub_bits = 1555; @@ -1423,14 +1423,14 @@ test_generate_key_pair (CuTest *tc) rv = (module->C_GenerateKeyPair) (0, &mech, pub_attrs, 2, priv_attrs, 2, &pub_object, &priv_object); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); mech.pParameter = "generate"; mech.ulParameterLen = 9; rv = (module->C_GenerateKeyPair) (session, &mech, pub_attrs, 2, priv_attrs, 2, &pub_object, &priv_object); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); pub_bits = 0; pub_attrs[0].ulValueLen = sizeof (pub_label); @@ -1440,13 +1440,13 @@ test_generate_key_pair (CuTest *tc) pub_attrs[2].ulValueLen = sizeof (pub_value); rv = (module->C_GetAttributeValue) (session, pub_object, pub_attrs, 3); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - CuAssertIntEquals (tc, 1555, pub_bits); - CuAssertIntEquals (tc, 7, pub_attrs[0].ulValueLen); - CuAssertTrue (tc, memcmp (pub_label, "Blahooo", pub_attrs[0].ulValueLen) == 0); - CuAssertIntEquals (tc, 9, pub_attrs[2].ulValueLen); - CuAssertTrue (tc, memcmp (pub_value, "generated", pub_attrs[2].ulValueLen) == 0); + assert_num_eq (1555, pub_bits); + assert_num_eq (7, pub_attrs[0].ulValueLen); + assert (memcmp (pub_label, "Blahooo", pub_attrs[0].ulValueLen) == 0); + assert_num_eq (9, pub_attrs[2].ulValueLen); + assert (memcmp (pub_value, "generated", pub_attrs[2].ulValueLen) == 0); priv_bits = 0; priv_attrs[0].ulValueLen = sizeof (priv_label); @@ -1456,19 +1456,19 @@ test_generate_key_pair (CuTest *tc) priv_attrs[2].ulValueLen = sizeof (priv_value); rv = (module->C_GetAttributeValue) (session, priv_object, priv_attrs, 3); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - CuAssertIntEquals (tc, 1666, priv_bits); - CuAssertIntEquals (tc, 7, priv_attrs[0].ulValueLen); - CuAssertTrue (tc, memcmp (priv_label, "Private", priv_attrs[0].ulValueLen) == 0); - CuAssertIntEquals (tc, 9, priv_attrs[2].ulValueLen); - CuAssertTrue (tc, memcmp (priv_value, "generated", priv_attrs[2].ulValueLen) == 0); + assert_num_eq (1666, priv_bits); + assert_num_eq (7, priv_attrs[0].ulValueLen); + assert (memcmp (priv_label, "Private", priv_attrs[0].ulValueLen) == 0); + assert_num_eq (9, priv_attrs[2].ulValueLen); + assert (memcmp (priv_value, "generated", priv_attrs[2].ulValueLen) == 0); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_wrap_key (CuTest *tc) +test_wrap_key (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; @@ -1477,26 +1477,26 @@ test_wrap_key (CuTest *tc) CK_ULONG length; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); length = sizeof (data); rv = (module->C_WrapKey) (session, &mech, MOCK_PUBLIC_KEY_PREFIX, MOCK_PUBLIC_KEY_PREFIX, data, &length); - CuAssertTrue (tc, rv == CKR_MECHANISM_PARAM_INVALID); + assert (rv == CKR_MECHANISM_PARAM_INVALID); mech.pParameter = "wrap"; mech.ulParameterLen = 4; rv = (module->C_WrapKey) (session, &mech, MOCK_PUBLIC_KEY_PREFIX, MOCK_PUBLIC_KEY_PREFIX, data, &length); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - CuAssertIntEquals (tc, 5, length); - CuAssertTrue (tc, memcmp (data, "value", 5) == 0); + assert_num_eq (5, length); + assert (memcmp (data, "value", 5) == 0); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_unwrap_key (CuTest *tc) +test_unwrap_key (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; @@ -1508,7 +1508,7 @@ test_unwrap_key (CuTest *tc) CK_ULONG bits; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); strcpy (label, "Blahooo"); bits = 1555; @@ -1522,14 +1522,14 @@ test_unwrap_key (CuTest *tc) rv = (module->C_UnwrapKey) (session, &mech, MOCK_PUBLIC_KEY_PREFIX, (CK_BYTE_PTR)"wheee", 5, attrs, 2, &object); - CuAssertTrue (tc, rv == CKR_MECHANISM_PARAM_INVALID); + assert (rv == CKR_MECHANISM_PARAM_INVALID); mech.pParameter = "wrap"; mech.ulParameterLen = 4; rv = (module->C_UnwrapKey) (session, &mech, MOCK_PUBLIC_KEY_PREFIX, (CK_BYTE_PTR)"wheee", 5, attrs, 2, &object); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); attrs[0].ulValueLen = sizeof (label); memset (label, 0, sizeof (label)); @@ -1539,19 +1539,19 @@ test_unwrap_key (CuTest *tc) attrs[2].ulValueLen = sizeof (value); rv = (module->C_GetAttributeValue) (session, object, attrs, 3); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - CuAssertIntEquals (tc, bits, 1555); - CuAssertIntEquals (tc, 7, attrs[0].ulValueLen); - CuAssertTrue (tc, memcmp (label, "Blahooo", attrs[0].ulValueLen) == 0); - CuAssertIntEquals (tc, 5, attrs[2].ulValueLen); - CuAssertTrue (tc, memcmp (value, "wheee", attrs[2].ulValueLen) == 0); + assert_num_eq (bits, 1555); + assert_num_eq (7, attrs[0].ulValueLen); + assert (memcmp (label, "Blahooo", attrs[0].ulValueLen) == 0); + assert_num_eq (5, attrs[2].ulValueLen); + assert (memcmp (value, "wheee", attrs[2].ulValueLen) == 0); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_derive_key (CuTest *tc) +test_derive_key (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; @@ -1563,7 +1563,7 @@ test_derive_key (CuTest *tc) CK_ULONG bits; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); strcpy (label, "Blahooo"); bits = 1555; @@ -1577,14 +1577,14 @@ test_derive_key (CuTest *tc) rv = (module->C_DeriveKey) (session, &mech, MOCK_PUBLIC_KEY_PREFIX, attrs, 2, &object); - CuAssertTrue (tc, rv == CKR_MECHANISM_PARAM_INVALID); + assert (rv == CKR_MECHANISM_PARAM_INVALID); mech.pParameter = "derive"; mech.ulParameterLen = 6; rv = (module->C_DeriveKey) (session, &mech, MOCK_PUBLIC_KEY_PREFIX, attrs, 2, &object); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); attrs[0].ulValueLen = sizeof (label); memset (label, 0, sizeof (label)); @@ -1594,86 +1594,86 @@ test_derive_key (CuTest *tc) attrs[2].ulValueLen = sizeof (value); rv = (module->C_GetAttributeValue) (session, object, attrs, 3); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - CuAssertIntEquals (tc, bits, 1555); - CuAssertIntEquals (tc, 7, attrs[0].ulValueLen); - CuAssertTrue (tc, memcmp (label, "Blahooo", attrs[0].ulValueLen) == 0); - CuAssertIntEquals (tc, 7, attrs[2].ulValueLen); - CuAssertTrue (tc, memcmp (value, "derived", attrs[2].ulValueLen) == 0); + assert_num_eq (bits, 1555); + assert_num_eq (7, attrs[0].ulValueLen); + assert (memcmp (label, "Blahooo", attrs[0].ulValueLen) == 0); + assert_num_eq (7, attrs[2].ulValueLen); + assert (memcmp (value, "derived", attrs[2].ulValueLen) == 0); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_random (CuTest *tc) +test_random (void) { CK_FUNCTION_LIST_PTR module; CK_SESSION_HANDLE session = 0; CK_BYTE data[10]; CK_RV rv; - module = setup_mock_module (tc, &session); + module = setup_mock_module (&session); rv = (module->C_SeedRandom) (0, (CK_BYTE_PTR)"seed", 4); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); rv = (module->C_SeedRandom) (session, (CK_BYTE_PTR)"seed", 4); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); rv = (module->C_GenerateRandom) (0, data, sizeof (data)); - CuAssertTrue (tc, rv == CKR_SESSION_HANDLE_INVALID); + assert (rv == CKR_SESSION_HANDLE_INVALID); rv = (module->C_GenerateRandom) (session, data, sizeof (data)); - CuAssertTrue (tc, rv == CKR_OK); + assert (rv == CKR_OK); - CuAssertTrue (tc, memcmp (data, "seedseedse", sizeof (data)) == 0); + assert (memcmp (data, "seedseedse", sizeof (data)) == 0); - teardown_mock_module (tc, module); + teardown_mock_module (module); } static void -test_mock_add_tests (CuSuite *suite) +test_mock_add_tests (const char *prefix) { - SUITE_ADD_TEST (suite, test_get_info); - SUITE_ADD_TEST (suite, test_get_slot_list); - SUITE_ADD_TEST (suite, test_get_slot_info); - SUITE_ADD_TEST (suite, test_get_token_info); - SUITE_ADD_TEST (suite, test_get_mechanism_list); - SUITE_ADD_TEST (suite, test_get_mechanism_info); - SUITE_ADD_TEST (suite, test_init_token); - SUITE_ADD_TEST (suite, test_wait_for_slot_event); - SUITE_ADD_TEST (suite, test_open_close_session); - SUITE_ADD_TEST (suite, test_close_all_sessions); - SUITE_ADD_TEST (suite, test_get_function_status); - SUITE_ADD_TEST (suite, test_cancel_function); - SUITE_ADD_TEST (suite, test_get_session_info); - SUITE_ADD_TEST (suite, test_init_pin); - SUITE_ADD_TEST (suite, test_set_pin); - SUITE_ADD_TEST (suite, test_operation_state); - SUITE_ADD_TEST (suite, test_login_logout); - SUITE_ADD_TEST (suite, test_get_attribute_value); - SUITE_ADD_TEST (suite, test_set_attribute_value); - SUITE_ADD_TEST (suite, test_create_object); - SUITE_ADD_TEST (suite, test_copy_object); - SUITE_ADD_TEST (suite, test_destroy_object); - SUITE_ADD_TEST (suite, test_get_object_size); - SUITE_ADD_TEST (suite, test_find_objects); - SUITE_ADD_TEST (suite, test_encrypt); - SUITE_ADD_TEST (suite, test_decrypt); - SUITE_ADD_TEST (suite, test_digest); - SUITE_ADD_TEST (suite, test_sign); - SUITE_ADD_TEST (suite, test_sign_recover); - SUITE_ADD_TEST (suite, test_verify); - SUITE_ADD_TEST (suite, test_verify_recover); - SUITE_ADD_TEST (suite, test_digest_encrypt); - SUITE_ADD_TEST (suite, test_decrypt_digest); - SUITE_ADD_TEST (suite, test_sign_encrypt); - SUITE_ADD_TEST (suite, test_decrypt_verify); - SUITE_ADD_TEST (suite, test_generate_key); - SUITE_ADD_TEST (suite, test_generate_key_pair); - SUITE_ADD_TEST (suite, test_wrap_key); - SUITE_ADD_TEST (suite, test_unwrap_key); - SUITE_ADD_TEST (suite, test_derive_key); - SUITE_ADD_TEST (suite, test_random); + p11_test (test_get_info, "%s/test_get_info", prefix); + p11_test (test_get_slot_list, "%s/test_get_slot_list", prefix); + p11_test (test_get_slot_info, "%s/test_get_slot_info", prefix); + p11_test (test_get_token_info, "%s/test_get_token_info", prefix); + p11_test (test_get_mechanism_list, "%s/test_get_mechanism_list", prefix); + p11_test (test_get_mechanism_info, "%s/test_get_mechanism_info", prefix); + p11_test (test_init_token, "%s/test_init_token", prefix); + p11_test (test_wait_for_slot_event, "%s/test_wait_for_slot_event", prefix); + p11_test (test_open_close_session, "%s/test_open_close_session", prefix); + p11_test (test_close_all_sessions, "%s/test_close_all_sessions", prefix); + p11_test (test_get_function_status, "%s/test_get_function_status", prefix); + p11_test (test_cancel_function, "%s/test_cancel_function", prefix); + p11_test (test_get_session_info, "%s/test_get_session_info", prefix); + p11_test (test_init_pin, "%s/test_init_pin", prefix); + p11_test (test_set_pin, "%s/test_set_pin", prefix); + p11_test (test_operation_state, "%s/test_operation_state", prefix); + p11_test (test_login_logout, "%s/test_login_logout", prefix); + p11_test (test_get_attribute_value, "%s/test_get_attribute_value", prefix); + p11_test (test_set_attribute_value, "%s/test_set_attribute_value", prefix); + p11_test (test_create_object, "%s/test_create_object", prefix); + p11_test (test_copy_object, "%s/test_copy_object", prefix); + p11_test (test_destroy_object, "%s/test_destroy_object", prefix); + p11_test (test_get_object_size, "%s/test_get_object_size", prefix); + p11_test (test_find_objects, "%s/test_find_objects", prefix); + p11_test (test_encrypt, "%s/test_encrypt", prefix); + p11_test (test_decrypt, "%s/test_decrypt", prefix); + p11_test (test_digest, "%s/test_digest", prefix); + p11_test (test_sign, "%s/test_sign", prefix); + p11_test (test_sign_recover, "%s/test_sign_recover", prefix); + p11_test (test_verify, "%s/test_verify", prefix); + p11_test (test_verify_recover, "%s/test_verify_recover", prefix); + p11_test (test_digest_encrypt, "%s/test_digest_encrypt", prefix); + p11_test (test_decrypt_digest, "%s/test_decrypt_digest", prefix); + p11_test (test_sign_encrypt, "%s/test_sign_encrypt", prefix); + p11_test (test_decrypt_verify, "%s/test_decrypt_verify", prefix); + p11_test (test_generate_key, "%s/test_generate_key", prefix); + p11_test (test_generate_key_pair, "%s/test_generate_key_pair", prefix); + p11_test (test_wrap_key, "%s/test_wrap_key", prefix); + p11_test (test_unwrap_key, "%s/test_unwrap_key", prefix); + p11_test (test_derive_key, "%s/test_derive_key", prefix); + p11_test (test_random, "%s/test_random", prefix); } |