1 files changed, 0 insertions, 620 deletions
diff --git a/libparc/parc/algol/test/test_parc_Deque.c b/libparc/parc/algol/test/test_parc_Deque.c
deleted file mode 100755
index 02884b4a..00000000
--- a/libparc/parc/algol/test/test_parc_Deque.c
+++ /dev/null
@@ -1,620 +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.
- */
-
-#include "../parc_Deque.c"
-#include <LongBow/unit-test.h>
-#include <parc/algol/parc_SafeMemory.h>
-#include <parc/algol/parc_StdlibMemory.h>
-
-#include <parc/testing/parc_ObjectTesting.h>
-#include <parc/testing/parc_MemoryTesting.h>
-
-LONGBOW_TEST_RUNNER(parc_Deque)
-{
-    // 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(Local);
-    LONGBOW_RUN_TEST_FIXTURE(AcquireRelease);
-    LONGBOW_RUN_TEST_FIXTURE(Global);
-    LONGBOW_RUN_TEST_FIXTURE(Performance);
-//    LONGBOW_RUN_TEST_FIXTURE(Errors);
-}
-
-// The Test Runner calls this function once before any Test Fixtures are run.
-LONGBOW_TEST_RUNNER_SETUP(parc_Deque)
-{
-    parcMemory_SetInterface(&PARCSafeMemoryAsPARCMemory);
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-// The Test Runner calls this function once after all the Test Fixtures are run.
-LONGBOW_TEST_RUNNER_TEARDOWN(parc_Deque)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE(AcquireRelease)
-{
-    LONGBOW_RUN_TEST_CASE(AcquireRelease, parcDeque_CreateRelease);
-    LONGBOW_RUN_TEST_CASE(AcquireRelease, parcDeque_CreateRelease_WithEquals);
-    LONGBOW_RUN_TEST_CASE(AcquireRelease, parcDeque_AcquireRelease);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(AcquireRelease)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(AcquireRelease)
-{
-    bool leaked = parcMemoryTesting_ExpectedOutstanding(0, "%s leaks memory \n", longBowTestCase_GetName(testCase)) != true;
-    if (leaked) {
-        parcSafeMemory_ReportAllocation(STDOUT_FILENO);
-        printf("bailing\n");
-        exit(1);
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_CASE(AcquireRelease, parcDeque_CreateRelease)
-{
-    PARCDeque *deque = parcDeque_Create();
-    assertNotNull(deque, "Expected non-null result from parcDeque_Create()");
-
-    parcDeque_Release(&deque);
-    assertNull(deque, "Expected parcDeque_Release to null the pointer");
-}
-
-LONGBOW_TEST_CASE(AcquireRelease, parcDeque_CreateRelease_WithEquals)
-{
-    PARCDeque *deque = parcDeque_CreateCustom(NULL, NULL);
-    assertNotNull(deque, "Expected non-null result from parcDeque_Create()");
-
-    parcDeque_Release(&deque);
-    assertNull(deque, "Expected parcDeque_Release to null the pointer");
-}
-
-LONGBOW_TEST_CASE(AcquireRelease, parcDeque_AcquireRelease)
-{
-    PARCDeque *original = parcDeque_Create();
-    assertNotNull(original, "Expected non-null result from parcDeque_Create()");
-
-    parcObjectTesting_AssertAcquireReleaseContract(parcDeque_Acquire, original);
-
-    PARCDeque *reference = parcDeque_Acquire(original);
-    assertTrue(original == reference, "Expected the reference to be equal to the original.");
-
-    parcDeque_Release(&original);
-    assertNull(original, "Expected parcDeque_Release to null the pointer");
-
-    parcDeque_Append(reference, (void *) 1);
-    size_t expected = 1;
-    size_t actual = parcDeque_Size(reference);
-    assertTrue(expected == actual,
-               "Expected size %zd, actual %zd", expected, actual);
-    parcDeque_Release(&reference);
-}
-
-LONGBOW_TEST_FIXTURE(Global)
-{
-    LONGBOW_RUN_TEST_CASE(Global, parcDeque_Append_One);
-    LONGBOW_RUN_TEST_CASE(Global, parcDeque_Append_Two);
-    LONGBOW_RUN_TEST_CASE(Global, parcDeque_CreateDestroy);
-    LONGBOW_RUN_TEST_CASE(Global, parcDeque_PeekFirst);
-    LONGBOW_RUN_TEST_CASE(Global, parcDeque_PeekLast);
-
-    LONGBOW_RUN_TEST_CASE(Global, parcDeque_Prepend_One);
-    LONGBOW_RUN_TEST_CASE(Global, parcDeque_Prepend_Two);
-    LONGBOW_RUN_TEST_CASE(Global, parcDeque_Prepend_Three);
-
-    LONGBOW_RUN_TEST_CASE(Global, parcDeque_IsEmpty);
-    LONGBOW_RUN_TEST_CASE(Global, parcDeque_GetAtIndex);
-
-    LONGBOW_RUN_TEST_CASE(Global, parcDeque_RemoveFirst);
-    LONGBOW_RUN_TEST_CASE(Global, parcDeque_RemoveFirst_SingleElement);
-    LONGBOW_RUN_TEST_CASE(Global, parcDeque_RemoveLast);
-    LONGBOW_RUN_TEST_CASE(Global, parcDeque_Size);
-    LONGBOW_RUN_TEST_CASE(Global, parcDeque_Equals);
-    LONGBOW_RUN_TEST_CASE(Global, parcDeque_Copy);
-    LONGBOW_RUN_TEST_CASE(Global, parcDeque_Display);
-    LONGBOW_RUN_TEST_CASE(Global, parcDeque_Display_NULL);
-
-    LONGBOW_RUN_TEST_CASE(Global, parcDeque_Iterator);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Global)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Global)
-{
-    bool leaked = parcMemoryTesting_ExpectedOutstanding(0, "%s leaks memory \n", longBowTestCase_GetName(testCase)) != true;
-    if (leaked) {
-        parcSafeMemory_ReportAllocation(STDOUT_FILENO);
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_CASE(Global, parcDeque_Append_One)
-{
-    PARCDeque *deque = parcDeque_Create();
-    PARCDeque *actual = parcDeque_Append(deque, "element 1");
-
-    assertTrue(deque == actual, "Expected parcDeque_Append to return its argument.");
-    assertTrue(parcDeque_Size(deque) == 1, "Expected size of 1, actual %zd", parcDeque_Size(deque));
-
-    parcDeque_Release(&deque);
-}
-
-LONGBOW_TEST_CASE(Global, parcDeque_Append_Two)
-{
-    PARCDeque *deque = parcDeque_Create();
-    parcDeque_Append(deque, "element 1");
-    PARCDeque *actual = parcDeque_Append(deque, "element 2");
-
-    assertTrue(deque == actual, "Expected parcDeque_Append to return its argument.");
-    assertTrue(parcDeque_Size(deque) == 2, "Expected size of 2, actual %zd", parcDeque_Size(deque));
-
-    parcDeque_Release(&deque);
-}
-
-LONGBOW_TEST_CASE(Global, parcDeque_CreateDestroy)
-{
-    PARCDeque *deque = parcDeque_Create();
-    assertNotNull(deque, "Expected non-null result from parcDeque_Create()");
-
-    parcDeque_Release(&deque);
-    assertNull(deque, "Expected parcDeque_Destroy to null the pointer");
-}
-
-LONGBOW_TEST_CASE(Global, parcDeque_PeekFirst)
-{
-    char *expected = "element 2";
-    PARCDeque *deque = parcDeque_Create();
-    parcDeque_Append(deque, expected);
-    parcDeque_Append(deque, "element 2");
-    parcDeque_Append(deque, "element 3");
-
-    char *actual = parcDeque_PeekFirst(deque);
-    assertTrue(strcmp(expected, actual) == 0, "Expected '%s' actual '%s'", expected, actual);
-
-    parcDeque_Release(&deque);
-}
-
-LONGBOW_TEST_CASE(Global, parcDeque_PeekLast)
-{
-    char *expected = "element 2";
-    PARCDeque *deque = parcDeque_Create();
-    parcDeque_Append(deque, "element 1");
-    parcDeque_Append(deque, "element 2");
-    parcDeque_Append(deque, expected);
-
-    char *actual = parcDeque_PeekLast(deque);
-    assertTrue(strcmp(expected, actual) == 0, "Expected '%s' actual '%s'", expected, actual);
-
-    parcDeque_Release(&deque);
-}
-
-LONGBOW_TEST_CASE(Global, parcDeque_Prepend_One)
-{
-    PARCDeque *deque = parcDeque_Create();
-    PARCDeque *actual = parcDeque_Prepend(deque, "element 1");
-
-    assertTrue(deque == actual, "Expected parcDeque_Append to return its argument.");
-    assertTrue(parcDeque_Size(deque) == 1, "Expected size of 1, actual %zd", parcDeque_Size(deque));
-    assertTrue(deque->head != NULL, "Expected head to be not null.");
-    assertTrue(deque->head == deque->tail, "Expected head to be equal to the tail.");
-
-    parcDeque_Release(&deque);
-}
-
-LONGBOW_TEST_CASE(Global, parcDeque_Prepend_Two)
-{
-    PARCDeque *deque = parcDeque_Create();
-    parcDeque_Prepend(deque, "element 2");
-    PARCDeque *actual = parcDeque_Prepend(deque, "element 1");
-
-    assertTrue(deque == actual, "Expected parcDeque_Prepend to return its argument.");
-    assertTrue(parcDeque_Size(deque) == 2, "Expected size of 2, actual %zd", parcDeque_Size(deque));
-
-    parcDeque_Release(&deque);
-}
-
-LONGBOW_TEST_CASE(Global, parcDeque_Prepend_Three)
-{
-    char *expectedFirst = "expected first";
-    char *expectedLast = "expected last";
-
-    PARCDeque *deque = parcDeque_Create();
-    parcDeque_Prepend(deque, expectedLast);
-    parcDeque_Prepend(deque, "element 2");
-    PARCDeque *actual = parcDeque_Prepend(deque, expectedFirst);
-
-    assertTrue(deque == actual, "Expected parcDeque_Prepend to return its argument.");
-    assertTrue(parcDeque_Size(deque) == 3, "Expected size of 3, actual %zd", parcDeque_Size(deque));
-
-    char *peek = parcDeque_PeekFirst(deque);
-    assertTrue(strcmp(expectedFirst, peek) == 0, "Expected '%s' actual '%s'", expectedFirst, peek);
-
-    peek = parcDeque_PeekLast(deque);
-    assertTrue(strcmp(expectedLast, peek) == 0, "Expected '%s' actual '%s'", expectedLast, peek);
-
-    parcDeque_Release(&deque);
-}
-
-LONGBOW_TEST_CASE(Global, parcDeque_RemoveFirst)
-{
-    char *expectedFirst = "expected 1st";
-    char *expectedLast = "expected last";
-
-    PARCDeque *deque = parcDeque_Create();
-    parcDeque_Prepend(deque, expectedLast);
-    parcDeque_Prepend(deque, "element 2");
-    parcDeque_Prepend(deque, expectedFirst);
-
-    char *peek = parcDeque_RemoveFirst(deque);
-    assertTrue(strcmp(expectedFirst, peek) == 0, "Expected '%s' actual '%s'", expectedFirst, peek);
-
-    parcDeque_Release(&deque);
-}
-
-LONGBOW_TEST_CASE(Global, parcDeque_RemoveFirst_SingleElement)
-{
-    char *expectedFirst = "expected 1st";
-
-    PARCDeque *deque = parcDeque_Create();
-    parcDeque_Prepend(deque, expectedFirst);
-
-    char *peek = parcDeque_RemoveFirst(deque);
-    assertTrue(strcmp(expectedFirst, peek) == 0,
-               "Expected '%s' actual '%s'", expectedFirst, peek);
-
-    parcDeque_Release(&deque);
-}
-
-LONGBOW_TEST_CASE(Global, parcDeque_RemoveLast)
-{
-    char *expectedFirst = "expected 1st";
-    char *expectedLast = "expected last";
-
-    PARCDeque *deque = parcDeque_Create();
-    parcDeque_Prepend(deque, expectedLast);
-    parcDeque_Prepend(deque, "element 2");
-    parcDeque_Prepend(deque, expectedFirst);
-
-    char *peek = parcDeque_RemoveLast(deque);
-    assertTrue(strcmp(expectedLast, peek) == 0,
-               "Expected '%s' actual '%s'", expectedLast, peek);
-
-    parcDeque_Release(&deque);
-}
-
-LONGBOW_TEST_CASE(Global, parcDeque_RemoveLast_SingleElement)
-{
-    char *expectedFirst = "expected 1st";
-
-    PARCDeque *deque = parcDeque_Create();
-    parcDeque_Prepend(deque, expectedFirst);
-
-    char *peek = parcDeque_RemoveLast(deque);
-    assertTrue(strcmp(expectedFirst, peek) == 0,
-               "Expected '%s' actual '%s'", expectedFirst, peek);
-
-    parcDeque_Release(&deque);
-}
-
-LONGBOW_TEST_CASE(Global, parcDeque_Size)
-{
-    char *expectedFirst = "expected 1st";
-    char *expectedLast = "expected last";
-
-    PARCDeque *deque = parcDeque_Create();
-    parcDeque_Prepend(deque, expectedLast);
-    parcDeque_Prepend(deque, "element 2");
-    parcDeque_Prepend(deque, expectedFirst);
-
-    assertTrue(parcDeque_Size(deque) == 3,
-               "Expected 3, actual %zd", parcDeque_Size(deque));
-    parcDeque_Release(&deque);
-}
-
-LONGBOW_TEST_CASE(Global, parcDeque_IsEmpty)
-{
-    char *expectedLast = "expected last";
-
-    PARCDeque *deque = parcDeque_Create();
-
-    assertTrue(parcDeque_IsEmpty(deque), "Expected true.");
-    parcDeque_Prepend(deque, expectedLast);
-    assertFalse(parcDeque_IsEmpty(deque), "Expected false.");
-    parcDeque_Release(&deque);
-}
-
-LONGBOW_TEST_CASE(Global, parcDeque_GetAtIndex)
-{
-    char *expected0 = "expected 1";
-    char *expected1 = "expected 2";
-    char *expected2 = "expected 3";
-
-    PARCDeque *deque = parcDeque_Create();
-    parcDeque_Append(deque, expected0);
-    parcDeque_Append(deque, expected1);
-    parcDeque_Append(deque, expected2);
-
-    char *actual;
-    actual = parcDeque_GetAtIndex(deque, 0);
-    assertTrue(strcmp(actual, expected0) == 0, "Expected '%s', actual '%s", expected0, actual);
-    actual = parcDeque_GetAtIndex(deque, 1);
-    assertTrue(strcmp(actual, expected1) == 0, "Expected '%s', actual '%s", expected1, actual);
-    actual = parcDeque_GetAtIndex(deque, 2);
-    assertTrue(strcmp(actual, expected2) == 0, "Expected '%s', actual '%s", expected2, actual);
-
-    parcDeque_Release(&deque);
-}
-
-LONGBOW_TEST_CASE(Global, parcDeque_Equals)
-{
-    PARCDeque *x = parcDeque_Create();
-    parcDeque_Append(x, (void *) 0);
-    parcDeque_Append(x, (void *) 1);
-    parcDeque_Append(x, (void *) 2);
-    parcDeque_Append(x, (void *) 3);
-    parcDeque_Append(x, (void *) 4);
-    parcDeque_Append(x, (void *) 5);
-    PARCDeque *y = parcDeque_Create();
-    parcDeque_Append(y, (void *) 0);
-    parcDeque_Append(y, (void *) 1);
-    parcDeque_Append(y, (void *) 2);
-    parcDeque_Append(y, (void *) 3);
-    parcDeque_Append(y, (void *) 4);
-    parcDeque_Append(y, (void *) 5);
-    PARCDeque *z = parcDeque_Create();
-    parcDeque_Append(z, (void *) 0);
-    parcDeque_Append(z, (void *) 1);
-    parcDeque_Append(z, (void *) 2);
-    parcDeque_Append(z, (void *) 3);
-    parcDeque_Append(z, (void *) 4);
-    parcDeque_Append(z, (void *) 5);
-    PARCDeque *u1 = parcDeque_Create();
-    parcDeque_Append(u1, (void *) 0);
-    parcDeque_Append(u1, (void *) 1);
-    parcDeque_Append(u1, (void *) 2);
-    parcDeque_Append(u1, (void *) 3);
-    parcDeque_Append(u1, (void *) 4);
-    PARCDeque *u2 = parcDeque_Create();
-    parcDeque_Append(u2, (void *) 0);
-    parcDeque_Append(u2, (void *) 1);
-    parcDeque_Append(u2, (void *) 2);
-    parcDeque_Append(u2, (void *) 3);
-    parcDeque_Append(u2, (void *) 4);
-    parcDeque_Append(u2, (void *) 4);
-
-    parcObjectTesting_AssertEqualsFunction(parcDeque_Equals, x, y, z, u1, u2, NULL);
-
-    parcDeque_Release(&x);
-    parcDeque_Release(&y);
-    parcDeque_Release(&z);
-    parcDeque_Release(&u1);
-    parcDeque_Release(&u2);
-}
-
-LONGBOW_TEST_CASE(Global, parcDeque_Copy)
-{
-    PARCDeque *x = parcDeque_Create();
-    parcDeque_Append(x, (void *) 0);
-    parcDeque_Append(x, (void *) 1);
-    parcDeque_Append(x, (void *) 2);
-    parcDeque_Append(x, (void *) 3);
-    parcDeque_Append(x, (void *) 4);
-    parcDeque_Append(x, (void *) 5);
-
-    PARCDeque *y = parcDeque_Copy(x);
-
-    assertTrue(parcDeque_Equals(x, y), "Expected the copy to be equal to the original.");
-
-    parcDeque_Release(&y);
-    parcDeque_Release(&x);
-}
-
-LONGBOW_TEST_CASE(Global, parcDeque_Display)
-{
-    PARCDeque *x = parcDeque_Create();
-    parcDeque_Append(x, (void *) 0);
-    parcDeque_Append(x, (void *) 1);
-    parcDeque_Append(x, (void *) 2);
-    parcDeque_Append(x, (void *) 3);
-    parcDeque_Append(x, (void *) 4);
-    parcDeque_Append(x, (void *) 5);
-
-    parcDeque_Display(x, 0);
-
-    parcDeque_Release(&x);
-}
-
-LONGBOW_TEST_CASE(Global, parcDeque_Display_NULL)
-{
-    parcDeque_Display(NULL, 0);
-}
-
-LONGBOW_TEST_CASE(Global, parcDeque_Iterator)
-{
-    PARCDeque *x = parcDeque_Create();
-    for (size_t i = 0; i < 100; i++) {
-        parcDeque_Append(x, (void *) i);
-    }
-
-    PARCIterator *iterator = parcDeque_Iterator(x);
-    size_t expected = 0;
-    while (parcIterator_HasNext(iterator)) {
-        size_t actual = (size_t) parcIterator_Next(iterator);
-        assertTrue(expected == actual, "Expected %zd, actual %zd", expected, actual);
-        expected++;
-    }
-    parcIterator_Release(&iterator);
-
-    parcDeque_Release(&x);
-}
-
-LONGBOW_TEST_FIXTURE(Local)
-{
-    LONGBOW_RUN_TEST_CASE(Local, _parcDequeNode_Create);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Local)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Local)
-{
-    bool leaked = parcMemoryTesting_ExpectedOutstanding(0, "%s leaks memory \n", longBowTestCase_GetName(testCase)) != true;
-    if (leaked) {
-        parcSafeMemory_ReportAllocation(STDOUT_FILENO);
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_CASE(Local, _parcDequeNode_Create)
-{
-    void *element = "element";
-    struct parc_deque_node *previous = NULL;
-    struct parc_deque_node *next = NULL;
-
-    struct parc_deque_node *actual = _parcDequeNode_Create(element, previous, next);
-    _parcDequeNode_Destroy(NULL, &actual);
-}
-
-LONGBOW_TEST_FIXTURE(Errors)
-{
-    LONGBOW_RUN_TEST_CASE(Errors, parcDeque_GetAtIndex_OutOfBounds);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Errors)
-{
-    PARCDeque *deque = parcDeque_Create();
-    longBowTestCase_SetClipBoardData(testCase, deque);
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Errors)
-{
-    PARCDeque *deque = longBowTestCase_GetClipBoardData(testCase);
-    parcDeque_Release(&deque);
-
-    uint32_t outstandingAllocations = parcSafeMemory_ReportAllocation(STDOUT_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_EXPECTS(Errors, parcDeque_GetAtIndex_OutOfBounds, .event = &LongBowTrapOutOfBounds)
-{
-    char *expected0 = "expected 1";
-    char *expected1 = "expected 2";
-    char *expected2 = "expected 3";
-
-    PARCDeque *deque = longBowTestCase_GetClipBoardData(testCase);
-    parcDeque_Append(deque, expected0);
-    parcDeque_Append(deque, expected1);
-    parcDeque_Append(deque, expected2);
-
-    parcDeque_GetAtIndex(deque, 3);
-}
-
-LONGBOW_TEST_FIXTURE_OPTIONS(Performance, .enabled = false)
-{
-    LONGBOW_RUN_TEST_CASE(Performance, parcQueue_Append);
-    LONGBOW_RUN_TEST_CASE(Performance, parcQueue_N2);
-    LONGBOW_RUN_TEST_CASE(Performance, parcQueue_Iterator);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Performance)
-{
-    parcMemory_SetInterface(&PARCStdlibMemoryAsPARCMemory);
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Performance)
-{
-    uint32_t outstandingAllocations = parcSafeMemory_ReportAllocation(STDOUT_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(Performance, parcQueue_Append)
-{
-    PARCDeque *x = parcDeque_Create();
-
-    for (size_t i = 0; i < 100000; i++) {
-        parcDeque_Append(x, (void *) i);
-    }
-
-    parcDeque_Release(&x);
-}
-
-LONGBOW_TEST_CASE(Performance, parcQueue_N2)
-{
-    PARCDeque *x = parcDeque_Create();
-    for (size_t i = 0; i < 100000; i++) {
-        parcDeque_Append(x, (void *) i);
-    }
-
-    for (size_t expected = 0; expected < parcDeque_Size(x); expected++) {
-        size_t actual = (size_t) parcDeque_GetAtIndex(x, expected);
-        assertTrue(expected == actual, "Expected %zd, actual %zd", expected, actual);
-    }
-
-    parcDeque_Release(&x);
-}
-
-LONGBOW_TEST_CASE(Performance, parcQueue_Iterator)
-{
-    PARCDeque *x = parcDeque_Create();
-    for (size_t i = 0; i < 100000; i++) {
-        parcDeque_Append(x, (void *) i);
-    }
-
-    PARCIterator *iterator = parcDeque_Iterator(x);
-    size_t expected = 0;
-    while (parcIterator_HasNext(iterator)) {
-        size_t actual = (size_t) parcIterator_Next(iterator);
-        assertTrue(expected == actual, "Expected %zd, actual %zd", expected, actual);
-        expected++;
-    }
-    parcIterator_Release(&iterator);
-
-    parcDeque_Release(&x);
-}
-
-int
-main(int argc, char *argv[])
-{
-    LongBowRunner *testRunner = LONGBOW_TEST_RUNNER_CREATE(parc_Deque);
-    int exitStatus = LONGBOW_TEST_MAIN(argc, argv, testRunner);
-    longBowTestRunner_Destroy(&testRunner);
-    exit(exitStatus);
-}