diff options
Diffstat (limited to 'security/nss/cmd/libpkix/pkix/util')
| -rw-r--r-- | security/nss/cmd/libpkix/pkix/util/Makefile | 45 | ||||
| -rw-r--r-- | security/nss/cmd/libpkix/pkix/util/manifest.mn | 24 | ||||
| -rw-r--r-- | security/nss/cmd/libpkix/pkix/util/test_error.c | 385 | ||||
| -rw-r--r-- | security/nss/cmd/libpkix/pkix/util/test_list.c | 765 | ||||
| -rw-r--r-- | security/nss/cmd/libpkix/pkix/util/test_list2.c | 118 | ||||
| -rw-r--r-- | security/nss/cmd/libpkix/pkix/util/test_logger.c | 314 |
6 files changed, 1651 insertions, 0 deletions
diff --git a/security/nss/cmd/libpkix/pkix/util/Makefile b/security/nss/cmd/libpkix/pkix/util/Makefile new file mode 100644 index 0000000000..802e7729d9 --- /dev/null +++ b/security/nss/cmd/libpkix/pkix/util/Makefile @@ -0,0 +1,45 @@ +#! gmake +# +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +####################################################################### +# (1) Include initial platform-independent assignments (MANDATORY). # +####################################################################### + +include manifest.mn + +####################################################################### +# (2) Include "global" configuration information. (OPTIONAL) # +####################################################################### + +include $(CORE_DEPTH)/coreconf/config.mk + +####################################################################### +# (3) Include "component" configuration information. (OPTIONAL) # +####################################################################### + +####################################################################### +# (4) Include "local" platform-dependent assignments (OPTIONAL). # +####################################################################### + +include $(PLAT_DEPTH)/platlibs.mk + +####################################################################### +# (5) Execute "global" rules. (OPTIONAL) # +####################################################################### + +include $(CORE_DEPTH)/coreconf/rules.mk + +####################################################################### +# (6) Execute "component" rules. (OPTIONAL) # +####################################################################### + + + +####################################################################### +# (7) Execute "local" rules. (OPTIONAL). # +####################################################################### + +include $(PLAT_DEPTH)/platrules.mk diff --git a/security/nss/cmd/libpkix/pkix/util/manifest.mn b/security/nss/cmd/libpkix/pkix/util/manifest.mn new file mode 100644 index 0000000000..c7790c401b --- /dev/null +++ b/security/nss/cmd/libpkix/pkix/util/manifest.mn @@ -0,0 +1,24 @@ +# +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +PKIX_DEPTH = ../.. +PLAT_DEPTH = $(PKIX_DEPTH)/.. +CORE_DEPTH = $(PKIX_DEPTH)/../../.. + +# MODULE public and private header directories are implicitly REQUIRED. +MODULE = nss + +CSRCS = test_error.c \ + test_list.c \ + test_list2.c \ + test_logger.c \ + $(NULL) + +LIBRARY_NAME = pkixtoolutil +SHARED_LIBRARY = $(NULL) + +SOURCE_LIB_DIR=$(PKIX_DEPTH)/$(OBJDIR) + +NO_MD_RELEASE = 1 diff --git a/security/nss/cmd/libpkix/pkix/util/test_error.c b/security/nss/cmd/libpkix/pkix/util/test_error.c new file mode 100644 index 0000000000..9cddecc827 --- /dev/null +++ b/security/nss/cmd/libpkix/pkix/util/test_error.c @@ -0,0 +1,385 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ +/* + * test_error.c + * + * Tests Error Object Creation, ToString, Callbacks and Destroy + * + */ + +#include "testutil.h" +#include "testutil_nss.h" + +static void *plContext = NULL; + +static void +createErrors( + PKIX_Error **error, + PKIX_Error **error2, + PKIX_Error **error3, + PKIX_Error **error5, + PKIX_Error **error6, + PKIX_Error **error7, + char *infoChar) + +{ + PKIX_PL_String *infoString = NULL; + + PKIX_TEST_STD_VARS(); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_Create( + PKIX_ESCASCII, + infoChar, + PL_strlen(infoChar), + &infoString, + plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_Error_Create(PKIX_MEM_ERROR, + NULL, + NULL, + PKIX_TESTANOTHERERRORMESSAGE, + error2, + plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_Error_Create(PKIX_OBJECT_ERROR, + *error2, + (PKIX_PL_Object *)infoString, + PKIX_TESTERRORMESSAGE, + error, + plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_Error_Create(PKIX_OBJECT_ERROR, + *error2, + (PKIX_PL_Object *)infoString, + PKIX_TESTERRORMESSAGE, + error3, + plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_Error_Create(PKIX_OBJECT_ERROR, + NULL, + (PKIX_PL_Object *)infoString, + 0, + error5, + plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_Error_Create(PKIX_MEM_ERROR, + *error5, + (PKIX_PL_Object *)infoString, + 0, + error6, + plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_Error_Create(PKIX_OBJECT_ERROR, + *error6, + (PKIX_PL_Object *)infoString, + 0, + error7, + plContext)); + +cleanup: + + PKIX_TEST_DECREF_AC(infoString); + + PKIX_TEST_RETURN(); +} + +static void +testGetErrorClass(PKIX_Error *error, PKIX_Error *error2) +{ + PKIX_ERRORCLASS errClass; + + PKIX_TEST_STD_VARS(); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_Error_GetErrorClass(error, &errClass, plContext)); + + if (errClass != PKIX_OBJECT_ERROR) { + testError("Incorrect Class Returned"); + } + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_Error_GetErrorClass(error2, &errClass, plContext)); + + if (errClass != PKIX_MEM_ERROR) { + testError("Incorrect Class Returned"); + } + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_Error_GetErrorClass(PKIX_ALLOC_ERROR(), + &errClass, plContext)); + if (errClass != PKIX_FATAL_ERROR) { + testError("Incorrect Class Returned"); + } + +cleanup: + PKIX_TEST_RETURN(); +} + +static void +testGetDescription( + PKIX_Error *error, + PKIX_Error *error2, + PKIX_Error *error3, + char *descChar, + char *descChar2) +{ + + PKIX_PL_String *targetString = NULL; + char *temp = NULL; + + PKIX_TEST_STD_VARS(); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_Error_GetDescription(error, &targetString, plContext)); + temp = PKIX_String2ASCII(targetString, plContext); + PKIX_TEST_DECREF_BC(targetString); + + if (temp) { + if (PL_strcmp(temp, descChar) != 0) { + testError("Incorrect description returned"); + } + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); + } + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_Error_GetDescription(error2, &targetString, plContext)); + temp = PKIX_String2ASCII(targetString, plContext); + PKIX_TEST_DECREF_BC(targetString); + + if (temp) { + if (PL_strcmp(temp, descChar2) != 0) { + testError("Incorrect description returned"); + } + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); + } + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_Error_GetDescription(error3, &targetString, plContext)); + temp = PKIX_String2ASCII(targetString, plContext); + PKIX_TEST_DECREF_BC(targetString); + + if (temp) { + if (PL_strcmp(temp, descChar) != 0) { + testError("Incorrect description returned"); + } + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); + } + +cleanup: + + PKIX_TEST_RETURN(); +} + +static void +testGetCause(PKIX_Error *error, PKIX_Error *error2, PKIX_Error *error3) +{ + + PKIX_Error *error4 = NULL; + PKIX_PL_String *targetString = NULL; + char *temp = NULL; + PKIX_Boolean boolResult; + + PKIX_TEST_STD_VARS(); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_Error_GetCause(error, &error4, plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_Equals((PKIX_PL_Object *)error2, + (PKIX_PL_Object *)error4, + &boolResult, plContext)); + if (!boolResult) + testError("Incorrect Cause returned"); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_ToString((PKIX_PL_Object *)error4, + &targetString, plContext)); + + temp = PKIX_String2ASCII(targetString, plContext); + if (temp) { + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); + } + + PKIX_TEST_DECREF_BC(targetString); + PKIX_TEST_DECREF_BC(error4); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_Error_GetCause(error3, &error4, plContext)); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_Equals((PKIX_PL_Object *)error2, + (PKIX_PL_Object *)error4, + &boolResult, plContext)); + if (!boolResult) + testError("Incorrect Cause returned"); + + PKIX_TEST_DECREF_BC(error4); + +cleanup: + + PKIX_TEST_RETURN(); +} + +static void +testGetSupplementaryInfo(PKIX_Error *error, char *infoChar) +{ + + PKIX_PL_Object *targetString = NULL; + char *temp = NULL; + + PKIX_TEST_STD_VARS(); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_Error_GetSupplementaryInfo(error, &targetString, plContext)); + temp = PKIX_String2ASCII((PKIX_PL_String *)targetString, plContext); + PKIX_TEST_DECREF_BC(targetString); + + if (temp) { + if (PL_strcmp(temp, infoChar) != 0) { + testError("Incorrect info returned"); + } + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); + } + +cleanup: + + PKIX_TEST_RETURN(); +} + +static void +testPrimitiveError(void) +{ + PKIX_PL_String *targetString = NULL; + PKIX_PL_String *targetStringCopy = NULL; + char *temp = NULL; + + PKIX_TEST_STD_VARS(); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_ToString((PKIX_PL_Object *)PKIX_ALLOC_ERROR(), + &targetString, plContext)); + + temp = PKIX_String2ASCII(targetString, plContext); + if (temp) { + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); + } + + targetStringCopy = targetString; + + PKIX_TEST_DECREF_BC(targetString); + + /* + * We need to DECREF twice, b/c the PKIX_ALLOC_ERROR object + * which holds a cached copy of the stringRep can never be DECREF'd + */ + PKIX_TEST_DECREF_BC(targetStringCopy); + +cleanup: + + PKIX_TEST_RETURN(); +} + +static void +testChaining(PKIX_Error *error7) +{ + PKIX_PL_String *targetString = NULL; + PKIX_Error *tempError = NULL; + char *temp = NULL; + PKIX_UInt32 i; + + PKIX_TEST_STD_VARS(); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_ToString((PKIX_PL_Object *)error7, + &targetString, plContext)); + + temp = PKIX_String2ASCII(targetString, plContext); + if (temp) { + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); + } + + for (i = 0, tempError = error7; i < 2; i++) { + PKIX_TEST_EXPECT_NO_ERROR(PKIX_Error_GetCause(tempError, &tempError, plContext)); + if (tempError == NULL) { + testError("Unexpected end to error chain"); + break; + } + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_DecRef((PKIX_PL_Object *)tempError, plContext)); + } + + PKIX_TEST_DECREF_BC(targetString); + +cleanup: + + PKIX_TEST_RETURN(); +} + +static void +testDestroy(PKIX_Error *error) +{ + PKIX_TEST_STD_VARS(); + + PKIX_TEST_DECREF_BC(error); + +cleanup: + + PKIX_TEST_RETURN(); +} + +int +test_error(int argc, char *argv[]) +{ + + PKIX_Error *error, *error2, *error3, *error5, *error6, *error7; + char *descChar = "Error Message"; + char *descChar2 = "Another Error Message"; + char *infoChar = "Auxiliary Info"; + PKIX_UInt32 actualMinorVersion; + PKIX_UInt32 j = 0; + + PKIX_TEST_STD_VARS(); + + startTests("Errors"); + + PKIX_TEST_EXPECT_NO_ERROR( + PKIX_PL_NssContext_Create(0, PKIX_FALSE, NULL, &plContext)); + + subTest("PKIX_Error_Create"); + createErrors(&error, + &error2, + &error3, + &error5, + &error6, + &error7, + infoChar); + + PKIX_TEST_EQ_HASH_TOSTR_DUP(error, + error, + error2, + NULL, + Error, + PKIX_TRUE); + + subTest("PKIX_Error_GetErrorClass"); + testGetErrorClass(error, error2); + + subTest("PKIX_Error_GetDescription"); + testGetDescription(error, error2, error3, descChar, descChar2); + + subTest("PKIX_Error_GetCause"); + testGetCause(error, error2, error3); + + subTest("PKIX_Error_GetSupplementaryInfo"); + testGetSupplementaryInfo(error, infoChar); + + subTest("Primitive Error Type"); + testPrimitiveError(); + + subTest("Error Chaining"); + testChaining(error7); + + subTest("PKIX_Error_Destroy"); + testDestroy(error); + testDestroy(error2); + testDestroy(error3); + testDestroy(error5); + testDestroy(error6); + testDestroy(error7); + +cleanup: + + PKIX_Shutdown(plContext); + + PKIX_TEST_RETURN(); + + endTests("Errors"); + + return (0); +} diff --git a/security/nss/cmd/libpkix/pkix/util/test_list.c b/security/nss/cmd/libpkix/pkix/util/test_list.c new file mode 100644 index 0000000000..e5e6e507ba --- /dev/null +++ b/security/nss/cmd/libpkix/pkix/util/test_list.c @@ -0,0 +1,765 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ +/* + * test_list.c + * + * Tests List Objects + * + */ + +#include "testutil.h" +#include "testutil_nss.h" + +static void *plContext = NULL; + +static void +createLists(PKIX_List **list, PKIX_List **list2) +{ + PKIX_TEST_STD_VARS(); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_Create(list, plContext)); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_Create(list2, plContext)); + +cleanup: + + PKIX_TEST_RETURN(); +} + +static void +testReverseList(void) +{ + PKIX_List *firstList = NULL; + PKIX_List *reverseList = NULL; + PKIX_UInt32 length, i; + char *testItemString = "one"; + char *testItemString2 = "two"; + PKIX_PL_String *testItem = NULL; + PKIX_PL_String *testItem2 = NULL; + PKIX_PL_Object *retrievedItem1 = NULL; + PKIX_PL_Object *retrievedItem2 = NULL; + + PKIX_TEST_STD_VARS(); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_Create(&firstList, plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_ReverseList(firstList, &reverseList, plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetLength(reverseList, &length, plContext)); + if (length != 0) { + testError("Incorrect Length returned"); + } + + PKIX_TEST_DECREF_BC(reverseList); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_Create(PKIX_ESCASCII, + testItemString, + 0, + &testItem, + plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_Create(PKIX_ESCASCII, + testItemString2, + 0, + &testItem2, + plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(firstList, + (PKIX_PL_Object *)testItem, + plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_ReverseList(firstList, &reverseList, plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetLength(reverseList, &length, plContext)); + if (length != 1) { + testError("Incorrect Length returned"); + } + + PKIX_TEST_DECREF_BC(reverseList); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(firstList, + (PKIX_PL_Object *)testItem2, + plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(firstList, + (PKIX_PL_Object *)testItem, + plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(firstList, + (PKIX_PL_Object *)testItem2, + plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_ReverseList(firstList, &reverseList, plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetLength(reverseList, &length, plContext)); + if (length != 4) { + testError("Incorrect Length returned"); + } + + for (i = 0; i < length; i++) { + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetItem(firstList, + i, + &retrievedItem1, + plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetItem(reverseList, + (length - 1) - i, + &retrievedItem2, + plContext)); + + testEqualsHelper(retrievedItem1, retrievedItem2, PKIX_TRUE, plContext); + + PKIX_TEST_DECREF_BC(retrievedItem1); + PKIX_TEST_DECREF_BC(retrievedItem2); + } + +cleanup: + + PKIX_TEST_DECREF_AC(firstList); + PKIX_TEST_DECREF_AC(reverseList); + + PKIX_TEST_DECREF_AC(testItem); + PKIX_TEST_DECREF_AC(testItem2); + + PKIX_TEST_DECREF_AC(retrievedItem1); + PKIX_TEST_DECREF_AC(retrievedItem2); + + PKIX_TEST_RETURN(); +} + +static void +testZeroLengthList(PKIX_List *list) +{ + PKIX_UInt32 length; + PKIX_Boolean empty; + char *testItemString = "hello"; + PKIX_PL_String *testItem = NULL; + PKIX_PL_String *retrievedItem = NULL; + PKIX_List *diffList = NULL; + + PKIX_TEST_STD_VARS(); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_Create(&diffList, plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetLength(list, &length, plContext)); + + if (length != 0) { + testError("Incorrect Length returned"); + } + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_IsEmpty(list, &empty, plContext)); + if (!empty) { + testError("Incorrect result for PKIX_List_IsEmpty"); + } + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_Create(PKIX_ESCASCII, + testItemString, + 0, + &testItem, + plContext)); + + PKIX_TEST_EXPECT_ERROR(PKIX_List_InsertItem(list, 0, (PKIX_PL_Object *)testItem, plContext)); + + PKIX_TEST_EXPECT_ERROR(PKIX_List_SetItem(list, 0, (PKIX_PL_Object *)testItem, plContext)); + + PKIX_TEST_EXPECT_ERROR(PKIX_List_GetItem(list, + 0, + (PKIX_PL_Object **)&retrievedItem, + plContext)); + + PKIX_TEST_EXPECT_ERROR(PKIX_List_DeleteItem(list, 0, plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(diffList, + (PKIX_PL_Object *)testItem, + plContext)); + + testDuplicateHelper((PKIX_PL_Object *)diffList, plContext); + + PKIX_TEST_EQ_HASH_TOSTR_DUP(list, list, diffList, "(EMPTY)", List, PKIX_TRUE); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetLength(diffList, &length, plContext)); + if (length != 1) { + testError("Incorrect Length returned"); + } + + PKIX_TEST_EXPECT_ERROR(PKIX_List_DeleteItem(list, 1, plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_DeleteItem(diffList, 0, plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetLength(diffList, &length, plContext)); + if (length != 0) { + testError("Incorrect Length returned"); + } + +cleanup: + + PKIX_TEST_DECREF_AC(testItem); + PKIX_TEST_DECREF_AC(diffList); + PKIX_TEST_RETURN(); +} + +static void +testGetLength(PKIX_List *list) +{ + PKIX_UInt32 length; + PKIX_TEST_STD_VARS(); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetLength(list, &length, plContext)); + + if (length != 3) { + testError("Incorrect Length returned"); + } + +cleanup: + + PKIX_TEST_RETURN(); +} + +static void +testGetSetItem( + PKIX_List *list, + char *testItemString, + char *testItemString2, + char *testItemString3, + PKIX_PL_String **testItem, + PKIX_PL_String **testItem2, + PKIX_PL_String **testItem3) +{ + PKIX_PL_Object *tempItem = NULL; + char *temp = NULL; + + PKIX_TEST_STD_VARS(); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_Create(PKIX_ESCASCII, + testItemString, + PL_strlen(testItemString), + testItem, + plContext)); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_Create(PKIX_ESCASCII, + testItemString2, + PL_strlen(testItemString2), + testItem2, + plContext)); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_Create(PKIX_ESCASCII, + testItemString3, + PL_strlen(testItemString3), + testItem3, + plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(list, (PKIX_PL_Object *)*testItem, plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(list, (PKIX_PL_Object *)*testItem, plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(list, (PKIX_PL_Object *)*testItem, plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_SetItem(list, 0, (PKIX_PL_Object *)*testItem, plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_SetItem(list, 1, (PKIX_PL_Object *)*testItem2, plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_SetItem(list, 2, (PKIX_PL_Object *)*testItem3, plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetItem(list, 0, &tempItem, plContext)); + + temp = PKIX_String2ASCII((PKIX_PL_String *)tempItem, plContext); + if (temp) { + if (PL_strcmp(testItemString, temp) != 0) + testError("GetItem from list is incorrect"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); + } + + PKIX_TEST_DECREF_BC(tempItem); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetItem(list, 1, &tempItem, plContext)); + + temp = PKIX_String2ASCII((PKIX_PL_String *)tempItem, plContext); + if (temp) { + if (PL_strcmp(testItemString2, temp) != 0) + testError("GetItem from list is incorrect"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); + } + PKIX_TEST_DECREF_BC(tempItem); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetItem(list, 2, &tempItem, plContext)); + + temp = PKIX_String2ASCII((PKIX_PL_String *)tempItem, plContext); + if (temp) { + if (PL_strcmp(testItemString3, temp) != 0) + testError("GetItem from list is incorrect"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); + } + PKIX_TEST_DECREF_BC(tempItem); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_SetItem(list, 0, (PKIX_PL_Object *)*testItem3, plContext)); + temp = PKIX_String2ASCII(*testItem3, plContext); + if (temp) { + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); + } + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetItem(list, 0, &tempItem, plContext)); + + temp = PKIX_String2ASCII((PKIX_PL_String *)tempItem, plContext); + if (temp) { + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); + } + + temp = PKIX_String2ASCII((PKIX_PL_String *)tempItem, plContext); + if (temp) { + if (PL_strcmp(testItemString3, temp) != 0) + testError("GetItem from list is incorrect"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); + } + PKIX_TEST_DECREF_BC(tempItem); + +cleanup: + + PKIX_TEST_RETURN(); +} + +static void +testInsertItem( + PKIX_List *list, + PKIX_PL_String *testItem, + char *testItemString) +{ + PKIX_PL_Object *tempItem = NULL; + PKIX_PL_String *outputString = NULL; + char *temp = NULL; + + PKIX_TEST_STD_VARS(); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_InsertItem(list, 0, (PKIX_PL_Object *)testItem, plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetItem(list, 0, &tempItem, plContext)); + + temp = PKIX_String2ASCII((PKIX_PL_String *)tempItem, plContext); + if (temp) { + if (PL_strcmp(testItemString, temp) != 0) + testError("GetItem from list is incorrect"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); + } + PKIX_TEST_DECREF_BC(tempItem); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_ToString((PKIX_PL_Object *)list, + &outputString, + plContext)); + + temp = PKIX_String2ASCII(outputString, plContext); + if (temp) { + if (PL_strcmp("(a, c, b, c)", temp) != 0) + testError("List toString is Incorrect"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); + } + + PKIX_TEST_DECREF_BC(outputString); + +cleanup: + + PKIX_TEST_RETURN(); +} + +static void +testAppendItem(PKIX_List *list, PKIX_PL_String *testItem) +{ + PKIX_UInt32 length2; + PKIX_PL_String *outputString = NULL; + char *temp = NULL; + + PKIX_TEST_STD_VARS(); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetLength(list, &length2, plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(list, + (PKIX_PL_Object *)testItem, + plContext)); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_ToString((PKIX_PL_Object *)list, + &outputString, + plContext)); + + temp = PKIX_String2ASCII(outputString, plContext); + if (temp) { + if (PL_strcmp("(a, c, b, c, a)", temp) != 0) + testError("List toString is Incorrect"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); + } + + PKIX_TEST_DECREF_BC(outputString); + +cleanup: + + PKIX_TEST_RETURN(); +} + +static void +testNestedLists( + PKIX_List *list, + PKIX_List *list2, + PKIX_PL_String *testItem, + PKIX_PL_String *testItem2) +{ + PKIX_PL_String *outputString = NULL; + char *temp = NULL; + + PKIX_TEST_STD_VARS(); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(list2, (PKIX_PL_Object *)testItem, plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(list2, + (PKIX_PL_Object *)NULL, + plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(list2, + (PKIX_PL_Object *)testItem, + plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_ToString((PKIX_PL_Object *)list2, + &outputString, + plContext)); + + temp = PKIX_String2ASCII(outputString, plContext); + if (temp) { + if (PL_strcmp("(a, (null), a)", temp) != 0) + testError("List toString is Incorrect"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); + } + PKIX_TEST_DECREF_BC(outputString); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_InsertItem(list, 1, + (PKIX_PL_Object *)list2, + plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_ToString((PKIX_PL_Object *)list, + &outputString, + plContext)); + + temp = PKIX_String2ASCII(outputString, plContext); + if (temp) { + if (PL_strcmp("(a, (a, (null), a), c, b, c, a)", temp) != 0) + testError("List toString is Incorrect"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); + } + PKIX_TEST_DECREF_BC(outputString); + +cleanup: + + PKIX_TEST_RETURN(); +} + +static void +testDeleteItem( + PKIX_List *list, + PKIX_List *list2, + PKIX_PL_String *testItem2, + PKIX_PL_String *testItem3) +{ + PKIX_PL_String *outputString = NULL; + char *temp = NULL; + + PKIX_TEST_STD_VARS(); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_DeleteItem(list, 5, plContext)); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_ToString((PKIX_PL_Object *)list, + &outputString, + plContext)); + + temp = PKIX_String2ASCII(outputString, plContext); + if (temp) { + if (PL_strcmp("(a, (a, (null), a), c, b, c)", temp) != 0) + testError("List toString is Incorrect"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); + } + PKIX_TEST_DECREF_BC(outputString); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_DeleteItem(list, 1, plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_ToString((PKIX_PL_Object *)list, + &outputString, + plContext)); + + temp = PKIX_String2ASCII(outputString, plContext); + if (temp) { + if (PL_strcmp("(a, c, b, c)", temp) != 0) + testError("List toString is Incorrect"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); + } + PKIX_TEST_DECREF_BC(outputString); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_DeleteItem(list, 0, plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_ToString((PKIX_PL_Object *)list, + &outputString, + plContext)); + + temp = PKIX_String2ASCII(outputString, plContext); + if (temp) { + if (PL_strcmp("(c, b, c)", temp) != 0) + testError("List toString is Incorrect"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); + } + PKIX_TEST_DECREF_BC(outputString); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_DeleteItem(list2, 1, plContext)); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_ToString((PKIX_PL_Object *)list2, + &outputString, + plContext)); + temp = PKIX_String2ASCII(outputString, plContext); + if (temp) { + if (PL_strcmp("(a, a)", temp) != 0) + testError("List toString is Incorrect"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); + } + PKIX_TEST_DECREF_BC(outputString); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(list2, + (PKIX_PL_Object *)testItem2, + plContext)); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_ToString((PKIX_PL_Object *)list2, + &outputString, + plContext)); + + temp = PKIX_String2ASCII(outputString, plContext); + if (temp) { + if (PL_strcmp("(a, a, b)", temp) != 0) + testError("List toString is Incorrect"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); + } + PKIX_TEST_DECREF_BC(outputString); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_DeleteItem(list2, 2, plContext)); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_ToString((PKIX_PL_Object *)list2, + &outputString, + plContext)); + + temp = PKIX_String2ASCII(outputString, plContext); + if (temp) { + if (PL_strcmp("(a, a)", temp) != 0) + testError("List toString is Incorrect"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); + } + PKIX_TEST_DECREF_BC(outputString); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(list2, + (PKIX_PL_Object *)testItem3, + plContext)); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_ToString((PKIX_PL_Object *)list2, + &outputString, + plContext)); + temp = PKIX_String2ASCII(outputString, plContext); + if (temp) { + if (PL_strcmp("(a, a, c)", temp) != 0) + testError("List toString is Incorrect"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); + } + PKIX_TEST_DECREF_BC(outputString); + + PKIX_TEST_DECREF_BC(list2); + +cleanup: + + PKIX_TEST_RETURN(); +} + +#if testContainsFunction +/* This test requires pkix_List_Contains to be in nss.def */ +static void +testContains(void) +{ + + PKIX_List *list; + PKIX_PL_String *testItem, *testItem2, *testItem3, *testItem4; + char *testItemString = "a"; + char *testItemString2 = "b"; + char *testItemString3 = "c"; + char *testItemString4 = "d"; + PKIX_Boolean found = PKIX_FALSE; + + PKIX_TEST_STD_VARS(); + subTest("pkix_ListContains"); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_Create(PKIX_ESCASCII, + testItemString, + PL_strlen(testItemString), + &testItem, + plContext)); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_Create(PKIX_ESCASCII, + testItemString2, + PL_strlen(testItemString2), + &testItem2, + plContext)); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_Create(PKIX_ESCASCII, + testItemString3, + PL_strlen(testItemString3), + &testItem3, + plContext)); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_Create(PKIX_ESCASCII, + testItemString4, + PL_strlen(testItemString4), + &testItem4, + plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_Create(&list, plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(list, (PKIX_PL_Object *)testItem, plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(list, (PKIX_PL_Object *)testItem2, plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(list, (PKIX_PL_Object *)testItem3, plContext)); + + subTest("pkix_List_Contains <object missing>"); + + PKIX_TEST_EXPECT_NO_ERROR(pkix_List_Contains(list, (PKIX_PL_Object *)testItem4, &found, plContext)); + + if (found) { + testError("Contains found item that wasn't there!"); + } + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(list, (PKIX_PL_Object *)testItem4, plContext)); + + subTest("pkix_List_Contains <object present>"); + + PKIX_TEST_EXPECT_NO_ERROR(pkix_List_Contains(list, (PKIX_PL_Object *)testItem4, &found, plContext)); + + if (!found) { + testError("Contains missed item that was present!"); + } + + PKIX_TEST_DECREF_BC(list); + PKIX_TEST_DECREF_BC(testItem); + PKIX_TEST_DECREF_BC(testItem2); + PKIX_TEST_DECREF_BC(testItem3); + PKIX_TEST_DECREF_BC(testItem4); + +cleanup: + + PKIX_TEST_RETURN(); +} +#endif + +static void +testErrorHandling(void) +{ + PKIX_List *emptylist = NULL; + PKIX_List *list = NULL; + PKIX_PL_Object *tempItem = NULL; + + PKIX_TEST_STD_VARS(); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_Create(&list, plContext)); + + PKIX_TEST_EXPECT_ERROR(PKIX_List_GetItem(list, 4, &tempItem, plContext)); + + PKIX_TEST_EXPECT_ERROR(PKIX_List_GetItem(list, 1, NULL, plContext)); + PKIX_TEST_EXPECT_ERROR(PKIX_List_SetItem(list, 4, tempItem, plContext)); + PKIX_TEST_EXPECT_ERROR(PKIX_List_SetItem(NULL, 1, tempItem, plContext)); + PKIX_TEST_EXPECT_ERROR(PKIX_List_InsertItem(list, 4, tempItem, plContext)); + + PKIX_TEST_EXPECT_ERROR(PKIX_List_InsertItem(NULL, 1, tempItem, plContext)); + + PKIX_TEST_EXPECT_ERROR(PKIX_List_AppendItem(NULL, tempItem, plContext)); + PKIX_TEST_EXPECT_ERROR(PKIX_List_DeleteItem(list, 5, plContext)); + PKIX_TEST_EXPECT_ERROR(PKIX_List_DeleteItem(NULL, 1, plContext)); + PKIX_TEST_EXPECT_ERROR(PKIX_List_GetLength(list, NULL, plContext)); + + PKIX_TEST_DECREF_BC(list); + PKIX_TEST_DECREF_BC(emptylist); + +cleanup: + + PKIX_TEST_RETURN(); +} + +static void +testDestroy(PKIX_List *list) +{ + PKIX_TEST_STD_VARS(); + + PKIX_TEST_DECREF_BC(list); + +cleanup: + + PKIX_TEST_RETURN(); +} + +int +test_list(int argc, char *argv[]) +{ + + PKIX_List *list, *list2; + PKIX_PL_String *testItem, *testItem2, *testItem3; + char *testItemString = "a"; + char *testItemString2 = "b"; + char *testItemString3 = "c"; + PKIX_UInt32 actualMinorVersion; + PKIX_UInt32 j = 0; + + PKIX_TEST_STD_VARS(); + + startTests("Lists"); + + PKIX_TEST_EXPECT_NO_ERROR( + PKIX_PL_NssContext_Create(0, PKIX_FALSE, NULL, &plContext)); + + subTest("PKIX_List_Create"); + createLists(&list, &list2); + + subTest("pkix_List_ReverseList"); + testReverseList(); + + subTest("Zero-length List"); + testZeroLengthList(list); + + subTest("PKIX_List_Get/SetItem"); + testGetSetItem(list, + testItemString, + testItemString2, + testItemString3, + &testItem, + &testItem2, + &testItem3); + + subTest("PKIX_List_GetLength"); + testGetLength(list); + + PKIX_TEST_EQ_HASH_TOSTR_DUP(list, + list, + list2, + "(c, b, c)", + List, + PKIX_TRUE); + + subTest("PKIX_List_InsertItem"); + testInsertItem(list, testItem, testItemString); + + subTest("PKIX_List_AppendItem"); + testAppendItem(list, testItem); + + subTest("Nested Lists"); + testNestedLists(list, list2, testItem, testItem2); + + subTest("PKIX_List_DeleteItem"); + testDeleteItem(list, list2, testItem2, testItem3); + + PKIX_TEST_DECREF_BC(testItem); + PKIX_TEST_DECREF_BC(testItem2); + PKIX_TEST_DECREF_BC(testItem3); + +#if testContainsFunction + /* This test requires pkix_List_Contains to be in nss.def */ + testContains(); +#endif + + subTest("PKIX_List Error Handling"); + testErrorHandling(); + + subTest("PKIX_List_Destroy"); + testDestroy(list); + +cleanup: + + PKIX_Shutdown(plContext); + + PKIX_TEST_RETURN(); + + endTests("Lists"); + + return (0); +} diff --git a/security/nss/cmd/libpkix/pkix/util/test_list2.c b/security/nss/cmd/libpkix/pkix/util/test_list2.c new file mode 100644 index 0000000000..b802ff0e66 --- /dev/null +++ b/security/nss/cmd/libpkix/pkix/util/test_list2.c @@ -0,0 +1,118 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ +/* + * test_list2.c + * + * Performs an in-place sort on a list + * + */ + +#include "testutil.h" +#include "testutil_nss.h" + +static void *plContext = NULL; + +int +test_list2(int argc, char *argv[]) +{ + + PKIX_List *list; + char *temp; + PKIX_UInt32 i = 0; + PKIX_UInt32 j = 0; + PKIX_Int32 cmpResult; + PKIX_PL_OID *testOID; + PKIX_PL_String *testString; + PKIX_PL_Object *obj, *obj2; + PKIX_UInt32 size = 10; + char *testOIDString[10] = { + "2.9.999.1.20", + "1.2.3.4.5.6.7", + "0.1", + "1.2.3.5", + "0.39", + "1.2.3.4.7", + "1.2.3.4.6", + "0.39.1", + "1.2.3.4.5", + "0.39.1.300" + }; + PKIX_UInt32 actualMinorVersion; + + PKIX_TEST_STD_VARS(); + + startTests("List Sorting"); + + PKIX_TEST_EXPECT_NO_ERROR( + PKIX_PL_NssContext_Create(0, PKIX_FALSE, NULL, &plContext)); + + subTest("Creating Unsorted Lists"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_Create(&list, plContext)); + for (i = 0; i < size; i++) { + /* Create a new OID object */ + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_OID_Create( + testOIDString[i], + &testOID, + plContext)); + /* Insert it into the list */ + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(list, (PKIX_PL_Object *)testOID, plContext)); + /* Decref the string object */ + PKIX_TEST_DECREF_BC(testOID); + } + + subTest("Outputting Unsorted List"); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_ToString((PKIX_PL_Object *)list, + &testString, + plContext)); + temp = PKIX_String2ASCII(testString, plContext); + if (temp) { + (void)printf("%s \n", temp); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); + } + PKIX_TEST_DECREF_BC(testString); + + subTest("Performing Bubble Sort"); + + for (i = 0; i < size; i++) + for (j = 9; j > i; j--) { + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetItem(list, j, &obj, plContext)); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetItem(list, j - 1, + &obj2, plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_Compare(obj, obj2, &cmpResult, plContext)); + if (cmpResult < 0) { + /* Exchange the items */ + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_SetItem(list, j, obj2, plContext)); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_SetItem(list, j - 1, + obj, plContext)); + } + /* DecRef objects */ + PKIX_TEST_DECREF_BC(obj); + PKIX_TEST_DECREF_BC(obj2); + } + + subTest("Outputting Sorted List"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_ToString((PKIX_PL_Object *)list, + &testString, + plContext)); + temp = PKIX_String2ASCII(testString, plContext); + if (temp) { + (void)printf("%s \n", temp); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); + } + +cleanup: + + PKIX_TEST_DECREF_AC(testString); + PKIX_TEST_DECREF_AC(list); + + PKIX_Shutdown(plContext); + + PKIX_TEST_RETURN(); + + endTests("List Sorting"); + + return (0); +} diff --git a/security/nss/cmd/libpkix/pkix/util/test_logger.c b/security/nss/cmd/libpkix/pkix/util/test_logger.c new file mode 100644 index 0000000000..3b7e5160a3 --- /dev/null +++ b/security/nss/cmd/libpkix/pkix/util/test_logger.c @@ -0,0 +1,314 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ +/* + * test_logger.c + * + * Tests Logger Objects + * + */ + +#include "testutil.h" +#include "testutil_nss.h" + +static void *plContext = NULL; + +static char *levels[] = { + "None", + "Fatal Error", + "Error", + "Warning", + "Debug", + "Trace" +}; + +static PKIX_Error * +testLoggerCallback( + PKIX_Logger *logger, + PKIX_PL_String *message, + PKIX_UInt32 logLevel, + PKIX_ERRORCLASS logComponent, + void *plContext) +{ + char *comp = NULL; + char *msg = NULL; + char result[100]; + static int callCount = 0; + + PKIX_TEST_STD_VARS(); + + msg = PKIX_String2ASCII(message, plContext); + PR_snprintf(result, 100, "Logging %s (%s): %s", + levels[logLevel], PKIX_ERRORCLASSNAMES[logComponent], msg); + subTest(result); + + callCount++; + if (callCount > 1) { + testError("Incorrect number of Logger Callback <expect 1>"); + } + +cleanup: + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(msg, plContext)); + PKIX_TEST_RETURN(); +} + +static PKIX_Error * +testLoggerCallback2( + PKIX_Logger *logger, + PKIX_PL_String *message, + PKIX_UInt32 logLevel, + PKIX_ERRORCLASS logComponent, + void *plContext) +{ + char *comp = NULL; + char *msg = NULL; + char result[100]; + + PKIX_TEST_STD_VARS(); + + msg = PKIX_String2ASCII(message, plContext); + PR_snprintf(result, 100, "Logging %s (%s): %s", + levels[logLevel], PKIX_ERRORCLASSNAMES[logComponent], msg); + subTest(result); + +cleanup: + PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(msg, plContext)); + PKIX_TEST_RETURN(); +} + +static void +createLogger(PKIX_Logger **logger, + PKIX_PL_Object *context, + PKIX_Logger_LogCallback cb) +{ + PKIX_TEST_STD_VARS(); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_Create(cb, context, logger, plContext)); + +cleanup: + + PKIX_TEST_RETURN(); +} + +static void +testContextCallback(PKIX_Logger *logger, PKIX_Logger *logger2) +{ + PKIX_Logger_LogCallback cb = NULL; + PKIX_PL_Object *context = NULL; + PKIX_Boolean cmpResult = PKIX_FALSE; + PKIX_UInt32 length; + + PKIX_TEST_STD_VARS(); + + subTest("PKIX_Logger_GetLoggerContext"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_GetLoggerContext(logger2, &context, plContext)); + + testEqualsHelper((PKIX_PL_Object *)logger, context, PKIX_TRUE, plContext); + + subTest("PKIX_Logger_GetLogCallback"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_GetLogCallback(logger, &cb, plContext)); + + if (cb != testLoggerCallback) { + testError("Incorrect Logger Callback returned"); + } + +cleanup: + + PKIX_TEST_DECREF_AC(context); + PKIX_TEST_RETURN(); +} + +static void +testComponent(PKIX_Logger *logger) +{ + PKIX_ERRORCLASS compName = (PKIX_ERRORCLASS)NULL; + PKIX_ERRORCLASS compNameReturn = (PKIX_ERRORCLASS)NULL; + PKIX_Boolean cmpResult = PKIX_FALSE; + PKIX_TEST_STD_VARS(); + + subTest("PKIX_Logger_GetLoggingComponent"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_GetLoggingComponent(logger, &compName, plContext)); + + if (compName != (PKIX_ERRORCLASS)NULL) { + testError("Incorrect Logger Component returned. expect <NULL>"); + } + + subTest("PKIX_Logger_SetLoggingComponent"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_SetLoggingComponent(logger, PKIX_LIST_ERROR, plContext)); + + subTest("PKIX_Logger_GetLoggingComponent"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_GetLoggingComponent(logger, &compNameReturn, plContext)); + + if (compNameReturn != PKIX_LIST_ERROR) { + testError("Incorrect Logger Component returned."); + } + +cleanup: + + PKIX_TEST_RETURN(); +} + +static void +testMaxLoggingLevel(PKIX_Logger *logger) +{ + PKIX_UInt32 level = 0; + PKIX_TEST_STD_VARS(); + + subTest("PKIX_Logger_GetMaxLoggingLevel"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_GetMaxLoggingLevel(logger, &level, plContext)); + + if (level != 0) { + testError("Incorrect Logger MaxLoggingLevel returned"); + } + + subTest("PKIX_Logger_SetMaxLoggingLevel"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_SetMaxLoggingLevel(logger, 3, plContext)); + + subTest("PKIX_Logger_GetMaxLoggingLevel"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_GetMaxLoggingLevel(logger, &level, plContext)); + + if (level != 3) { + testError("Incorrect Logger MaxLoggingLevel returned"); + } + +cleanup: + + PKIX_TEST_RETURN(); +} + +static void +testLogger(PKIX_Logger *logger, PKIX_Logger *logger2) +{ + PKIX_List *loggerList = NULL; + PKIX_List *checkList = NULL; + PKIX_UInt32 length; + PKIX_Boolean cmpResult = PKIX_FALSE; + char *expectedAscii = "[\n" + "\tLogger: \n" + "\tContext: (null)\n" + "\tMaximum Level: 3\n" + "\tComponent Name: LIST\n" + "]\n"; + + PKIX_TEST_STD_VARS(); + + subTest("PKIX_GetLoggers"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_GetLoggers(&loggerList, plContext)); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetLength(loggerList, &length, plContext)); + if (length != 0) { + testError("Incorrect Logger List returned"); + } + PKIX_TEST_DECREF_BC(loggerList); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_Create(&loggerList, plContext)); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(loggerList, (PKIX_PL_Object *)logger, plContext)); + + subTest("PKIX_SetLoggers"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_SetLoggers(loggerList, plContext)); + + subTest("PKIX_Logger_SetLoggingComponent"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_SetLoggingComponent(logger2, PKIX_MUTEX_ERROR, plContext)); + + subTest("PKIX_Logger_SetMaxLoggingLevel"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_SetMaxLoggingLevel(logger2, 5, plContext)); + + subTest("PKIX_AddLogger"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_AddLogger(logger2, plContext)); + + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_Create(&checkList, plContext)); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(checkList, (PKIX_PL_Object *)logger, plContext)); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(checkList, (PKIX_PL_Object *)logger2, plContext)); + + PKIX_TEST_DECREF_BC(loggerList); + + subTest("PKIX_GetLoggers"); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_GetLoggers(&loggerList, plContext)); + PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetLength(loggerList, &length, plContext)); + + subTest("pkix_Loggers_Equals"); + testEqualsHelper((PKIX_PL_Object *)loggerList, + (PKIX_PL_Object *)checkList, + PKIX_TRUE, + plContext); + + subTest("pkix_Loggers_Duplicate"); + testDuplicateHelper((PKIX_PL_Object *)logger, plContext); + + subTest("pkix_Loggers_Hashcode"); + testHashcodeHelper((PKIX_PL_Object *)logger, + (PKIX_PL_Object *)logger, + PKIX_TRUE, + plContext); + + subTest("pkix_Loggers_ToString"); + testToStringHelper((PKIX_PL_Object *)logger, expectedAscii, plContext); + + subTest("PKIX Logger Callback"); + subTest("Expect to have ***Fatal Error (List): Null argument*** once"); + PKIX_TEST_EXPECT_ERROR(PKIX_List_AppendItem(NULL, (PKIX_PL_Object *)NULL, plContext)); + +cleanup: + + PKIX_TEST_DECREF_AC(loggerList); + PKIX_TEST_DECREF_AC(checkList); + PKIX_TEST_RETURN(); +} + +static void +testDestroy(PKIX_Logger *logger) +{ + PKIX_TEST_STD_VARS(); + + PKIX_TEST_DECREF_BC(logger); + +cleanup: + + PKIX_TEST_RETURN(); +} + +int +test_logger(int argc, char *argv[]) +{ + + PKIX_Logger *logger, *logger2; + PKIX_UInt32 actualMinorVersion; + PKIX_UInt32 j = 0; + + PKIX_TEST_STD_VARS(); + + startTests("Loggers"); + + PKIX_TEST_EXPECT_NO_ERROR( + PKIX_PL_NssContext_Create(0, PKIX_FALSE, NULL, &plContext)); + + subTest("PKIX_Logger_Create"); + createLogger(&logger, NULL, testLoggerCallback); + createLogger(&logger2, (PKIX_PL_Object *)logger, testLoggerCallback2); + + subTest("Logger Context and Callback"); + testContextCallback(logger, logger2); + + subTest("Logger Component"); + testComponent(logger); + + subTest("Logger MaxLoggingLevel"); + testMaxLoggingLevel(logger); + + subTest("Logger List operations"); + testLogger(logger, logger2); + + subTest("PKIX_Logger_Destroy"); + testDestroy(logger); + testDestroy(logger2); + +cleanup: + + PKIX_Shutdown(plContext); + + PKIX_TEST_RETURN(); + + endTests("Loggers"); + + return (0); +} |