1 files changed, 0 insertions, 499 deletions
diff --git a/libparc/parc/algol/test/test_parc_ByteArray.c b/libparc/parc/algol/test/test_parc_ByteArray.c
deleted file mode 100755
index 971d79dd..00000000
--- a/libparc/parc/algol/test/test_parc_ByteArray.c
+++ /dev/null
@@ -1,499 +0,0 @@
-/*
- * 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);
-}