diff options
Diffstat (limited to 'libparc/parc/algol/test/test_parc_ByteArray.c')
| -rwxr-xr-x | libparc/parc/algol/test/test_parc_ByteArray.c | 499 |
1 files changed, 499 insertions, 0 deletions
diff --git a/libparc/parc/algol/test/test_parc_ByteArray.c b/libparc/parc/algol/test/test_parc_ByteArray.c new file mode 100755 index 00000000..971d79dd --- /dev/null +++ b/libparc/parc/algol/test/test_parc_ByteArray.c @@ -0,0 +1,499 @@ +/* + * 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. + */ + +/** + * @file test_parc_ByteArray.c + * + */ +#include "../parc_ByteArray.c" +#include <stdio.h> + +#include <LongBow/unit-test.h> +#include <LongBow/debugging.h> +#include <stdio.h> + +#include <parc/algol/parc_SafeMemory.h> +#include <parc/testing/parc_ObjectTesting.h> + +LONGBOW_TEST_RUNNER(PARCByteArray) +{ + // 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(Global); + LONGBOW_RUN_TEST_FIXTURE(Errors); +} + +// The Test Runner calls this function once before any Test Fixtures are run. +LONGBOW_TEST_RUNNER_SETUP(PARCByteArray) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +// The Test Runner calls this function once after all the Test Fixtures are run. +LONGBOW_TEST_RUNNER_TEARDOWN(PARCByteArray) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_FIXTURE(Global) +{ + LONGBOW_RUN_TEST_CASE(Global, parcByteArray_Acquire); + LONGBOW_RUN_TEST_CASE(Global, parcByteArray_Acquire_destroyoriginal); + LONGBOW_RUN_TEST_CASE(Global, parcByteArray_Allocate); + LONGBOW_RUN_TEST_CASE(Global, parcByteArray_Allocate_ZeroLength); + + LONGBOW_RUN_TEST_CASE(Global, parcByteArray_Wrap_NULL); + LONGBOW_RUN_TEST_CASE(Global, parcByteArray_Wrap_ZeroLength); + + LONGBOW_RUN_TEST_CASE(Global, parcByteArray_Wrap); + LONGBOW_RUN_TEST_CASE(Global, parcByteArray_Array); + LONGBOW_RUN_TEST_CASE(Global, parcByteArray_AddressOfIndex); + LONGBOW_RUN_TEST_CASE(Global, parcByteArray_Capacity); + LONGBOW_RUN_TEST_CASE(Global, parcByteArray_Copy_Allocated); + LONGBOW_RUN_TEST_CASE(Global, parcByteArray_Copy_Wrapped); + LONGBOW_RUN_TEST_CASE(Global, parcByteArray_Compare); + LONGBOW_RUN_TEST_CASE(Global, parcByteArray_PutBytes); + LONGBOW_RUN_TEST_CASE(Global, parcByteArray_CopyOut); + LONGBOW_RUN_TEST_CASE(Global, parcByteArray_CopyInByteArray); + LONGBOW_RUN_TEST_CASE(Global, parcByteArray_Get); + LONGBOW_RUN_TEST_CASE(Global, parcByteArray_Put); + LONGBOW_RUN_TEST_CASE(Global, parcByteArray_Equals); + LONGBOW_RUN_TEST_CASE(Global, parcByteArray_HashCode); + LONGBOW_RUN_TEST_CASE(Global, parcByteArray_Release); + LONGBOW_RUN_TEST_CASE(Global, parcByteArray_Display); +} + +LONGBOW_TEST_FIXTURE_SETUP(Global) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_FIXTURE_TEARDOWN(Global) +{ + uint32_t outstandingAllocations = parcSafeMemory_ReportAllocation(STDERR_FILENO); + if (outstandingAllocations != 0) { + printf("%s leaks memory by %d allocations\n", longBowTestCase_GetName(testCase), outstandingAllocations); + return LONGBOW_STATUS_MEMORYLEAK; + } + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_CASE(Global, parcByteArray_Allocate) +{ + PARCByteArray *actual = parcByteArray_Allocate(10); + + parcByteArray_Release(&actual); +} + +LONGBOW_TEST_CASE(Global, parcByteArray_Allocate_ZeroLength) +{ + PARCByteArray *actual = parcByteArray_Allocate(0); + assertNotNull(actual, "parcByteArray_Allocate(0) must not return NULL."); + assertTrue(parcByteArray_Capacity(actual) == 0, "Expected capacity to be 0"); + + parcByteArray_Release(&actual); +} + +LONGBOW_TEST_CASE(Global, parcByteArray_Wrap) +{ + uint8_t buffer[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + PARCByteArray *actual = parcByteArray_Wrap(10, buffer); + + parcByteArray_Release(&actual); +} + +LONGBOW_TEST_CASE(Global, parcByteArray_Wrap_NULL) +{ + PARCByteArray *actual = parcByteArray_Wrap(10, NULL); + + assertNull(actual, "Expected NULL return value from parcByteArray_Wrap()"); +} + +LONGBOW_TEST_CASE(Global, parcByteArray_Wrap_ZeroLength) +{ + PARCByteArray *actual = parcByteArray_Wrap(0, (uint8_t[1]) { 0 }); + + assertNotNull(actual, "Expected non-NULL return value from parcByteArray_Wrap()"); + assertTrue(parcByteArray_Capacity(actual) == 0, "Expected capacity to be zero."); + parcByteArray_Release(&actual); +} + +LONGBOW_TEST_CASE(Global, parcByteArray_Array) +{ + uint8_t buffer[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + PARCByteArray *actual = parcByteArray_Wrap(10, buffer); + assertTrue(buffer == parcByteArray_Array(actual), "Expected the array to be the wrapped array."); + + parcByteArray_Release(&actual); +} + +LONGBOW_TEST_CASE(Global, parcByteArray_AddressOfIndex) +{ + uint8_t buffer[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + PARCByteArray *actual = parcByteArray_Wrap(10, buffer); + uint8_t *address = parcByteArray_AddressOfIndex(actual, 3); + + assertTrue(buffer[3] == *address, + "Expected %d, actual %d", buffer[3], *address); + + parcByteArray_Release(&actual); +} + + +LONGBOW_TEST_CASE(Global, parcByteArray_Release) +{ + PARCByteArray *actual = parcByteArray_Allocate(10); + + parcByteArray_Release(&actual); + assertNull(actual, "Expected the pointer to be NULL after parcByteArray_Release"); +} + +LONGBOW_TEST_CASE(Global, parcByteArray_Copy_Allocated) +{ + uint8_t buffer[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + PARCByteArray *original = parcByteArray_Allocate(sizeof(buffer)); + parcByteArray_PutBytes(original, 0, sizeof(buffer), buffer); + + PARCByteArray *clone = parcByteArray_Copy(original); + + assertTrue(original != clone, "Expected clone to be a different instance that original."); + + assertTrue(parcByteArray_Equals(original, clone), "Expected the clone to be equal to the original."); + + parcByteArray_Release(&original); + parcByteArray_Release(&clone); +} + +LONGBOW_TEST_CASE(Global, parcByteArray_Copy_Wrapped) +{ + uint8_t buffer[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + PARCByteArray *original = parcByteArray_Wrap(sizeof(buffer), buffer); + + PARCByteArray *clone = parcByteArray_Copy(original); + + assertTrue(original != clone, "Expected clone to be a different instance that original."); + + assertTrue(parcByteArray_Equals(original, clone), "Expected the clone to be equal to the original."); + + parcByteArray_Release(&original); + parcByteArray_Release(&clone); +} + +LONGBOW_TEST_CASE(Global, parcByteArray_Compare) +{ + uint8_t buffer[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + PARCByteArray *x = parcByteArray_Wrap(sizeof(buffer), buffer); + + PARCByteArray **equivalents = (PARCByteArray *[]) { + parcByteArray_Wrap(sizeof(buffer), buffer), + NULL + }; + PARCByteArray **lessers = (PARCByteArray *[]) { + parcByteArray_Wrap(sizeof(buffer) - 1, buffer), + parcByteArray_Wrap(sizeof(buffer) - 1, (uint8_t[]) { 0, 1, 2, 3, 4, 5, 6, 7, 8, 8 }), + NULL + }; + PARCByteArray **greaters = (PARCByteArray *[]) { + parcByteArray_Wrap(11, (uint8_t[]) { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }), + parcByteArray_Wrap(10, (uint8_t[]) { 0, 1, 2, 3, 4, 5, 6, 7, 8, 10 }), + NULL + }; + /* + * (a - b) + */ + parcObjectTesting_AssertCompareTo(parcByteArray_Compare, x, equivalents, lessers, greaters); + + parcByteArray_Release(&x); + + for (int i = 0; equivalents[i] != NULL; i++) { + parcByteArray_Release(&equivalents[i]); + } + for (int i = 0; lessers[i] != NULL; i++) { + parcByteArray_Release(&lessers[i]); + } + for (int i = 0; greaters[i] != NULL; i++) { + parcByteArray_Release(&greaters[i]); + } +} + +LONGBOW_TEST_CASE(Global, parcByteArray_Equals) +{ + uint8_t buffer[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + PARCByteArray *x = parcByteArray_Wrap(10, buffer); + PARCByteArray *y = parcByteArray_Wrap(10, buffer); + PARCByteArray *z = parcByteArray_Wrap(10, buffer); + PARCByteArray *u1 = parcByteArray_Wrap(5, buffer); + PARCByteArray *u2 = parcByteArray_Allocate(5); + + parcObjectTesting_AssertEqualsFunction(parcByteArray_Equals, x, y, z, u1, u2, NULL); + + parcByteArray_Release(&x); + parcByteArray_Release(&y); + parcByteArray_Release(&z); + parcByteArray_Release(&u1); + parcByteArray_Release(&u2); +} + +LONGBOW_TEST_CASE(Global, parcByteArray_Capacity) +{ + size_t expected = 10; + + PARCByteArray *actual = parcByteArray_Allocate(expected); + assertTrue(expected == parcByteArray_Capacity(actual), "Expected %zd, actual %zd", expected, parcByteArray_Capacity(actual)); + + parcByteArray_Release(&actual); +} + +LONGBOW_TEST_CASE(Global, parcByteArray_CopyOut) +{ + uint8_t expected[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + uint8_t actual[10]; + + PARCByteArray *original = parcByteArray_Wrap(10, expected); + parcByteArray_GetBytes(original, 0, sizeof(actual), actual); + + assertTrue(memcmp(expected, actual, sizeof(actual)) == 0, + "Expected parcByteArray_CopyOut to copy the orginal data"); + + parcByteArray_Release(&original); +} + +LONGBOW_TEST_CASE(Global, parcByteArray_PutBytes) +{ + uint8_t expected[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + uint8_t actual[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + + PARCByteArray *original = parcByteArray_Wrap(10, expected); + parcByteArray_PutBytes(original, 0, 10, actual); + + assertTrue(memcmp(expected, actual, 10) == 0, + "Expected parcByteArray_CopyOut to copy the orginal data"); + + parcByteArray_Release(&original); +} + +LONGBOW_TEST_CASE(Global, parcByteArray_CopyInByteArray) +{ + uint8_t array1[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + uint8_t array2[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + uint8_t expected[10] = { 0, 1, 2, 0, 0, 0, 6, 7, 8, 9 }; + + PARCByteArray *a1 = parcByteArray_Wrap(10, array1); + PARCByteArray *a2 = parcByteArray_Wrap(10, array2); + parcByteArray_ArrayCopy(a1, 3, a2, 0, 3); + + assertTrue(memcmp(expected, parcByteArray_Array(a1), 10) == 0, + "Expected parcByteArray_CopyOut to copy the orginal data"); + + parcByteArray_Release(&a1); + parcByteArray_Release(&a2); +} + +LONGBOW_TEST_CASE(Global, parcByteArray_Get) +{ + uint8_t buffer[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + PARCByteArray *original = parcByteArray_Wrap(10, buffer); + + for (uint8_t index = 0; index < 10; index++) { + uint8_t actual = parcByteArray_GetByte(original, index); + assertTrue(index == actual, "Expected %d, actual %d", index, actual); + } + parcByteArray_Release(&original); +} + +LONGBOW_TEST_CASE(Global, parcByteArray_Put) +{ + uint8_t buffer[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + + PARCByteArray *original = parcByteArray_Wrap(10, buffer); + + for (uint8_t index = 0; index < 10; index++) { + parcByteArray_PutByte(original, index, index); + } + + for (uint8_t index = 0; index < 10; index++) { + uint8_t actual = parcByteArray_GetByte(original, index); + assertTrue(index == actual, "Expected %d, actual %d", index, actual); + } + + parcByteArray_Release(&original); +} + +LONGBOW_TEST_CASE(Global, parcByteArray_Acquire) +{ + uint8_t buffer[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + PARCByteArray *actual = parcByteArray_Wrap(10, buffer); + PARCByteArray *reference = parcByteArray_Acquire(actual); + + assertTrue(reference == actual, "Expected the new reference to be equal to the original."); + + PARCByteArray *new1 = parcByteArray_Acquire(actual); + assertTrue(new1 == actual, "Expected new to be the same as actual"); + + PARCByteArray *new2 = parcByteArray_Acquire(actual); + assertTrue(new2 == actual, "Expected new to be the same as actual"); + + parcByteArray_Release(&new1); + assertNull(new1, "Expected destroy to null the pointer"); + assertNotNull(actual, "Expected destroy to NOT null the original pointer"); + + parcByteArray_Release(&new2); + assertNull(new1, "Expected destroy to null the pointer"); + assertNotNull(actual, "Expected destroy to NOT null the original pointer"); + + parcByteArray_Release(&reference); + parcByteArray_Release(&actual); +} + +LONGBOW_TEST_CASE(Global, parcByteArray_Acquire_destroyoriginal) +{ + uint8_t buffer[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + PARCByteArray *original = parcByteArray_Wrap(10, buffer); + + PARCByteArray *ref1 = parcByteArray_Acquire(original); + assertTrue(ref1 == original, "Expected new to be the same as original"); + + parcByteArray_Release(&original); + assertNull(original, "Expected destroy to null the pointer"); + assertNotNull(ref1, "Expected destroy to NOT null the new reference"); + + parcByteArray_Release(&ref1); +} + +LONGBOW_TEST_CASE(Global, parcByteArray_HashCode) +{ + uint8_t buffer[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + PARCByteArray *x = parcByteArray_Wrap(10, buffer); + PARCByteArray *y = parcByteArray_Wrap(10, buffer); + + PARCHashCode hashX = parcByteArray_HashCode(x); + PARCHashCode hashY = parcByteArray_HashCode(y); + + assertTrue(hashX == hashY, + "Expected %" PRIPARCHashCode ", actual %" PRIPARCHashCode, hashX, hashY); + + parcByteArray_Release(&x); + parcByteArray_Release(&y); +} + +LONGBOW_TEST_CASE(Global, parcByteArray_Display) +{ + uint8_t buffer[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23 }; + + PARCByteArray *x = parcByteArray_Wrap(sizeof(buffer), buffer); + + parcByteArray_Display(x, 0); + + parcByteArray_Release(&x); +} + +LONGBOW_TEST_FIXTURE(Errors) +{ + LONGBOW_RUN_TEST_CASE(Errors, parcByteArray_Put_overrun); + LONGBOW_RUN_TEST_CASE(Errors, parcByteArray_Get_overrun); + LONGBOW_RUN_TEST_CASE(Errors, parcByteArray_CopyIn_overrun); + LONGBOW_RUN_TEST_CASE(Errors, parcByteArray_CopyOut_overrun); +} + +typedef struct parc_byte_array_longbow_clipboard { + PARCByteArray *byteArray; +} parcByteArray_LongBowClipBoard; + +LONGBOW_TEST_FIXTURE_SETUP(Errors) +{ + parcByteArray_LongBowClipBoard *clipboardData = calloc(1, sizeof(parcByteArray_LongBowClipBoard)); + clipboardData->byteArray = parcByteArray_Allocate(10); + + longBowTestCase_SetClipBoardData(testCase, clipboardData); + + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_FIXTURE_TEARDOWN(Errors) +{ + parcByteArray_LongBowClipBoard *clipboardData = longBowTestCase_GetClipBoardData(testCase); + parcByteArray_Release(&clipboardData->byteArray); + free(clipboardData); + + uint32_t outstandingAllocations = parcSafeMemory_ReportAllocation(STDERR_FILENO); + if (outstandingAllocations != 0) { + printf("Errors %s leaks memory by %d allocations\n", longBowTestCase_GetName(testCase), outstandingAllocations); + return LONGBOW_STATUS_MEMORYLEAK; + } + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_CASE_EXPECTS(Errors, parcByteArray_Put_overrun, .event = &LongBowTrapOutOfBounds) +{ + parcByteArray_LongBowClipBoard *testData = longBowTestCase_GetClipBoardData(testCase); + PARCByteArray *original = testData->byteArray; + + for (uint8_t index = 0; index < 10 + 1; index++) { + parcByteArray_PutByte(original, index, index); // This will fail. + } +} + +LONGBOW_TEST_CASE_EXPECTS(Errors, parcByteArray_CopyIn_overrun, .event = &LongBowTrapOutOfBounds) +{ + uint8_t actual[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + + parcByteArray_LongBowClipBoard *testData = longBowTestCase_GetClipBoardData(testCase); + PARCByteArray *original = testData->byteArray; + parcByteArray_GetBytes(original, 1, 10, actual); // This will fail. +} + +LONGBOW_TEST_CASE_EXPECTS(Errors, parcByteArray_CopyOut_overrun, .event = &LongBowTrapOutOfBounds) +{ + uint8_t actual[10]; + + parcByteArray_LongBowClipBoard *testData = longBowTestCase_GetClipBoardData(testCase); + PARCByteArray *original = testData->byteArray; + parcByteArray_GetBytes(original, 1, 10, actual); // This will fail. +} + +LONGBOW_TEST_CASE_EXPECTS(Errors, parcByteArray_Get_overrun, .event = &LongBowTrapOutOfBounds) +{ + uint8_t buffer[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + parcByteArray_LongBowClipBoard *testData = longBowTestCase_GetClipBoardData(testCase); + PARCByteArray *original = testData->byteArray; + parcByteArray_PutBytes(original, 0, 10, buffer); + + for (uint8_t index = 0; index < 10 + 1; index++) { + uint8_t actual = parcByteArray_GetByte(original, index); // this will fail. + assertTrue(index == actual, "Expected %d, actual %d", index, actual); + } +} + +int +main(int argc, char *argv[argc]) +{ + LongBowRunner *testRunner = LONGBOW_TEST_RUNNER_CREATE(PARCByteArray); + int exitStatus = LONGBOW_TEST_MAIN(argc, argv, testRunner); + longBowTestRunner_Destroy(&testRunner); + exit(exitStatus); +} |