From ec688b4723a041044226358bcd4dd6e2da39da49 Mon Sep 17 00:00:00 2001 From: Luca Muscariello Date: Thu, 23 Feb 2017 17:01:02 +0100 Subject: Initial commit: cframework. Longbow and Libparc Change-Id: I90378dbd30da6033b20fb1f829b3b822cf366c59 Signed-off-by: Luca Muscariello --- libparc/parc/algol/test/test_parc_SortedList.c | 510 +++++++++++++++++++++++++ 1 file changed, 510 insertions(+) create mode 100644 libparc/parc/algol/test/test_parc_SortedList.c (limited to 'libparc/parc/algol/test/test_parc_SortedList.c') diff --git a/libparc/parc/algol/test/test_parc_SortedList.c b/libparc/parc/algol/test/test_parc_SortedList.c new file mode 100644 index 00000000..f0445d86 --- /dev/null +++ b/libparc/parc/algol/test/test_parc_SortedList.c @@ -0,0 +1,510 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + */ +#include "../parc_SortedList.c" + +#include +#include +#include +#include +#include + +#include +#include + +LONGBOW_TEST_RUNNER(parc_SortedList) +{ + // The following Test Fixtures will run their corresponding Test Cases. + // Test Fixtures are run in the order specified, but all tests should be idempotent. + // Never rely on the execution order of tests or share state between them. + LONGBOW_RUN_TEST_FIXTURE(CreateAcquireRelease); + LONGBOW_RUN_TEST_FIXTURE(Global); + LONGBOW_RUN_TEST_FIXTURE(Specialization); +} + +// The Test Runner calls this function once before any Test Fixtures are run. +LONGBOW_TEST_RUNNER_SETUP(parc_SortedList) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +// The Test Runner calls this function once after all the Test Fixtures are run. +LONGBOW_TEST_RUNNER_TEARDOWN(parc_SortedList) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_FIXTURE(CreateAcquireRelease) +{ + LONGBOW_RUN_TEST_CASE(CreateAcquireRelease, CreateRelease); + LONGBOW_RUN_TEST_CASE(CreateAcquireRelease, CreateCompare); +} + +LONGBOW_TEST_FIXTURE_SETUP(CreateAcquireRelease) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_FIXTURE_TEARDOWN(CreateAcquireRelease) +{ + if (!parcMemoryTesting_ExpectedOutstanding(0, "%s leaked memory.", longBowTestCase_GetFullName(testCase))) { + return LONGBOW_STATUS_MEMORYLEAK; + } + + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_CASE(CreateAcquireRelease, CreateRelease) +{ + PARCSortedList *instance = parcSortedList_Create(); + assertNotNull(instance, "Expected non-null result from parcSortedList_Create();"); + + parcObjectTesting_AssertAcquire(instance); + + parcSortedList_Release(&instance); + assertNull(instance, "Expected null result from parcSortedList_Release();"); +} + +// A signum function to compare two PARCBuffers by length of buffer. +static int +_compareTwoBuffersByLength(const PARCObject *buf1, const PARCObject *buf2) +{ + size_t size1 = parcBuffer_Limit((PARCBuffer *) buf1); + size_t size2 = parcBuffer_Limit((PARCBuffer *) buf2); + + if (size1 > size2) { + return 1; + } else if (size2 > size1) { + return -1; + } + return 0; +} + +LONGBOW_TEST_CASE(CreateAcquireRelease, CreateCompare) +{ + PARCSortedList *instance = parcSortedList_CreateCompare(_compareTwoBuffersByLength); + + PARCBuffer *buf1 = parcBuffer_WrapCString("medium long"); + PARCBuffer *buf2 = parcBuffer_WrapCString("somewhat longer"); + PARCBuffer *buf3 = parcBuffer_WrapCString("short"); + + parcSortedList_Add(instance, buf1); + parcSortedList_Add(instance, buf2); + parcSortedList_Add(instance, buf3); + + PARCBuffer *test = parcSortedList_GetAtIndex(instance, 0); + assertTrue(test == buf3, "Expected the shortes buffer first"); + + test = parcSortedList_GetAtIndex(instance, 1); + assertTrue(test == buf1, "Expected the medium length buffer second"); + + test = parcSortedList_GetAtIndex(instance, 2); + assertTrue(test == buf2, "Expected the longest buffer last"); + + parcBuffer_Release(&buf1); + parcBuffer_Release(&buf2); + parcBuffer_Release(&buf3); + + parcSortedList_Release(&instance); +} + +LONGBOW_TEST_FIXTURE(Global) +{ + LONGBOW_RUN_TEST_CASE(Global, parcSortedList_Copy); + LONGBOW_RUN_TEST_CASE(Global, parcSortedList_Display); + LONGBOW_RUN_TEST_CASE(Global, parcSortedList_Equals); + LONGBOW_RUN_TEST_CASE(Global, parcSortedList_HashCode); + LONGBOW_RUN_TEST_CASE(Global, parcSortedList_IsValid); + LONGBOW_RUN_TEST_CASE(Global, parcSortedList_ToJSON); + LONGBOW_RUN_TEST_CASE(Global, parcSortedList_ToString); +} + +LONGBOW_TEST_FIXTURE_SETUP(Global) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_FIXTURE_TEARDOWN(Global) +{ + if (!parcMemoryTesting_ExpectedOutstanding(0, "%s mismanaged memory.", longBowTestCase_GetFullName(testCase))) { + return LONGBOW_STATUS_MEMORYLEAK; + } + + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_CASE(Global, parcSortedList_Copy) +{ + PARCSortedList *instance = parcSortedList_Create(); + PARCSortedList *copy = parcSortedList_Copy(instance); + assertTrue(parcSortedList_Equals(instance, copy), "Expected the copy to be equal to the original"); + + parcSortedList_Release(&instance); + parcSortedList_Release(©); +} + +LONGBOW_TEST_CASE(Global, parcSortedList_Display) +{ + PARCSortedList *instance = parcSortedList_Create(); + parcSortedList_Display(instance, 0); + parcSortedList_Release(&instance); +} + +LONGBOW_TEST_CASE(Global, parcSortedList_Equals) +{ + PARCSortedList *x = parcSortedList_Create(); + PARCSortedList *y = parcSortedList_Create(); + PARCSortedList *z = parcSortedList_Create(); + + parcObjectTesting_AssertEquals(x, y, z, NULL); + + parcSortedList_Release(&x); + parcSortedList_Release(&y); + parcSortedList_Release(&z); +} + +LONGBOW_TEST_CASE(Global, parcSortedList_HashCode) +{ + PARCSortedList *x = parcSortedList_Create(); + PARCSortedList *y = parcSortedList_Create(); + + parcObjectTesting_AssertHashCode(x, y); + + parcSortedList_Release(&x); + parcSortedList_Release(&y); +} + +LONGBOW_TEST_CASE(Global, parcSortedList_IsValid) +{ + PARCSortedList *instance = parcSortedList_Create(); + assertTrue(parcSortedList_IsValid(instance), "Expected parcSortedList_Create to result in a valid instance."); + + parcSortedList_Release(&instance); + assertFalse(parcSortedList_IsValid(instance), "Expected parcSortedList_Release to result in an invalid instance."); +} + +LONGBOW_TEST_CASE(Global, parcSortedList_ToJSON) +{ + PARCSortedList *instance = parcSortedList_Create(); + + PARCJSON *json = parcSortedList_ToJSON(instance); + + parcJSON_Release(&json); + + parcSortedList_Release(&instance); +} + +LONGBOW_TEST_CASE(Global, parcSortedList_ToString) +{ + PARCSortedList *instance = parcSortedList_Create(); + + char *string = parcSortedList_ToString(instance); + + assertNotNull(string, "Expected non-NULL result from parcSortedList_ToString"); + + parcMemory_Deallocate((void **) &string); + parcSortedList_Release(&instance); +} + +LONGBOW_TEST_FIXTURE(Specialization) +{ + LONGBOW_RUN_TEST_CASE(Specialization, parcSortedList_Add); + LONGBOW_RUN_TEST_CASE(Specialization, parcSortedList_Remove); + LONGBOW_RUN_TEST_CASE(Specialization, parcSortedList_GetAtIndex); + LONGBOW_RUN_TEST_CASE(Specialization, parcSortedList_GetFirst); + LONGBOW_RUN_TEST_CASE(Specialization, parcSortedList_GetLast); + + LONGBOW_RUN_TEST_CASE(Specialization, parcSortedList_RemoveFirst); + LONGBOW_RUN_TEST_CASE(Specialization, parcSortedList_RemoveFirst_SingleElement); + LONGBOW_RUN_TEST_CASE(Specialization, parcSortedList_RemoveLast); +} + +LONGBOW_TEST_FIXTURE_SETUP(Specialization) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_FIXTURE_TEARDOWN(Specialization) +{ + if (!parcMemoryTesting_ExpectedOutstanding(0, "%s mismanaged memory.", longBowTestCase_GetFullName(testCase))) { + return LONGBOW_STATUS_MEMORYLEAK; + } + + return LONGBOW_STATUS_SUCCEEDED; +} + +static void +dump(PARCSortedList *i) +{ + PARCIterator *iterator = parcSortedList_CreateIterator(i); + while (parcIterator_HasNext(iterator)) { + PARCBuffer *buffer = parcIterator_Next(iterator); + parcBuffer_Display(buffer, 0); + } + + parcIterator_Release(&iterator); +} + +LONGBOW_TEST_CASE(Specialization, parcSortedList_Add) +{ + PARCSortedList *instance = parcSortedList_Create(); + PARCBuffer *element1 = parcBuffer_WrapCString("1"); + PARCBuffer *element2 = parcBuffer_WrapCString("2"); + PARCBuffer *element3 = parcBuffer_WrapCString("3"); + PARCBuffer *element4 = parcBuffer_WrapCString("4"); + PARCBuffer *element7 = parcBuffer_WrapCString("7"); + PARCBuffer *element6 = parcBuffer_WrapCString("6"); + PARCBuffer *element5 = parcBuffer_WrapCString("5"); + PARCBuffer *element8 = parcBuffer_WrapCString("8"); + + parcSortedList_Add(instance, element2); + parcSortedList_Display(instance, 0); + parcSortedList_Add(instance, element8); + parcSortedList_Display(instance, 0); + parcSortedList_Add(instance, element3); + parcSortedList_Display(instance, 0); + parcSortedList_Add(instance, element4); + parcSortedList_Display(instance, 0); + parcSortedList_Add(instance, element7); + parcSortedList_Display(instance, 0); + parcSortedList_Add(instance, element6); + parcSortedList_Display(instance, 0); + parcSortedList_Add(instance, element5); + parcSortedList_Display(instance, 0); + parcSortedList_Add(instance, element1); + parcSortedList_Display(instance, 0); + parcSortedList_Add(instance, element6); + parcSortedList_Display(instance, 0); + + dump(instance); + + parcBuffer_Release(&element1); + parcBuffer_Release(&element2); + parcBuffer_Release(&element3); + parcBuffer_Release(&element4); + parcBuffer_Release(&element5); + parcBuffer_Release(&element6); + parcBuffer_Release(&element7); + parcBuffer_Release(&element8); + parcSortedList_Release(&instance); +} + +LONGBOW_TEST_CASE(Specialization, parcSortedList_Remove) +{ + PARCSortedList *instance = parcSortedList_Create(); + PARCBuffer *element1 = parcBuffer_WrapCString("1"); + PARCBuffer *element2 = parcBuffer_WrapCString("2"); + PARCBuffer *element3 = parcBuffer_WrapCString("3"); + PARCBuffer *element4 = parcBuffer_WrapCString("4"); + PARCBuffer *element7 = parcBuffer_WrapCString("7"); + PARCBuffer *element6 = parcBuffer_WrapCString("6"); + PARCBuffer *element5 = parcBuffer_WrapCString("5"); + PARCBuffer *element8 = parcBuffer_WrapCString("8"); + + parcSortedList_Add(instance, element1); + parcSortedList_Add(instance, element2); + parcSortedList_Add(instance, element3); + parcSortedList_Display(instance, 0); + + parcSortedList_Remove(instance, element2); + + assertTrue(parcSortedList_Size(instance) == 2, "Expected list to be 2 in size"); + + parcBuffer_Release(&element1); + parcBuffer_Release(&element2); + parcBuffer_Release(&element3); + parcBuffer_Release(&element4); + parcBuffer_Release(&element5); + parcBuffer_Release(&element6); + parcBuffer_Release(&element7); + parcBuffer_Release(&element8); + parcSortedList_Release(&instance); +} + +LONGBOW_TEST_CASE(Specialization, parcSortedList_GetAtIndex) +{ + PARCSortedList *instance = parcSortedList_Create(); + PARCBuffer *element1 = parcBuffer_WrapCString("1"); + PARCBuffer *element2 = parcBuffer_WrapCString("2"); + PARCBuffer *element3 = parcBuffer_WrapCString("3"); + PARCBuffer *element4 = parcBuffer_WrapCString("4"); + PARCBuffer *element7 = parcBuffer_WrapCString("7"); + PARCBuffer *element6 = parcBuffer_WrapCString("6"); + PARCBuffer *element5 = parcBuffer_WrapCString("5"); + PARCBuffer *element8 = parcBuffer_WrapCString("8"); + + parcSortedList_Add(instance, element1); + parcSortedList_Add(instance, element2); + parcSortedList_Add(instance, element3); + + PARCBuffer *actual = (PARCBuffer *) parcSortedList_GetAtIndex(instance, 1); + assertTrue(parcBuffer_Equals(element2, actual), "Got the wrong value at index 1"); + + parcBuffer_Release(&element1); + parcBuffer_Release(&element2); + parcBuffer_Release(&element3); + parcBuffer_Release(&element4); + parcBuffer_Release(&element5); + parcBuffer_Release(&element6); + parcBuffer_Release(&element7); + parcBuffer_Release(&element8); + parcSortedList_Release(&instance); +} + +LONGBOW_TEST_CASE(Specialization, parcSortedList_GetFirst) +{ + PARCSortedList *instance = parcSortedList_Create(); + PARCBuffer *element1 = parcBuffer_WrapCString("1"); + PARCBuffer *element2 = parcBuffer_WrapCString("2"); + PARCBuffer *element3 = parcBuffer_WrapCString("3"); + PARCBuffer *element4 = parcBuffer_WrapCString("4"); + PARCBuffer *element7 = parcBuffer_WrapCString("7"); + PARCBuffer *element6 = parcBuffer_WrapCString("6"); + PARCBuffer *element5 = parcBuffer_WrapCString("5"); + PARCBuffer *element8 = parcBuffer_WrapCString("8"); + + parcSortedList_Add(instance, element1); + parcSortedList_Add(instance, element2); + parcSortedList_Add(instance, element3); + + PARCBuffer *actual = (PARCBuffer *) parcSortedList_GetFirst(instance); + assertTrue(parcBuffer_Equals(element1, actual), "Got the wrong value."); + + parcBuffer_Release(&element1); + parcBuffer_Release(&element2); + parcBuffer_Release(&element3); + parcBuffer_Release(&element4); + parcBuffer_Release(&element5); + parcBuffer_Release(&element6); + parcBuffer_Release(&element7); + parcBuffer_Release(&element8); + parcSortedList_Release(&instance); +} + +LONGBOW_TEST_CASE(Specialization, parcSortedList_GetLast) +{ + PARCSortedList *instance = parcSortedList_Create(); + PARCBuffer *element1 = parcBuffer_WrapCString("1"); + PARCBuffer *element2 = parcBuffer_WrapCString("2"); + PARCBuffer *element3 = parcBuffer_WrapCString("3"); + PARCBuffer *element4 = parcBuffer_WrapCString("4"); + PARCBuffer *element7 = parcBuffer_WrapCString("7"); + PARCBuffer *element6 = parcBuffer_WrapCString("6"); + PARCBuffer *element5 = parcBuffer_WrapCString("5"); + PARCBuffer *element8 = parcBuffer_WrapCString("8"); + + parcSortedList_Add(instance, element1); + parcSortedList_Add(instance, element2); + parcSortedList_Add(instance, element3); + + PARCBuffer *actual = (PARCBuffer *) parcSortedList_GetLast(instance); + assertTrue(parcBuffer_Equals(element3, actual), "Got the wrong value at index 1"); + + parcBuffer_Release(&element1); + parcBuffer_Release(&element2); + parcBuffer_Release(&element3); + parcBuffer_Release(&element4); + parcBuffer_Release(&element5); + parcBuffer_Release(&element6); + parcBuffer_Release(&element7); + parcBuffer_Release(&element8); + parcSortedList_Release(&instance); +} + +LONGBOW_TEST_CASE(Specialization, parcSortedList_RemoveFirst) +{ + PARCSortedList *deque = parcSortedList_Create(); + + PARCBuffer *object1 = parcBuffer_WrapCString("1"); + PARCBuffer *object2 = parcBuffer_WrapCString("2"); + PARCBuffer *object3 = parcBuffer_WrapCString("3"); + + parcSortedList_Add(deque, object1); + parcSortedList_Add(deque, object2); + parcSortedList_Add(deque, object3); + + PARCBuffer *peek = parcSortedList_RemoveFirst(deque); + assertTrue(parcBuffer_Equals(object1, peek), "Objects out of order"); + + parcBuffer_Release(&peek); + parcBuffer_Release(&object1); + parcBuffer_Release(&object2); + parcBuffer_Release(&object3); + parcSortedList_Release(&deque); +} + +LONGBOW_TEST_CASE(Specialization, parcSortedList_RemoveFirst_SingleElement) +{ + PARCBuffer *object1 = parcBuffer_WrapCString("1"); + PARCSortedList *deque = parcSortedList_Create(); + parcSortedList_Add(deque, object1); + + PARCBuffer *peek = parcSortedList_RemoveFirst(deque); + assertTrue(parcBuffer_Equals(object1, peek), + "Objects out of order."); + + parcBuffer_Release(&peek); + parcBuffer_Release(&object1); + parcSortedList_Release(&deque); +} + +LONGBOW_TEST_CASE(Specialization, parcSortedList_RemoveLast) +{ + PARCBuffer *object1 = parcBuffer_WrapCString("1"); + PARCBuffer *object2 = parcBuffer_WrapCString("2"); + PARCBuffer *object3 = parcBuffer_WrapCString("3"); + + PARCSortedList *deque = parcSortedList_Create(); + parcSortedList_Add(deque, object1); + parcSortedList_Add(deque, object2); + parcSortedList_Add(deque, object3); + + PARCBuffer *peek = parcSortedList_RemoveLast(deque); + assertTrue(parcBuffer_Equals(object3, peek), + "Objects out of order."); + + parcBuffer_Release(&peek); + + parcBuffer_Release(&object1); + parcBuffer_Release(&object2); + parcBuffer_Release(&object3); + parcSortedList_Release(&deque); +} + +LONGBOW_TEST_CASE(Specialization, parcSortedList_RemoveLast_SingleElement) +{ + PARCBuffer *object1 = parcBuffer_WrapCString("1"); + + PARCSortedList *deque = parcSortedList_Create(); + parcSortedList_Add(deque, object1); + + PARCBuffer *peek = parcSortedList_RemoveLast(deque); + assertTrue(parcBuffer_Equals(object1, peek), + "Objects out of order."); + + parcBuffer_Release(&object1); + parcSortedList_Release(&deque); +} + +int +main(int argc, char *argv[argc]) +{ + LongBowRunner *testRunner = LONGBOW_TEST_RUNNER_CREATE(parc_SortedList); + int exitStatus = longBowMain(argc, argv, testRunner, NULL); + longBowTestRunner_Destroy(&testRunner); + exit(exitStatus); +} -- cgit 1.2.3-korg