Remove cframework files from master

Change-Id: I02f17ede1cf97986a8b8852ed6d6a28fc016f590
Signed-off-by: Mauro Sardara <msardara@cisco.com>

52 files changed, 0 insertions, 13741 deletions

diff --git a/libparc/parc/concurrent/.gitignore b/libparc/parc/concurrent/.gitignore
deleted file mode 100644
index e6ed7cc3..00000000
--- a/libparc/parc/concurrent/.gitignore
+++ /dev/null
@@ -1,5 +0,0 @@
-parcConcurrent_About.c
-parcConcurrent_About.h
-
-test/test_parc_RingBuffer_1x1
-test/test_parc_RingBuffer_NxM
diff --git a/libparc/parc/concurrent/parc_AtomicUint16.c b/libparc/parc/concurrent/parc_AtomicUint16.c
deleted file mode 100755
index 9bf2e478..00000000
--- a/libparc/parc/concurrent/parc_AtomicUint16.c
+++ /dev/null
@@ -1,178 +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 <config.h>
-
-#include <parc/algol/parc_Object.h>
-#include <parc/algol/parc_DisplayIndented.h>
-
-#include <parc/concurrent/parc_AtomicUint16.h>
-
-struct PARCAtomicUint16 {
-    uint16_t value;
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    pthread_mutex_t mutex;
-#endif
-};
-
-static void
-_parcAtomicUint16_Finalize(PARCAtomicUint16 **instancePtr)
-{
-    parcAssertNotNull(instancePtr, "Parameter must be a non-null pointer to a PARCAtomicUint16 pointer.");
-
-    parcAtomicUint16_OptionalAssertValid((*instancePtr));
-
-    /* cleanup the instance fields here */
-}
-
-parcObject_ImplementAcquire(parcAtomicUint16, PARCAtomicUint16);
-
-parcObject_ImplementRelease(parcAtomicUint16, PARCAtomicUint16);
-
-parcObject_ExtendPARCObject(PARCAtomicUint16, _parcAtomicUint16_Finalize, parcAtomicUint16_Copy, NULL, parcAtomicUint16_Equals, parcAtomicUint16_Compare, parcAtomicUint16_HashCode, NULL);
-
-
-void
-parcAtomicUint16_AssertValid(const PARCAtomicUint16 *instance)
-{
-    parcAssertTrue(parcAtomicUint16_IsValid(instance),
-               "PARCAtomicUint16 is not valid.");
-}
-
-PARCAtomicUint16 *
-parcAtomicUint16_Create(uint16_t value)
-{
-    PARCAtomicUint16 *result = parcObject_CreateAndClearInstance(PARCAtomicUint16);
-
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    pthread_mutex_init(&result->mutex, NULL);
-    result->value = value;
-#else
-    *result = value;
-#endif
-
-    return result;
-}
-
-int
-parcAtomicUint16_Compare(const PARCAtomicUint16 *instance, const PARCAtomicUint16 *other)
-{
-    int16_t comparison = parcAtomicUint16_GetValue(instance) - parcAtomicUint16_GetValue(other);
-
-    int result = 0;
-    if (comparison < 0) {
-        result = -1;
-    } else if (comparison > 0) {
-        result = 1;
-    }
-
-    return result;
-}
-
-PARCAtomicUint16 *
-parcAtomicUint16_Copy(const PARCAtomicUint16 *original)
-{
-    PARCAtomicUint16 *result = parcAtomicUint16_Create(parcAtomicUint16_GetValue(original));
-
-    return result;
-}
-
-bool
-parcAtomicUint16_Equals(const PARCAtomicUint16 *x, const PARCAtomicUint16 *y)
-{
-    bool result = false;
-
-    result = parcAtomicUint16_GetValue(x) == parcAtomicUint16_GetValue(y);
-
-    return result;
-}
-
-PARCHashCode
-parcAtomicUint16_HashCode(const PARCAtomicUint16 *instance)
-{
-    PARCHashCode result = (PARCHashCode) parcAtomicUint16_GetValue(instance);
-
-    return result;
-}
-
-bool
-parcAtomicUint16_IsValid(const PARCAtomicUint16 *instance)
-{
-    bool result = false;
-
-    if (instance != NULL) {
-        result = true;
-    }
-
-    return result;
-}
-
-uint16_t
-parcAtomicUint16_GetValue(const PARCAtomicUint16 *instance)
-{
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    return instance->value;
-#else
-    return *instance;
-#endif
-}
-
-uint16_t
-parcAtomicUint16_AddImpl(PARCAtomicUint16 *value, uint16_t addend)
-{
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    pthread_mutex_lock(&value->mutex);
-    value->value += addend;
-    uint16_t result = value->value;
-    pthread_mutex_unlock(&value->mutex);
-    return result;
-#else
-    return __sync_add_and_fetch(value, addend);
-#endif
-}
-
-uint16_t
-parcAtomicUint16_SubtractImpl(PARCAtomicUint16 *value, uint16_t subtrahend)
-{
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    pthread_mutex_lock(&value->mutex);
-    value->value -= subtrahend;
-    uint16_t result = value->value;
-    pthread_mutex_unlock(&value->mutex);
-    return result;
-#else
-    return __sync_sub_and_fetch(value, subtrahend);
-#endif
-}
-
-bool
-parcAtomicUint16_CompareAndSwapImpl(PARCAtomicUint16 *value, uint16_t predicate, uint16_t newValue)
-{
-    bool result = false;
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    pthread_mutex_lock(&value->mutex);
-    if (value->value == predicate) {
-        value->value = newValue;
-        result = true;
-    }
-    pthread_mutex_unlock(&value->mutex);
-    return result;
-#else
-    result = __sync_bool_compare_and_swap(value, predicate, newValue);
-#endif
-    return result;
-}
diff --git a/libparc/parc/concurrent/parc_AtomicUint16.h b/libparc/parc/concurrent/parc_AtomicUint16.h
deleted file mode 100755
index ff6a4fc3..00000000
--- a/libparc/parc/concurrent/parc_AtomicUint16.h
+++ /dev/null
@@ -1,341 +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 parc_AtomicUint16.h
- * @ingroup threading
- * @brief An atomically updated 16-bit unsigned integer.
- *
- * <#Detailed Description#>
- *
- */
-#ifndef PARCLibrary_parc_AtomicUint16
-#define PARCLibrary_parc_AtomicUint16
-#include <stdbool.h>
-#include <stdint.h>
-
-#include <parc/algol/parc_JSON.h>
-
-#ifdef PARCLibrary_DISABLE_ATOMICS
-#include <pthread.h>
-struct PARCAtomicUint16;
-typedef struct PARCAtomicUint16 PARCAtomicUint16;
-#else
-typedef uint16_t PARCAtomicUint16;
-#endif
-
-
-PARCAtomicUint16 *parcAtomicInteger_CreateUint16(uint16_t value);
-
-uint16_t parcAtomicUint16_AddImpl(PARCAtomicUint16 *value, uint16_t addend);
-
-uint16_t parcAtomicUint16_SubtractImpl(PARCAtomicUint16 *value, uint16_t subtrahend);
-
-bool parcAtomicUint16_CompareAndSwapImpl(PARCAtomicUint16 *value, uint16_t predicate, uint16_t newValue);
-
-#ifdef PARCLibrary_DISABLE_ATOMICS
-
-#define parcAtomicUint16_Add                parcAtomicUint16_AddImpl
-
-#define parcAtomicUint16_Subtract           parcAtomicUint16_SubtractImpl
-
-#define parcAtomicUint16_CompareAndSwap     parcAtomicUint16_CompareAndSwapImpl
-
-#else
-
-#define parcAtomicUint16_Add(_atomic_uint16_, _addend_) \
-    __sync_add_and_fetch(_atomic_uint16_, _addend_)
-
-#define parcAtomicUint16_Subtract(_atomic_uint16_, _subtrahend_) \
-    __sync_sub_and_fetch(_atomic_uint16_, _subtrahend_)
-
-#define parcAtomicUint16_CompareAndSwap(_atomic_uint16_, _predicate_, _newValue_) \
-    __sync_bool_compare_and_swap(_atomic_uint16_, _predicate_, _newValue_)
-#endif
-
-#define parcAtomicUint16_Increment(_atomic_uint16_) parcAtomicUint16_Add(_atomic_uint16_, 1)
-#define parcAtomicUint16_Decrement(_atomic_uint16_) parcAtomicUint16_Subtract(_atomic_uint16_, 1)
-
-/**
- * Increase the number of references to a `PARCAtomicUint16` instance.
- *
- * Note that new `PARCAtomicUint16` is not created,
- * only that the given `PARCAtomicUint16` reference count is incremented.
- * Discard the reference by invoking `parcAtomicUint16_Release`.
- *
- * @param [in] instance A pointer to a valid PARCAtomicUint16 instance.
- *
- * @return The same value as @p instance.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint16 *a = parcAtomicUint16_Create();
- *
- *     PARCAtomicUint16 *b = parcAtomicUint16_Acquire();
- *
- *     parcAtomicUint16_Release(&a);
- *     parcAtomicUint16_Release(&b);
- * }
- * @endcode
- */
-PARCAtomicUint16 *parcAtomicUint16_Acquire(const PARCAtomicUint16 *instance);
-
-#ifdef PARCLibrary_DISABLE_VALIDATION
-#  define parcAtomicUint16_OptionalAssertValid(_instance_)
-#else
-#  define parcAtomicUint16_OptionalAssertValid(_instance_) parcAtomicUint16_AssertValid(_instance_)
-#endif
-
-/**
- * Assert that the given `PARCAtomicUint16` instance is valid.
- *
- * @param [in] instance A pointer to a valid PARCAtomicUint16 instance.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint16 *a = parcAtomicUint16_Create();
- *
- *     parcAtomicUint16_AssertValid(a);
- *
- *     printf("Instance is valid.\n");
- *
- *     parcAtomicUint16_Release(&b);
- * }
- * @endcode
- */
-void parcAtomicUint16_AssertValid(const PARCAtomicUint16 *instance);
-
-/**
- * Create an instance of PARCAtomicUint16
- *
- * <#Paragraphs Of Explanation#>
- *
- * @return non-NULL A pointer to a valid PARCAtomicUint16 instance.
- * @return NULL An error occurred.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint16 *a = parcAtomicUint16_Create();
- *
- *     parcAtomicUint16_Release(&b);
- * }
- * @endcode
- */
-PARCAtomicUint16 *parcAtomicUint16_Create(uint16_t);
-
-/**
- * Compares @p instance with @p other for order.
- *
- * Returns a negative integer, zero, or a positive integer as @p instance
- * is less than, equal to, or greater than @p other.
- *
- * @param [in] instance A pointer to a valid PARCAtomicUint16 instance.
- * @param [in] other A pointer to a valid PARCAtomicUint16 instance.
- *
- * @return <0 Instance is less than @p other.
- * @return 0 Instance a and instance b compare the same.
- * @return >0 Instance a is greater than instance b.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint16 *a = parcAtomicUint16_Create();
- *     PARCAtomicUint16 *b = parcAtomicUint16_Create();
- *
- *     if (parcAtomicUint16_Compare(a, b) == 0) {
- *         printf("Instances are equal.\n");
- *     }
- *
- *     parcAtomicUint16_Release(&a);
- *     parcAtomicUint16_Release(&b);
- * }
- * @endcode
- *
- * @see parcAtomicUint16_Equals
- */
-int parcAtomicUint16_Compare(const PARCAtomicUint16 *instance, const PARCAtomicUint16 *other);
-
-/**
- * Create an independent copy the given `PARCBuffer`
- *
- * A new buffer is created as a complete copy of the original.
- *
- * @param [in] original A pointer to a valid PARCAtomicUint16 instance.
- *
- * @return NULL Memory could not be allocated.
- * @return non-NULL A pointer to a new `PARCAtomicUint16` instance.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint16 *a = parcAtomicUint16_Create();
- *
- *     PARCAtomicUint16 *copy = parcAtomicUint16_Copy(&b);
- *
- *     parcAtomicUint16_Release(&b);
- *     parcAtomicUint16_Release(&copy);
- * }
- * @endcode
- */
-PARCAtomicUint16 *parcAtomicUint16_Copy(const PARCAtomicUint16 *original);
-
-/**
- * Determine if two `PARCAtomicUint16` instances are equal.
- *
- * The following equivalence relations on non-null `PARCAtomicUint16` instances are maintained: *
- *   * It is reflexive: for any non-null reference value x, `parcAtomicUint16_Equals(x, x)` must return true.
- *
- *   * It is symmetric: for any non-null reference values x and y, `parcAtomicUint16_Equals(x, y)` must return true if and only if
- *        `parcAtomicUint16_Equals(y x)` returns true.
- *
- *   * It is transitive: for any non-null reference values x, y, and z, if
- *        `parcAtomicUint16_Equals(x, y)` returns true and
- *        `parcAtomicUint16_Equals(y, z)` returns true,
- *        then `parcAtomicUint16_Equals(x, z)` must return true.
- *
- *   * It is consistent: for any non-null reference values x and y, multiple invocations of `parcAtomicUint16_Equals(x, y)`
- *         consistently return true or consistently return false.
- *
- *   * For any non-null reference value x, `parcAtomicUint16_Equals(x, NULL)` must return false.
- *
- * @param [in] x A pointer to a valid PARCAtomicUint16 instance.
- * @param [in] y A pointer to a valid PARCAtomicUint16 instance.
- *
- * @return true The instances x and y are equal.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint16 *a = parcAtomicUint16_Create();
- *     PARCAtomicUint16 *b = parcAtomicUint16_Create();
- *
- *     if (parcAtomicUint16_Equals(a, b)) {
- *         printf("Instances are equal.\n");
- *     }
- *
- *     parcAtomicUint16_Release(&a);
- *     parcAtomicUint16_Release(&b);
- * }
- * @endcode
- * @see parcAtomicUint16_HashCode
- */
-bool parcAtomicUint16_Equals(const PARCAtomicUint16 *x, const PARCAtomicUint16 *y);
-
-/**
- * Returns a hash code value for the given instance.
- *
- * The general contract of `HashCode` is:
- *
- * Whenever it is invoked on the same instance more than once during an execution of an application,
- * the `HashCode` function must consistently return the same value,
- * provided no information used in a corresponding comparisons on the instance is modified.
- *
- * This value need not remain consistent from one execution of an application to another execution of the same application.
- * If two instances are equal according to the {@link parcAtomicUint16_Equals} method,
- * then calling the {@link parcAtomicUint16_HashCode} method on each of the two instances must produce the same integer result.
- *
- * It is not required that if two instances are unequal according to the
- * {@link parcAtomicUint16_Equals} function,
- * then calling the `parcAtomicUint16_HashCode`
- * method on each of the two objects must produce distinct integer results.
- *
- * @param [in] instance A pointer to a valid PARCAtomicUint16 instance.
- *
- * @return The hashcode for the given instance.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint16 *a = parcAtomicUint16_Create();
- *
- *     PARCHashCode hashValue = parcAtomicUint16_HashCode(buffer);
- *     parcAtomicUint16_Release(&a);
- * }
- * @endcode
- */
-PARCHashCode parcAtomicUint16_HashCode(const PARCAtomicUint16 *instance);
-
-/**
- * Determine if an instance of `PARCAtomicUint16` is valid.
- *
- * Valid means the internal state of the type is consistent with its required current or future behaviour.
- * This may include the validation of internal instances of types.
- *
- * @param [in] instance A pointer to a valid PARCAtomicUint16 instance.
- *
- * @return true The instance is valid.
- * @return false The instance is not valid.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint16 *a = parcAtomicUint16_Create();
- *
- *     if (parcAtomicUint16_IsValid(a)) {
- *         printf("Instance is valid.\n");
- *     }
- *
- *     parcAtomicUint16_Release(&b);
- * }
- * @endcode
- */
-bool parcAtomicUint16_IsValid(const PARCAtomicUint16 *instance);
-
-/**
- * Release a previously acquired reference to the given `PARCAtomicUint16` instance,
- * decrementing the reference count for the instance.
- *
- * The pointer to the instance is set to NULL as a side-effect of this function.
- *
- * If the invocation causes the last reference to the instance to be released,
- * the instance is deallocated and the instance's implementation will perform
- * additional cleanup and release other privately held references.
- *
- * @param [in,out] instancePtr A pointer to a pointer to the instance to release.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint16 *a = parcAtomicUint16_Create();
- *
- *     parcAtomicUint16_Release(&a);
- * }
- * @endcode
- */
-void parcAtomicUint16_Release(PARCAtomicUint16 **instancePtr);
-
-/**
- * Get the current value of the given `PARCAtomicUint16` instance.
- *
- * @param [in] instance A pointer to a valid `PARCAtomicUint16` instance.
- *
- * @return the current value of the given `PARCAtomicUint16` instance.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint16 *instance = parcAtomicUint16_Create(7);
- *
- *     uint16_t value = parcAtomicUint16_GetValue(instance);
- *
- *     parcAtomicUint16_Release(&instance);
- * }
- * @endcode
- */
-uint16_t parcAtomicUint16_GetValue(const PARCAtomicUint16 *instance);
-#endif
diff --git a/libparc/parc/concurrent/parc_AtomicUint32.c b/libparc/parc/concurrent/parc_AtomicUint32.c
deleted file mode 100755
index 24093951..00000000
--- a/libparc/parc/concurrent/parc_AtomicUint32.c
+++ /dev/null
@@ -1,178 +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 <config.h>
-
-#include <parc/algol/parc_Object.h>
-#include <parc/algol/parc_DisplayIndented.h>
-
-#include <parc/concurrent/parc_AtomicUint32.h>
-
-struct PARCAtomicUint32 {
-    uint32_t value;
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    pthread_mutex_t mutex;
-#endif
-};
-
-static void
-_parcAtomicUint32_Finalize(PARCAtomicUint32 **instancePtr)
-{
-    parcAssertNotNull(instancePtr, "Parameter must be a non-null pointer to a PARCAtomicUint32 pointer.");
-
-    parcAtomicUint32_OptionalAssertValid((*instancePtr));
-
-    /* cleanup the instance fields here */
-}
-
-parcObject_ImplementAcquire(parcAtomicUint32, PARCAtomicUint32);
-
-parcObject_ImplementRelease(parcAtomicUint32, PARCAtomicUint32);
-
-parcObject_ExtendPARCObject(PARCAtomicUint32, _parcAtomicUint32_Finalize, parcAtomicUint32_Copy, NULL, parcAtomicUint32_Equals, parcAtomicUint32_Compare, parcAtomicUint32_HashCode, NULL);
-
-
-void
-parcAtomicUint32_AssertValid(const PARCAtomicUint32 *instance)
-{
-    parcAssertTrue(parcAtomicUint32_IsValid(instance),
-               "PARCAtomicUint32 is not valid.");
-}
-
-PARCAtomicUint32 *
-parcAtomicUint32_Create(uint32_t value)
-{
-    PARCAtomicUint32 *result = parcObject_CreateAndClearInstance(PARCAtomicUint32);
-
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    pthread_mutex_init(&result->mutex, NULL);
-    result->value = value;
-#else
-    *result = value;
-#endif
-
-    return result;
-}
-
-int
-parcAtomicUint32_Compare(const PARCAtomicUint32 *instance, const PARCAtomicUint32 *other)
-{
-    int32_t comparison = parcAtomicUint32_GetValue(instance) - parcAtomicUint32_GetValue(other);
-
-    int result = 0;
-    if (comparison < 0) {
-        result = -1;
-    } else if (comparison > 0) {
-        result = 1;
-    }
-
-    return result;
-}
-
-PARCAtomicUint32 *
-parcAtomicUint32_Copy(const PARCAtomicUint32 *original)
-{
-    PARCAtomicUint32 *result = parcAtomicUint32_Create(parcAtomicUint32_GetValue(original));
-
-    return result;
-}
-
-bool
-parcAtomicUint32_Equals(const PARCAtomicUint32 *x, const PARCAtomicUint32 *y)
-{
-    bool result = false;
-
-    result = parcAtomicUint32_GetValue(x) == parcAtomicUint32_GetValue(y);
-
-    return result;
-}
-
-PARCHashCode
-parcAtomicUint32_HashCode(const PARCAtomicUint32 *instance)
-{
-    PARCHashCode result = (PARCHashCode) parcAtomicUint32_GetValue(instance);
-
-    return result;
-}
-
-bool
-parcAtomicUint32_IsValid(const PARCAtomicUint32 *instance)
-{
-    bool result = false;
-
-    if (instance != NULL) {
-        result = true;
-    }
-
-    return result;
-}
-
-uint32_t
-parcAtomicUint32_GetValue(const PARCAtomicUint32 *instance)
-{
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    return instance->value;
-#else
-    return *instance;
-#endif
-}
-
-uint32_t
-parcAtomicUint32_AddImpl(PARCAtomicUint32 *value, uint32_t addend)
-{
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    pthread_mutex_lock(&value->mutex);
-    value->value += addend;
-    uint32_t result = value->value;
-    pthread_mutex_unlock(&value->mutex);
-    return result;
-#else
-    return __sync_add_and_fetch(value, addend);
-#endif
-}
-
-uint32_t
-parcAtomicUint32_SubtractImpl(PARCAtomicUint32 *value, uint32_t subtrahend)
-{
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    pthread_mutex_lock(&value->mutex);
-    value->value -= subtrahend;
-    uint32_t result = value->value;
-    pthread_mutex_unlock(&value->mutex);
-    return result;
-#else
-    return __sync_sub_and_fetch(value, subtrahend);
-#endif
-}
-
-bool
-parcAtomicUint32_CompareAndSwapImpl(PARCAtomicUint32 *value, uint32_t predicate, uint32_t newValue)
-{
-    bool result = false;
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    pthread_mutex_lock(&value->mutex);
-    if (value->value == predicate) {
-        value->value = newValue;
-        result = true;
-    }
-    pthread_mutex_unlock(&value->mutex);
-    return result;
-#else
-    result = __sync_bool_compare_and_swap(value, predicate, newValue);
-#endif
-    return result;
-}
diff --git a/libparc/parc/concurrent/parc_AtomicUint32.h b/libparc/parc/concurrent/parc_AtomicUint32.h
deleted file mode 100755
index 870cbe80..00000000
--- a/libparc/parc/concurrent/parc_AtomicUint32.h
+++ /dev/null
@@ -1,341 +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 parc_AtomicUint32.h
- * @ingroup threading
- * @brief An atomically updated 32-bit unsigned integer.
- *
- * <#Detailed Description#>
- *
- */
-#ifndef PARCLibrary_parc_AtomicUint32
-#define PARCLibrary_parc_AtomicUint32
-#include <stdbool.h>
-#include <stdint.h>
-
-#include <parc/algol/parc_JSON.h>
-
-#ifdef PARCLibrary_DISABLE_ATOMICS
-#include <pthread.h>
-struct PARCAtomicUint32;
-typedef struct PARCAtomicUint32 PARCAtomicUint32;
-#else
-typedef uint32_t PARCAtomicUint32;
-#endif
-
-
-PARCAtomicUint32 *parcAtomicInteger_CreateUint32(uint32_t value);
-
-uint32_t parcAtomicUint32_AddImpl(PARCAtomicUint32 *value, uint32_t addend);
-
-uint32_t parcAtomicUint32_SubtractImpl(PARCAtomicUint32 *value, uint32_t subtrahend);
-
-bool parcAtomicUint32_CompareAndSwapImpl(PARCAtomicUint32 *value, uint32_t predicate, uint32_t newValue);
-
-#ifdef PARCLibrary_DISABLE_ATOMICS
-
-#define parcAtomicUint32_Add                parcAtomicUint32_AddImpl
-
-#define parcAtomicUint32_Subtract           parcAtomicUint32_SubtractImpl
-
-#define parcAtomicUint32_CompareAndSwap     parcAtomicUint32_CompareAndSwapImpl
-
-#else
-
-#define parcAtomicUint32_Add(_atomic_uint32_, _addend_) \
-    __sync_add_and_fetch(_atomic_uint32_, _addend_)
-
-#define parcAtomicUint32_Subtract(_atomic_uint32_, _subtrahend_) \
-    __sync_sub_and_fetch(_atomic_uint32_, _subtrahend_)
-
-#define parcAtomicUint32_CompareAndSwap(_atomic_uint32_, _predicate_, _newValue_) \
-    __sync_bool_compare_and_swap(_atomic_uint32_, _predicate_, _newValue_)
-#endif
-
-#define parcAtomicUint32_Increment(_atomic_uint32_) parcAtomicUint32_Add(_atomic_uint32_, 1)
-#define parcAtomicUint32_Decrement(_atomic_uint32_) parcAtomicUint32_Subtract(_atomic_uint32_, 1)
-
-/**
- * Increase the number of references to a `PARCAtomicUint32` instance.
- *
- * Note that new `PARCAtomicUint32` is not created,
- * only that the given `PARCAtomicUint32` reference count is incremented.
- * Discard the reference by invoking `parcAtomicUint32_Release`.
- *
- * @param [in] instance A pointer to a valid PARCAtomicUint32 instance.
- *
- * @return The same value as @p instance.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint32 *a = parcAtomicUint32_Create();
- *
- *     PARCAtomicUint32 *b = parcAtomicUint32_Acquire();
- *
- *     parcAtomicUint32_Release(&a);
- *     parcAtomicUint32_Release(&b);
- * }
- * @endcode
- */
-PARCAtomicUint32 *parcAtomicUint32_Acquire(const PARCAtomicUint32 *instance);
-
-#ifdef PARCLibrary_DISABLE_VALIDATION
-#  define parcAtomicUint32_OptionalAssertValid(_instance_)
-#else
-#  define parcAtomicUint32_OptionalAssertValid(_instance_) parcAtomicUint32_AssertValid(_instance_)
-#endif
-
-/**
- * Assert that the given `PARCAtomicUint32` instance is valid.
- *
- * @param [in] instance A pointer to a valid PARCAtomicUint32 instance.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint32 *a = parcAtomicUint32_Create();
- *
- *     parcAtomicUint32_AssertValid(a);
- *
- *     printf("Instance is valid.\n");
- *
- *     parcAtomicUint32_Release(&b);
- * }
- * @endcode
- */
-void parcAtomicUint32_AssertValid(const PARCAtomicUint32 *instance);
-
-/**
- * Create an instance of PARCAtomicUint32
- *
- * <#Paragraphs Of Explanation#>
- *
- * @return non-NULL A pointer to a valid PARCAtomicUint32 instance.
- * @return NULL An error occurred.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint32 *a = parcAtomicUint32_Create();
- *
- *     parcAtomicUint32_Release(&b);
- * }
- * @endcode
- */
-PARCAtomicUint32 *parcAtomicUint32_Create(uint32_t);
-
-/**
- * Compares @p instance with @p other for order.
- *
- * Returns a negative integer, zero, or a positive integer as @p instance
- * is less than, equal to, or greater than @p other.
- *
- * @param [in] instance A pointer to a valid PARCAtomicUint32 instance.
- * @param [in] other A pointer to a valid PARCAtomicUint32 instance.
- *
- * @return <0 Instance is less than @p other.
- * @return 0 Instance a and instance b compare the same.
- * @return >0 Instance a is greater than instance b.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint32 *a = parcAtomicUint32_Create();
- *     PARCAtomicUint32 *b = parcAtomicUint32_Create();
- *
- *     if (parcAtomicUint32_Compare(a, b) == 0) {
- *         printf("Instances are equal.\n");
- *     }
- *
- *     parcAtomicUint32_Release(&a);
- *     parcAtomicUint32_Release(&b);
- * }
- * @endcode
- *
- * @see parcAtomicUint32_Equals
- */
-int parcAtomicUint32_Compare(const PARCAtomicUint32 *instance, const PARCAtomicUint32 *other);
-
-/**
- * Create an independent copy the given `PARCBuffer`
- *
- * A new buffer is created as a complete copy of the original.
- *
- * @param [in] original A pointer to a valid PARCAtomicUint32 instance.
- *
- * @return NULL Memory could not be allocated.
- * @return non-NULL A pointer to a new `PARCAtomicUint32` instance.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint32 *a = parcAtomicUint32_Create();
- *
- *     PARCAtomicUint32 *copy = parcAtomicUint32_Copy(&b);
- *
- *     parcAtomicUint32_Release(&b);
- *     parcAtomicUint32_Release(&copy);
- * }
- * @endcode
- */
-PARCAtomicUint32 *parcAtomicUint32_Copy(const PARCAtomicUint32 *original);
-
-/**
- * Determine if two `PARCAtomicUint32` instances are equal.
- *
- * The following equivalence relations on non-null `PARCAtomicUint32` instances are maintained: *
- *   * It is reflexive: for any non-null reference value x, `parcAtomicUint32_Equals(x, x)` must return true.
- *
- *   * It is symmetric: for any non-null reference values x and y, `parcAtomicUint32_Equals(x, y)` must return true if and only if
- *        `parcAtomicUint32_Equals(y x)` returns true.
- *
- *   * It is transitive: for any non-null reference values x, y, and z, if
- *        `parcAtomicUint32_Equals(x, y)` returns true and
- *        `parcAtomicUint32_Equals(y, z)` returns true,
- *        then `parcAtomicUint32_Equals(x, z)` must return true.
- *
- *   * It is consistent: for any non-null reference values x and y, multiple invocations of `parcAtomicUint32_Equals(x, y)`
- *         consistently return true or consistently return false.
- *
- *   * For any non-null reference value x, `parcAtomicUint32_Equals(x, NULL)` must return false.
- *
- * @param [in] x A pointer to a valid PARCAtomicUint32 instance.
- * @param [in] y A pointer to a valid PARCAtomicUint32 instance.
- *
- * @return true The instances x and y are equal.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint32 *a = parcAtomicUint32_Create();
- *     PARCAtomicUint32 *b = parcAtomicUint32_Create();
- *
- *     if (parcAtomicUint32_Equals(a, b)) {
- *         printf("Instances are equal.\n");
- *     }
- *
- *     parcAtomicUint32_Release(&a);
- *     parcAtomicUint32_Release(&b);
- * }
- * @endcode
- * @see parcAtomicUint32_HashCode
- */
-bool parcAtomicUint32_Equals(const PARCAtomicUint32 *x, const PARCAtomicUint32 *y);
-
-/**
- * Returns a hash code value for the given instance.
- *
- * The general contract of `HashCode` is:
- *
- * Whenever it is invoked on the same instance more than once during an execution of an application,
- * the `HashCode` function must consistently return the same value,
- * provided no information used in a corresponding comparisons on the instance is modified.
- *
- * This value need not remain consistent from one execution of an application to another execution of the same application.
- * If two instances are equal according to the {@link parcAtomicUint32_Equals} method,
- * then calling the {@link parcAtomicUint32_HashCode} method on each of the two instances must produce the same integer result.
- *
- * It is not required that if two instances are unequal according to the
- * {@link parcAtomicUint32_Equals} function,
- * then calling the `parcAtomicUint32_HashCode`
- * method on each of the two objects must produce distinct integer results.
- *
- * @param [in] instance A pointer to a valid PARCAtomicUint32 instance.
- *
- * @return The hashcode for the given instance.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint32 *a = parcAtomicUint32_Create();
- *
- *     PARCHashCode hashValue = parcAtomicUint32_HashCode(buffer);
- *     parcAtomicUint32_Release(&a);
- * }
- * @endcode
- */
-PARCHashCode parcAtomicUint32_HashCode(const PARCAtomicUint32 *instance);
-
-/**
- * Determine if an instance of `PARCAtomicUint32` is valid.
- *
- * Valid means the internal state of the type is consistent with its required current or future behaviour.
- * This may include the validation of internal instances of types.
- *
- * @param [in] instance A pointer to a valid PARCAtomicUint32 instance.
- *
- * @return true The instance is valid.
- * @return false The instance is not valid.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint32 *a = parcAtomicUint32_Create();
- *
- *     if (parcAtomicUint32_IsValid(a)) {
- *         printf("Instance is valid.\n");
- *     }
- *
- *     parcAtomicUint32_Release(&b);
- * }
- * @endcode
- */
-bool parcAtomicUint32_IsValid(const PARCAtomicUint32 *instance);
-
-/**
- * Release a previously acquired reference to the given `PARCAtomicUint32` instance,
- * decrementing the reference count for the instance.
- *
- * The pointer to the instance is set to NULL as a side-effect of this function.
- *
- * If the invocation causes the last reference to the instance to be released,
- * the instance is deallocated and the instance's implementation will perform
- * additional cleanup and release other privately held references.
- *
- * @param [in,out] instancePtr A pointer to a pointer to the instance to release.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint32 *a = parcAtomicUint32_Create();
- *
- *     parcAtomicUint32_Release(&a);
- * }
- * @endcode
- */
-void parcAtomicUint32_Release(PARCAtomicUint32 **instancePtr);
-
-/**
- * Get the current value of the given `PARCAtomicUint32` instance.
- *
- * @param [in] instance A pointer to a valid `PARCAtomicUint32` instance.
- *
- * @return the current value of the given `PARCAtomicUint32` instance.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint32 *instance = parcAtomicUint32_Create(7);
- *
- *     uint32_t value = parcAtomicUint32_GetValue(instance);
- *
- *     parcAtomicUint32_Release(&instance);
- * }
- * @endcode
- */
-uint32_t parcAtomicUint32_GetValue(const PARCAtomicUint32 *instance);
-#endif
diff --git a/libparc/parc/concurrent/parc_AtomicUint64.c b/libparc/parc/concurrent/parc_AtomicUint64.c
deleted file mode 100755
index 326f39db..00000000
--- a/libparc/parc/concurrent/parc_AtomicUint64.c
+++ /dev/null
@@ -1,178 +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 <config.h>
-
-#include <parc/algol/parc_Object.h>
-#include <parc/algol/parc_DisplayIndented.h>
-
-#include <parc/concurrent/parc_AtomicUint64.h>
-
-struct PARCAtomicUint64 {
-    uint64_t value;
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    pthread_mutex_t mutex;
-#endif
-};
-
-static void
-_parcAtomicUint64_Finalize(PARCAtomicUint64 **instancePtr)
-{
-    parcAssertNotNull(instancePtr, "Parameter must be a non-null pointer to a PARCAtomicUint64 pointer.");
-
-    parcAtomicUint64_OptionalAssertValid((*instancePtr));
-
-    /* cleanup the instance fields here */
-}
-
-parcObject_ImplementAcquire(parcAtomicUint64, PARCAtomicUint64);
-
-parcObject_ImplementRelease(parcAtomicUint64, PARCAtomicUint64);
-
-parcObject_ExtendPARCObject(PARCAtomicUint64, _parcAtomicUint64_Finalize, parcAtomicUint64_Copy, NULL, parcAtomicUint64_Equals, parcAtomicUint64_Compare, parcAtomicUint64_HashCode, NULL);
-
-
-void
-parcAtomicUint64_AssertValid(const PARCAtomicUint64 *instance)
-{
-    parcAssertTrue(parcAtomicUint64_IsValid(instance),
-               "PARCAtomicUint64 is not valid.");
-}
-
-PARCAtomicUint64 *
-parcAtomicUint64_Create(uint64_t value)
-{
-    PARCAtomicUint64 *result = parcObject_CreateAndClearInstance(PARCAtomicUint64);
-
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    pthread_mutex_init(&result->mutex, NULL);
-    result->value = value;
-#else
-    *result = value;
-#endif
-
-    return result;
-}
-
-int
-parcAtomicUint64_Compare(const PARCAtomicUint64 *instance, const PARCAtomicUint64 *other)
-{
-    int64_t comparison = parcAtomicUint64_GetValue(instance) - parcAtomicUint64_GetValue(other);
-
-    int result = 0;
-    if (comparison < 0) {
-        result = -1;
-    } else if (comparison > 0) {
-        result = 1;
-    }
-
-    return result;
-}
-
-PARCAtomicUint64 *
-parcAtomicUint64_Copy(const PARCAtomicUint64 *original)
-{
-    PARCAtomicUint64 *result = parcAtomicUint64_Create(parcAtomicUint64_GetValue(original));
-
-    return result;
-}
-
-bool
-parcAtomicUint64_Equals(const PARCAtomicUint64 *x, const PARCAtomicUint64 *y)
-{
-    bool result = false;
-
-    result = parcAtomicUint64_GetValue(x) == parcAtomicUint64_GetValue(y);
-
-    return result;
-}
-
-PARCHashCode
-parcAtomicUint64_HashCode(const PARCAtomicUint64 *instance)
-{
-    PARCHashCode result = (PARCHashCode) parcAtomicUint64_GetValue(instance);
-
-    return result;
-}
-
-bool
-parcAtomicUint64_IsValid(const PARCAtomicUint64 *instance)
-{
-    bool result = false;
-
-    if (instance != NULL) {
-        result = true;
-    }
-
-    return result;
-}
-
-uint64_t
-parcAtomicUint64_GetValue(const PARCAtomicUint64 *instance)
-{
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    return instance->value;
-#else
-    return *instance;
-#endif
-}
-
-uint64_t
-parcAtomicUint64_AddImpl(PARCAtomicUint64 *value, uint64_t addend)
-{
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    pthread_mutex_lock(&value->mutex);
-    value->value += addend;
-    uint64_t result = value->value;
-    pthread_mutex_unlock(&value->mutex);
-    return result;
-#else
-    return __sync_add_and_fetch(value, addend);
-#endif
-}
-
-uint64_t
-parcAtomicUint64_SubtractImpl(PARCAtomicUint64 *value, uint64_t subtrahend)
-{
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    pthread_mutex_lock(&value->mutex);
-    value->value -= subtrahend;
-    uint64_t result = value->value;
-    pthread_mutex_unlock(&value->mutex);
-    return result;
-#else
-    return __sync_sub_and_fetch(value, subtrahend);
-#endif
-}
-
-bool
-parcAtomicUint64_CompareAndSwapImpl(PARCAtomicUint64 *value, uint64_t predicate, uint64_t newValue)
-{
-    bool result = false;
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    pthread_mutex_lock(&value->mutex);
-    if (value->value == predicate) {
-        value->value = newValue;
-        result = true;
-    }
-    pthread_mutex_unlock(&value->mutex);
-    return result;
-#else
-    result = __sync_bool_compare_and_swap(value, predicate, newValue);
-#endif
-    return result;
-}
diff --git a/libparc/parc/concurrent/parc_AtomicUint64.h b/libparc/parc/concurrent/parc_AtomicUint64.h
deleted file mode 100755
index a6ac3ec1..00000000
--- a/libparc/parc/concurrent/parc_AtomicUint64.h
+++ /dev/null
@@ -1,341 +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 parc_AtomicUint64.h
- * @ingroup threading
- * @brief An atomically updated 64-bit unsigned integer.
- *
- * <#Detailed Description#>
- *
- */
-#ifndef PARCLibrary_parc_AtomicUint64
-#define PARCLibrary_parc_AtomicUint64
-#include <stdbool.h>
-#include <stdint.h>
-
-#include <parc/algol/parc_JSON.h>
-
-#ifdef PARCLibrary_DISABLE_ATOMICS
-#include <pthread.h>
-struct PARCAtomicUint64;
-typedef struct PARCAtomicUint64 PARCAtomicUint64;
-#else
-typedef uint64_t PARCAtomicUint64;
-#endif
-
-
-PARCAtomicUint64 *parcAtomicInteger_CreateUint64(uint64_t value);
-
-uint64_t parcAtomicUint64_AddImpl(PARCAtomicUint64 *value, uint64_t addend);
-
-uint64_t parcAtomicUint64_SubtractImpl(PARCAtomicUint64 *value, uint64_t subtrahend);
-
-bool parcAtomicUint64_CompareAndSwapImpl(PARCAtomicUint64 *value, uint64_t predicate, uint64_t newValue);
-
-#ifdef PARCLibrary_DISABLE_ATOMICS
-
-#define parcAtomicUint64_Add                parcAtomicUint64_AddImpl
-
-#define parcAtomicUint64_Subtract           parcAtomicUint64_SubtractImpl
-
-#define parcAtomicUint64_CompareAndSwap     parcAtomicUint64_CompareAndSwapImpl
-
-#else
-
-#define parcAtomicUint64_Add(_atomic_uint64_, _addend_) \
-    __sync_add_and_fetch(_atomic_uint64_, _addend_)
-
-#define parcAtomicUint64_Subtract(_atomic_uint64_, _subtrahend_) \
-    __sync_sub_and_fetch(_atomic_uint64_, _subtrahend_)
-
-#define parcAtomicUint64_CompareAndSwap(_atomic_uint64_, _predicate_, _newValue_) \
-    __sync_bool_compare_and_swap(_atomic_uint64_, _predicate_, _newValue_)
-#endif
-
-#define parcAtomicUint64_Increment(_atomic_uint64_) parcAtomicUint64_Add(_atomic_uint64_, 1)
-#define parcAtomicUint64_Decrement(_atomic_uint64_) parcAtomicUint64_Subtract(_atomic_uint64_, 1)
-
-/**
- * Increase the number of references to a `PARCAtomicUint64` instance.
- *
- * Note that new `PARCAtomicUint64` is not created,
- * only that the given `PARCAtomicUint64` reference count is incremented.
- * Discard the reference by invoking `parcAtomicUint64_Release`.
- *
- * @param [in] instance A pointer to a valid PARCAtomicUint64 instance.
- *
- * @return The same value as @p instance.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint64 *a = parcAtomicUint64_Create();
- *
- *     PARCAtomicUint64 *b = parcAtomicUint64_Acquire();
- *
- *     parcAtomicUint64_Release(&a);
- *     parcAtomicUint64_Release(&b);
- * }
- * @endcode
- */
-PARCAtomicUint64 *parcAtomicUint64_Acquire(const PARCAtomicUint64 *instance);
-
-#ifdef PARCLibrary_DISABLE_VALIDATION
-#  define parcAtomicUint64_OptionalAssertValid(_instance_)
-#else
-#  define parcAtomicUint64_OptionalAssertValid(_instance_) parcAtomicUint64_AssertValid(_instance_)
-#endif
-
-/**
- * Assert that the given `PARCAtomicUint64` instance is valid.
- *
- * @param [in] instance A pointer to a valid PARCAtomicUint64 instance.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint64 *a = parcAtomicUint64_Create();
- *
- *     parcAtomicUint64_AssertValid(a);
- *
- *     printf("Instance is valid.\n");
- *
- *     parcAtomicUint64_Release(&b);
- * }
- * @endcode
- */
-void parcAtomicUint64_AssertValid(const PARCAtomicUint64 *instance);
-
-/**
- * Create an instance of PARCAtomicUint64
- *
- * <#Paragraphs Of Explanation#>
- *
- * @return non-NULL A pointer to a valid PARCAtomicUint64 instance.
- * @return NULL An error occurred.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint64 *a = parcAtomicUint64_Create();
- *
- *     parcAtomicUint64_Release(&b);
- * }
- * @endcode
- */
-PARCAtomicUint64 *parcAtomicUint64_Create(uint64_t);
-
-/**
- * Compares @p instance with @p other for order.
- *
- * Returns a negative integer, zero, or a positive integer as @p instance
- * is less than, equal to, or greater than @p other.
- *
- * @param [in] instance A pointer to a valid PARCAtomicUint64 instance.
- * @param [in] other A pointer to a valid PARCAtomicUint64 instance.
- *
- * @return <0 Instance is less than @p other.
- * @return 0 Instance a and instance b compare the same.
- * @return >0 Instance a is greater than instance b.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint64 *a = parcAtomicUint64_Create();
- *     PARCAtomicUint64 *b = parcAtomicUint64_Create();
- *
- *     if (parcAtomicUint64_Compare(a, b) == 0) {
- *         printf("Instances are equal.\n");
- *     }
- *
- *     parcAtomicUint64_Release(&a);
- *     parcAtomicUint64_Release(&b);
- * }
- * @endcode
- *
- * @see parcAtomicUint64_Equals
- */
-int parcAtomicUint64_Compare(const PARCAtomicUint64 *instance, const PARCAtomicUint64 *other);
-
-/**
- * Create an independent copy the given `PARCBuffer`
- *
- * A new buffer is created as a complete copy of the original.
- *
- * @param [in] original A pointer to a valid PARCAtomicUint64 instance.
- *
- * @return NULL Memory could not be allocated.
- * @return non-NULL A pointer to a new `PARCAtomicUint64` instance.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint64 *a = parcAtomicUint64_Create();
- *
- *     PARCAtomicUint64 *copy = parcAtomicUint64_Copy(&b);
- *
- *     parcAtomicUint64_Release(&b);
- *     parcAtomicUint64_Release(&copy);
- * }
- * @endcode
- */
-PARCAtomicUint64 *parcAtomicUint64_Copy(const PARCAtomicUint64 *original);
-
-/**
- * Determine if two `PARCAtomicUint64` instances are equal.
- *
- * The following equivalence relations on non-null `PARCAtomicUint64` instances are maintained: *
- *   * It is reflexive: for any non-null reference value x, `parcAtomicUint64_Equals(x, x)` must return true.
- *
- *   * It is symmetric: for any non-null reference values x and y, `parcAtomicUint64_Equals(x, y)` must return true if and only if
- *        `parcAtomicUint64_Equals(y x)` returns true.
- *
- *   * It is transitive: for any non-null reference values x, y, and z, if
- *        `parcAtomicUint64_Equals(x, y)` returns true and
- *        `parcAtomicUint64_Equals(y, z)` returns true,
- *        then `parcAtomicUint64_Equals(x, z)` must return true.
- *
- *   * It is consistent: for any non-null reference values x and y, multiple invocations of `parcAtomicUint64_Equals(x, y)`
- *         consistently return true or consistently return false.
- *
- *   * For any non-null reference value x, `parcAtomicUint64_Equals(x, NULL)` must return false.
- *
- * @param [in] x A pointer to a valid PARCAtomicUint64 instance.
- * @param [in] y A pointer to a valid PARCAtomicUint64 instance.
- *
- * @return true The instances x and y are equal.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint64 *a = parcAtomicUint64_Create();
- *     PARCAtomicUint64 *b = parcAtomicUint64_Create();
- *
- *     if (parcAtomicUint64_Equals(a, b)) {
- *         printf("Instances are equal.\n");
- *     }
- *
- *     parcAtomicUint64_Release(&a);
- *     parcAtomicUint64_Release(&b);
- * }
- * @endcode
- * @see parcAtomicUint64_HashCode
- */
-bool parcAtomicUint64_Equals(const PARCAtomicUint64 *x, const PARCAtomicUint64 *y);
-
-/**
- * Returns a hash code value for the given instance.
- *
- * The general contract of `HashCode` is:
- *
- * Whenever it is invoked on the same instance more than once during an execution of an application,
- * the `HashCode` function must consistently return the same value,
- * provided no information used in a corresponding comparisons on the instance is modified.
- *
- * This value need not remain consistent from one execution of an application to another execution of the same application.
- * If two instances are equal according to the {@link parcAtomicUint64_Equals} method,
- * then calling the {@link parcAtomicUint64_HashCode} method on each of the two instances must produce the same integer result.
- *
- * It is not required that if two instances are unequal according to the
- * {@link parcAtomicUint64_Equals} function,
- * then calling the `parcAtomicUint64_HashCode`
- * method on each of the two objects must produce distinct integer results.
- *
- * @param [in] instance A pointer to a valid PARCAtomicUint64 instance.
- *
- * @return The hashcode for the given instance.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint64 *a = parcAtomicUint64_Create();
- *
- *     PARCHashCode hashValue = parcAtomicUint64_HashCode(buffer);
- *     parcAtomicUint64_Release(&a);
- * }
- * @endcode
- */
-PARCHashCode parcAtomicUint64_HashCode(const PARCAtomicUint64 *instance);
-
-/**
- * Determine if an instance of `PARCAtomicUint64` is valid.
- *
- * Valid means the internal state of the type is consistent with its required current or future behaviour.
- * This may include the validation of internal instances of types.
- *
- * @param [in] instance A pointer to a valid PARCAtomicUint64 instance.
- *
- * @return true The instance is valid.
- * @return false The instance is not valid.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint64 *a = parcAtomicUint64_Create();
- *
- *     if (parcAtomicUint64_IsValid(a)) {
- *         printf("Instance is valid.\n");
- *     }
- *
- *     parcAtomicUint64_Release(&b);
- * }
- * @endcode
- */
-bool parcAtomicUint64_IsValid(const PARCAtomicUint64 *instance);
-
-/**
- * Release a previously acquired reference to the given `PARCAtomicUint64` instance,
- * decrementing the reference count for the instance.
- *
- * The pointer to the instance is set to NULL as a side-effect of this function.
- *
- * If the invocation causes the last reference to the instance to be released,
- * the instance is deallocated and the instance's implementation will perform
- * additional cleanup and release other privately held references.
- *
- * @param [in,out] instancePtr A pointer to a pointer to the instance to release.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint64 *a = parcAtomicUint64_Create();
- *
- *     parcAtomicUint64_Release(&a);
- * }
- * @endcode
- */
-void parcAtomicUint64_Release(PARCAtomicUint64 **instancePtr);
-
-/**
- * Get the current value of the given `PARCAtomicUint64` instance.
- *
- * @param [in] instance A pointer to a valid `PARCAtomicUint64` instance.
- *
- * @return the current value of the given `PARCAtomicUint64` instance.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint64 *instance = parcAtomicUint64_Create(7);
- *
- *     uint64_t value = parcAtomicUint64_GetValue(instance);
- *
- *     parcAtomicUint64_Release(&instance);
- * }
- * @endcode
- */
-uint64_t parcAtomicUint64_GetValue(const PARCAtomicUint64 *instance);
-#endif
diff --git a/libparc/parc/concurrent/parc_AtomicUint8.c b/libparc/parc/concurrent/parc_AtomicUint8.c
deleted file mode 100755
index fd34258b..00000000
--- a/libparc/parc/concurrent/parc_AtomicUint8.c
+++ /dev/null
@@ -1,178 +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 <config.h>
-
-#include <parc/algol/parc_Object.h>
-#include <parc/algol/parc_DisplayIndented.h>
-
-#include <parc/concurrent/parc_AtomicUint8.h>
-
-struct PARCAtomicUint8 {
-    uint8_t value;
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    pthread_mutex_t mutex;
-#endif
-};
-
-static void
-_parcAtomicUint8_Finalize(PARCAtomicUint8 **instancePtr)
-{
-    parcAssertNotNull(instancePtr, "Parameter must be a non-null pointer to a PARCAtomicUint8 pointer.");
-
-    parcAtomicUint8_OptionalAssertValid((*instancePtr));
-
-    /* cleanup the instance fields here */
-}
-
-parcObject_ImplementAcquire(parcAtomicUint8, PARCAtomicUint8);
-
-parcObject_ImplementRelease(parcAtomicUint8, PARCAtomicUint8);
-
-parcObject_ExtendPARCObject(PARCAtomicUint8, _parcAtomicUint8_Finalize, parcAtomicUint8_Copy, NULL, parcAtomicUint8_Equals, parcAtomicUint8_Compare, parcAtomicUint8_HashCode, NULL);
-
-
-void
-parcAtomicUint8_AssertValid(const PARCAtomicUint8 *instance)
-{
-    parcAssertTrue(parcAtomicUint8_IsValid(instance),
-               "PARCAtomicUint8 is not valid.");
-}
-
-PARCAtomicUint8 *
-parcAtomicUint8_Create(uint8_t value)
-{
-    PARCAtomicUint8 *result = parcObject_CreateAndClearInstance(PARCAtomicUint8);
-
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    pthread_mutex_init(&result->mutex, NULL);
-    result->value = value;
-#else
-    *result = value;
-#endif
-
-    return result;
-}
-
-int
-parcAtomicUint8_Compare(const PARCAtomicUint8 *instance, const PARCAtomicUint8 *other)
-{
-    int8_t comparison = parcAtomicUint8_GetValue(instance) - parcAtomicUint8_GetValue(other);
-
-    int result = 0;
-    if (comparison < 0) {
-        result = -1;
-    } else if (comparison > 0) {
-        result = 1;
-    }
-
-    return result;
-}
-
-PARCAtomicUint8 *
-parcAtomicUint8_Copy(const PARCAtomicUint8 *original)
-{
-    PARCAtomicUint8 *result = parcAtomicUint8_Create(parcAtomicUint8_GetValue(original));
-
-    return result;
-}
-
-bool
-parcAtomicUint8_Equals(const PARCAtomicUint8 *x, const PARCAtomicUint8 *y)
-{
-    bool result = false;
-
-    result = parcAtomicUint8_GetValue(x) == parcAtomicUint8_GetValue(y);
-
-    return result;
-}
-
-PARCHashCode
-parcAtomicUint8_HashCode(const PARCAtomicUint8 *instance)
-{
-    PARCHashCode result = (uint32_t) parcAtomicUint8_GetValue(instance);
-
-    return result;
-}
-
-bool
-parcAtomicUint8_IsValid(const PARCAtomicUint8 *instance)
-{
-    bool result = false;
-
-    if (instance != NULL) {
-        result = true;
-    }
-
-    return result;
-}
-
-uint8_t
-parcAtomicUint8_GetValue(const PARCAtomicUint8 *instance)
-{
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    return instance->value;
-#else
-    return *instance;
-#endif
-}
-
-uint8_t
-parcAtomicUint8_AddImpl(PARCAtomicUint8 *value, uint8_t addend)
-{
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    pthread_mutex_lock(&value->mutex);
-    value->value += addend;
-    uint8_t result = value->value;
-    pthread_mutex_unlock(&value->mutex);
-    return result;
-#else
-    return __sync_add_and_fetch(value, addend);
-#endif
-}
-
-uint8_t
-parcAtomicUint8_SubtractImpl(PARCAtomicUint8 *value, uint8_t subtrahend)
-{
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    pthread_mutex_lock(&value->mutex);
-    value->value -= subtrahend;
-    uint8_t result = value->value;
-    pthread_mutex_unlock(&value->mutex);
-    return result;
-#else
-    return __sync_sub_and_fetch(value, subtrahend);
-#endif
-}
-
-bool
-parcAtomicUint8_CompareAndSwapImpl(PARCAtomicUint8 *value, uint8_t predicate, uint8_t newValue)
-{
-    bool result = false;
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    pthread_mutex_lock(&value->mutex);
-    if (value->value == predicate) {
-        value->value = newValue;
-        result = true;
-    }
-    pthread_mutex_unlock(&value->mutex);
-    return result;
-#else
-    result = __sync_bool_compare_and_swap(value, predicate, newValue);
-#endif
-    return result;
-}
diff --git a/libparc/parc/concurrent/parc_AtomicUint8.h b/libparc/parc/concurrent/parc_AtomicUint8.h
deleted file mode 100755
index 7434b93d..00000000
--- a/libparc/parc/concurrent/parc_AtomicUint8.h
+++ /dev/null
@@ -1,341 +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 parc_AtomicUint8.h
- * @ingroup threading
- * @brief An atomically updated 8-bit unsigned integer.
- *
- * <#Detailed Description#>
- *
- */
-#ifndef PARCLibrary_parc_AtomicUint8
-#define PARCLibrary_parc_AtomicUint8
-#include <stdbool.h>
-#include <stdint.h>
-
-#include <parc/algol/parc_JSON.h>
-
-#ifdef PARCLibrary_DISABLE_ATOMICS
-#include <pthread.h>
-struct PARCAtomicUint8;
-typedef struct PARCAtomicUint8 PARCAtomicUint8;
-#else
-typedef uint8_t PARCAtomicUint8;
-#endif
-
-
-PARCAtomicUint8 *parcAtomicInteger_CreateUint8(uint8_t value);
-
-uint8_t parcAtomicUint8_AddImpl(PARCAtomicUint8 *value, uint8_t addend);
-
-uint8_t parcAtomicUint8_SubtractImpl(PARCAtomicUint8 *value, uint8_t subtrahend);
-
-bool parcAtomicUint8_CompareAndSwapImpl(PARCAtomicUint8 *value, uint8_t predicate, uint8_t newValue);
-
-#ifdef PARCLibrary_DISABLE_ATOMICS
-
-#define parcAtomicUint8_Add                parcAtomicUint8_AddImpl
-
-#define parcAtomicUint8_Subtract           parcAtomicUint8_SubtractImpl
-
-#define parcAtomicUint8_CompareAndSwap     parcAtomicUint8_CompareAndSwapImpl
-
-#else
-
-#define parcAtomicUint8_Add(_atomic_uint8_, _addend_) \
-    __sync_add_and_fetch(_atomic_uint8_, _addend_)
-
-#define parcAtomicUint8_Subtract(_atomic_uint8_, _subtrahend_) \
-    __sync_sub_and_fetch(_atomic_uint8_, _subtrahend_)
-
-#define parcAtomicUint8_CompareAndSwap(_atomic_uint8_, _predicate_, _newValue_) \
-    __sync_bool_compare_and_swap(_atomic_uint8_, _predicate_, _newValue_)
-#endif
-
-#define parcAtomicUint8_Increment(_atomic_uint8_) parcAtomicUint8_Add(_atomic_uint8_, 1)
-#define parcAtomicUint8_Decrement(_atomic_uint8_) parcAtomicUint8_Subtract(_atomic_uint8_, 1)
-
-/**
- * Increase the number of references to a `PARCAtomicUint8` instance.
- *
- * Note that new `PARCAtomicUint8` is not created,
- * only that the given `PARCAtomicUint8` reference count is incremented.
- * Discard the reference by invoking `parcAtomicUint8_Release`.
- *
- * @param [in] instance A pointer to a valid PARCAtomicUint8 instance.
- *
- * @return The same value as @p instance.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint8 *a = parcAtomicUint8_Create();
- *
- *     PARCAtomicUint8 *b = parcAtomicUint8_Acquire();
- *
- *     parcAtomicUint8_Release(&a);
- *     parcAtomicUint8_Release(&b);
- * }
- * @endcode
- */
-PARCAtomicUint8 *parcAtomicUint8_Acquire(const PARCAtomicUint8 *instance);
-
-#ifdef PARCLibrary_DISABLE_VALIDATION
-#  define parcAtomicUint8_OptionalAssertValid(_instance_)
-#else
-#  define parcAtomicUint8_OptionalAssertValid(_instance_) parcAtomicUint8_AssertValid(_instance_)
-#endif
-
-/**
- * Assert that the given `PARCAtomicUint8` instance is valid.
- *
- * @param [in] instance A pointer to a valid PARCAtomicUint8 instance.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint8 *a = parcAtomicUint8_Create();
- *
- *     parcAtomicUint8_AssertValid(a);
- *
- *     printf("Instance is valid.\n");
- *
- *     parcAtomicUint8_Release(&b);
- * }
- * @endcode
- */
-void parcAtomicUint8_AssertValid(const PARCAtomicUint8 *instance);
-
-/**
- * Create an instance of PARCAtomicUint8
- *
- * <#Paragraphs Of Explanation#>
- *
- * @return non-NULL A pointer to a valid PARCAtomicUint8 instance.
- * @return NULL An error occurred.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint8 *a = parcAtomicUint8_Create();
- *
- *     parcAtomicUint8_Release(&b);
- * }
- * @endcode
- */
-PARCAtomicUint8 *parcAtomicUint8_Create(uint8_t);
-
-/**
- * Compares @p instance with @p other for order.
- *
- * Returns a negative integer, zero, or a positive integer as @p instance
- * is less than, equal to, or greater than @p other.
- *
- * @param [in] instance A pointer to a valid PARCAtomicUint8 instance.
- * @param [in] other A pointer to a valid PARCAtomicUint8 instance.
- *
- * @return <0 Instance is less than @p other.
- * @return 0 Instance a and instance b compare the same.
- * @return >0 Instance a is greater than instance b.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint8 *a = parcAtomicUint8_Create();
- *     PARCAtomicUint8 *b = parcAtomicUint8_Create();
- *
- *     if (parcAtomicUint8_Compare(a, b) == 0) {
- *         printf("Instances are equal.\n");
- *     }
- *
- *     parcAtomicUint8_Release(&a);
- *     parcAtomicUint8_Release(&b);
- * }
- * @endcode
- *
- * @see parcAtomicUint8_Equals
- */
-int parcAtomicUint8_Compare(const PARCAtomicUint8 *instance, const PARCAtomicUint8 *other);
-
-/**
- * Create an independent copy the given `PARCBuffer`
- *
- * A new buffer is created as a complete copy of the original.
- *
- * @param [in] original A pointer to a valid PARCAtomicUint8 instance.
- *
- * @return NULL Memory could not be allocated.
- * @return non-NULL A pointer to a new `PARCAtomicUint8` instance.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint8 *a = parcAtomicUint8_Create();
- *
- *     PARCAtomicUint8 *copy = parcAtomicUint8_Copy(&b);
- *
- *     parcAtomicUint8_Release(&b);
- *     parcAtomicUint8_Release(&copy);
- * }
- * @endcode
- */
-PARCAtomicUint8 *parcAtomicUint8_Copy(const PARCAtomicUint8 *original);
-
-/**
- * Determine if two `PARCAtomicUint8` instances are equal.
- *
- * The following equivalence relations on non-null `PARCAtomicUint8` instances are maintained: *
- *   * It is reflexive: for any non-null reference value x, `parcAtomicUint8_Equals(x, x)` must return true.
- *
- *   * It is symmetric: for any non-null reference values x and y, `parcAtomicUint8_Equals(x, y)` must return true if and only if
- *        `parcAtomicUint8_Equals(y x)` returns true.
- *
- *   * It is transitive: for any non-null reference values x, y, and z, if
- *        `parcAtomicUint8_Equals(x, y)` returns true and
- *        `parcAtomicUint8_Equals(y, z)` returns true,
- *        then `parcAtomicUint8_Equals(x, z)` must return true.
- *
- *   * It is consistent: for any non-null reference values x and y, multiple invocations of `parcAtomicUint8_Equals(x, y)`
- *         consistently return true or consistently return false.
- *
- *   * For any non-null reference value x, `parcAtomicUint8_Equals(x, NULL)` must return false.
- *
- * @param [in] x A pointer to a valid PARCAtomicUint8 instance.
- * @param [in] y A pointer to a valid PARCAtomicUint8 instance.
- *
- * @return true The instances x and y are equal.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint8 *a = parcAtomicUint8_Create();
- *     PARCAtomicUint8 *b = parcAtomicUint8_Create();
- *
- *     if (parcAtomicUint8_Equals(a, b)) {
- *         printf("Instances are equal.\n");
- *     }
- *
- *     parcAtomicUint8_Release(&a);
- *     parcAtomicUint8_Release(&b);
- * }
- * @endcode
- * @see parcAtomicUint8_HashCode
- */
-bool parcAtomicUint8_Equals(const PARCAtomicUint8 *x, const PARCAtomicUint8 *y);
-
-/**
- * Returns a hash code value for the given instance.
- *
- * The general contract of `HashCode` is:
- *
- * Whenever it is invoked on the same instance more than once during an execution of an application,
- * the `HashCode` function must consistently return the same value,
- * provided no information used in a corresponding comparisons on the instance is modified.
- *
- * This value need not remain consistent from one execution of an application to another execution of the same application.
- * If two instances are equal according to the {@link parcAtomicUint8_Equals} method,
- * then calling the {@link parcAtomicUint8_HashCode} method on each of the two instances must produce the same integer result.
- *
- * It is not required that if two instances are unequal according to the
- * {@link parcAtomicUint8_Equals} function,
- * then calling the `parcAtomicUint8_HashCode`
- * method on each of the two objects must produce distinct integer results.
- *
- * @param [in] instance A pointer to a valid PARCAtomicUint8 instance.
- *
- * @return The hashcode for the given instance.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint8 *a = parcAtomicUint8_Create();
- *
- *     PARCHashCode hashValue = parcAtomicUint8_HashCode(buffer);
- *     parcAtomicUint8_Release(&a);
- * }
- * @endcode
- */
-PARCHashCode parcAtomicUint8_HashCode(const PARCAtomicUint8 *instance);
-
-/**
- * Determine if an instance of `PARCAtomicUint8` is valid.
- *
- * Valid means the internal state of the type is consistent with its required current or future behaviour.
- * This may include the validation of internal instances of types.
- *
- * @param [in] instance A pointer to a valid PARCAtomicUint8 instance.
- *
- * @return true The instance is valid.
- * @return false The instance is not valid.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint8 *a = parcAtomicUint8_Create();
- *
- *     if (parcAtomicUint8_IsValid(a)) {
- *         printf("Instance is valid.\n");
- *     }
- *
- *     parcAtomicUint8_Release(&b);
- * }
- * @endcode
- */
-bool parcAtomicUint8_IsValid(const PARCAtomicUint8 *instance);
-
-/**
- * Release a previously acquired reference to the given `PARCAtomicUint8` instance,
- * decrementing the reference count for the instance.
- *
- * The pointer to the instance is set to NULL as a side-effect of this function.
- *
- * If the invocation causes the last reference to the instance to be released,
- * the instance is deallocated and the instance's implementation will perform
- * additional cleanup and release other privately held references.
- *
- * @param [in,out] instancePtr A pointer to a pointer to the instance to release.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint8 *a = parcAtomicUint8_Create();
- *
- *     parcAtomicUint8_Release(&a);
- * }
- * @endcode
- */
-void parcAtomicUint8_Release(PARCAtomicUint8 **instancePtr);
-
-/**
- * Get the current value of the given `PARCAtomicUint8` instance.
- *
- * @param [in] instance A pointer to a valid `PARCAtomicUint8` instance.
- *
- * @return the current value of the given `PARCAtomicUint8` instance.
- *
- * Example:
- * @code
- * {
- *     PARCAtomicUint8 *instance = parcAtomicUint8_Create(7);
- *
- *     uint8_t value = parcAtomicUint8_GetValue(instance);
- *
- *     parcAtomicUint8_Release(&instance);
- * }
- * @endcode
- */
-uint8_t parcAtomicUint8_GetValue(const PARCAtomicUint8 *instance);
-#endif
diff --git a/libparc/parc/concurrent/parc_FutureTask.c b/libparc/parc/concurrent/parc_FutureTask.c
deleted file mode 100755
index d323e0bd..00000000
--- a/libparc/parc/concurrent/parc_FutureTask.c
+++ /dev/null
@@ -1,304 +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 <config.h>
-#include <stdio.h>
-
-#include <parc/algol/parc_Object.h>
-#include <parc/algol/parc_DisplayIndented.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Execution.h>
-
-#include <parc/concurrent/parc_FutureTask.h>
-
-struct PARCFutureTask {
-    void *(*function)(PARCFutureTask *task, void *parameter);
-    void *parameter;
-    void *result;
-    bool isRunning;
-    bool isDone;
-    bool isCancelled;
-};
-
-static void
-_parcFutureTask_Initialise(PARCFutureTask *futureTask)
-{
-    futureTask->result = NULL;
-    futureTask->isDone = false;
-    futureTask->isCancelled = false;
-    futureTask->isRunning = false;
-}
-
-static bool
-_parcFutureTask_Destructor(PARCFutureTask **instancePtr)
-{
-    parcAssertNotNull(instancePtr, "Parameter must be a non-null pointer to a PARCFutureTask pointer.");
-    PARCFutureTask *task = *instancePtr;
-
-    if (parcObject_IsInstanceOf(task->parameter, &PARCObject_Descriptor)) {
-        parcObject_Release(&task->parameter);
-    }
-
-    return true;
-}
-
-parcObject_ImplementAcquire(parcFutureTask, PARCFutureTask);
-
-parcObject_ImplementRelease(parcFutureTask, PARCFutureTask);
-
-parcObject_Override(PARCFutureTask, PARCObject,
-                    .isLockable = true,
-                    .destructor = (PARCObjectDestructor *) _parcFutureTask_Destructor,
-                    .copy = (PARCObjectCopy *) parcFutureTask_Copy,
-                    .toString = (PARCObjectToString *) parcFutureTask_ToString,
-                    .equals = (PARCObjectEquals *) parcFutureTask_Equals,
-                    .compare = (PARCObjectCompare *) parcFutureTask_Compare,
-                    .hashCode = (PARCObjectHashCode *) parcFutureTask_HashCode,
-                    .display = (PARCObjectDisplay *) parcFutureTask_Display);
-
-void
-parcFutureTask_AssertValid(const PARCFutureTask *task)
-{
-    parcAssertTrue(parcFutureTask_IsValid(task),
-               "PARCFutureTask is not valid.");
-}
-
-PARCFutureTask *
-parcFutureTask_Create(void *(*function)(PARCFutureTask *task, void *parameter), void *parameter)
-{
-    PARCFutureTask *result = parcObject_CreateInstance(PARCFutureTask);
-
-    if (parcObject_IsInstanceOf(parameter, &PARCObject_Descriptor)) {
-        parameter = parcObject_Acquire(parameter);
-    }
-
-    if (result != NULL) {
-        result->function = function;
-        result->parameter = parameter;
-        _parcFutureTask_Initialise(result);
-    }
-
-    return result;
-}
-
-int
-parcFutureTask_Compare(const PARCFutureTask *instance, const PARCFutureTask *other)
-{
-    int result = 0;
-
-    return result;
-}
-
-PARCFutureTask *
-parcFutureTask_Copy(const PARCFutureTask *original)
-{
-    PARCFutureTask *result = parcFutureTask_Create(original->function, original->parameter);
-
-    return result;
-}
-
-void
-parcFutureTask_Display(const PARCFutureTask *instance, int indentation)
-{
-    parcDisplayIndented_PrintLine(indentation, "PARCFutureTask@%p {", instance);
-    /* Call Display() functions for the fields here. */
-    parcDisplayIndented_PrintLine(indentation, "}");
-}
-
-bool
-parcFutureTask_Equals(const PARCFutureTask *x, const PARCFutureTask *y)
-{
-    bool result = false;
-
-    if (x == y) {
-        result = true;
-    } else if (x == NULL || y == NULL) {
-        result = false;
-    } else {
-        if (x->function == y->function) {
-            if (x->parameter == y->parameter) {
-                result = true;
-            }
-        }
-    }
-
-    return result;
-}
-
-PARCHashCode
-parcFutureTask_HashCode(const PARCFutureTask *instance)
-{
-    PARCHashCode result = 0;
-
-    return result;
-}
-
-bool
-parcFutureTask_IsValid(const PARCFutureTask *instance)
-{
-    bool result = false;
-
-    if (instance != NULL) {
-        result = true;
-    }
-
-    return result;
-}
-
-PARCJSON *
-parcFutureTask_ToJSON(const PARCFutureTask *instance)
-{
-    PARCJSON *result = parcJSON_Create();
-
-    if (result != NULL) {
-    }
-
-    return result;
-}
-
-char *
-parcFutureTask_ToString(const PARCFutureTask *instance)
-{
-    char *result = parcMemory_Format("PARCFutureTask@%p\n", instance);
-
-    return result;
-}
-
-bool
-parcFutureTask_Cancel(PARCFutureTask *task, bool mayInterruptIfRunning)
-{
-    bool result = false;
-
-    if (parcObject_Lock(task)) {
-        if (task->isRunning) {
-            if (mayInterruptIfRunning) {
-                printf("Interrupting a running task is not implemented yet.\n");
-            }
-            result = false;
-        } else {
-            task->isCancelled = true;
-            task->isDone = true;
-            parcObject_Notify(task);
-            result = true;
-        }
-
-        parcObject_Unlock(task);
-    }
-
-    return result;
-}
-
-PARCFutureTaskResult
-parcFutureTask_Get(const PARCFutureTask *futureTask, const PARCTimeout *timeout)
-{
-    PARCFutureTaskResult result;
-
-    result.execution = PARCExecution_Timeout;
-    result.value = 0;
-
-    if (parcTimeout_IsImmediate(timeout)) {
-        if (futureTask->isDone) {
-            result.execution = PARCExecution_OK;
-            result.value = futureTask->result;
-        }
-    } else {
-        result.execution = PARCExecution_Interrupted;
-        result.value = 0;
-
-        parcObject_Lock(futureTask);
-        while (!futureTask->isDone) {
-            if (parcTimeout_IsNever(timeout)) {
-                parcObject_Wait(futureTask);
-                result.execution = PARCExecution_OK;
-                result.value = futureTask->result;
-                break;
-            } else {
-                if (parcObject_WaitFor(futureTask, parcTimeout_InNanoSeconds(timeout))) {
-                    result.execution = PARCExecution_OK;
-                    result.value = futureTask->result;
-                    break;
-                }
-            }
-        }
-        parcObject_Unlock(futureTask);
-    }
-
-    return result;
-}
-
-bool
-parcFutureTask_IsCancelled(const PARCFutureTask *task)
-{
-    return task->isCancelled;
-}
-
-bool
-parcFutureTask_IsDone(const PARCFutureTask *task)
-{
-    return task->isDone;
-}
-
-static void *
-_parcFutureTask_Execute(PARCFutureTask *task)
-{
-    task->isRunning = true;
-    void *result = task->function(task, task->parameter);
-    task->isRunning = false;
-
-    return result;
-}
-
-void *
-parcFutureTask_Run(PARCFutureTask *task)
-{
-    if (parcFutureTask_Lock(task)) {
-        if (!task->isCancelled) {
-            task->result = _parcFutureTask_Execute(task);
-            task->isDone = true;
-            parcFutureTask_Notify(task);
-        }
-        parcFutureTask_Unlock(task);
-    } else {
-        parcTrapCannotObtainLock("Cannot lock PARCFutureTask");
-    }
-    return task->result;
-}
-
-bool
-parcFutureTask_RunAndReset(PARCFutureTask *task)
-{
-    bool result = false;
-
-    if (parcObject_Lock(task)) {
-        if (!task->isCancelled) {
-            _parcFutureTask_Execute(task);
-            parcFutureTask_Reset(task);
-            result = true;
-        }
-        parcFutureTask_Unlock(task);
-    } else {
-        parcTrapCannotObtainLock("Cannot lock PARCFutureTask");
-    }
-
-    return result;
-}
-
-void
-parcFutureTask_Reset(PARCFutureTask *task)
-{
-    _parcFutureTask_Initialise(task);
-}
diff --git a/libparc/parc/concurrent/parc_FutureTask.h b/libparc/parc/concurrent/parc_FutureTask.h
deleted file mode 100755
index 9a5776c5..00000000
--- a/libparc/parc/concurrent/parc_FutureTask.h
+++ /dev/null
@@ -1,657 +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 parc_FutureTask.h
- * @ingroup threading
- * @brief An encapsulated, asynchronous computation.
- *
- * This type associates a function and a pointer to data and provides the functionality
- * to invoke the function supplying the given pointer to data and returning the result.
- *
- * The operations of invoking the function and collecting its return value may be asynchronous from each other
- * in that an attempting to fetch the return value before the function has been invoked
- * will cause the calling thread to block until the function has been invoked and run to completion.
- * This enables the use of PARCFutureTask in a work queue, or thread pool where tasks are run asynchronously
- * from each other and from an originating thread.
- *
- * Each instance of the type may be cancelled,
- * inhibiting a future invocation of the associated function.
- *
- * Typical use is a one time invocation of the associated function, induced by the `parcFutureTask_Get`,
- * but invoking `parcFutureTask_GetAndReset` invokes the associated function and resets the task to the initial state,
- * permitting a future call to `parcFutureTask_Get` or `parcFutureTask_GetAndReset` the run the associated function again.
- *
- */
-#ifndef PARCLibrary_parc_FutureTask
-#define PARCLibrary_parc_FutureTask
-#include <stdbool.h>
-#include <stdint.h>
-
-#include <parc/algol/parc_JSON.h>
-#include <parc/algol/parc_HashCode.h>
-#include <parc/concurrent/parc_Timeout.h>
-#include <parc/algol/parc_Execution.h>
-
-struct PARCFutureTask;
-typedef struct PARCFutureTask PARCFutureTask;
-
-typedef struct PARCFutureTaskResult {
-    void *value;
-    PARCExecution *execution;
-} PARCFutureTaskResult;
-
-/**
- * Increase the number of references to a `PARCFutureTask` instance.
- *
- * Note that new `PARCFutureTask` is not created,
- * only that the given `PARCFutureTask` reference count is incremented.
- * Discard the reference by invoking `parcFutureTask_Release`.
- *
- * @param [in] instance A pointer to a valid PARCFutureTask instance.
- *
- * @return The same value as @p instance.
- *
- * Example:
- * @code
- * {
- *     PARCFutureTask *a = parcFutureTask_Create();
- *
- *     PARCFutureTask *b = parcFutureTask_Acquire();
- *
- *     parcFutureTask_Release(&a);
- *     parcFutureTask_Release(&b);
- * }
- * @endcode
- */
-PARCFutureTask *parcFutureTask_Acquire(const PARCFutureTask *instance);
-
-#ifdef PARCLibrary_DISABLE_VALIDATION
-#  define parcFutureTask_OptionalAssertValid(_instance_)
-#else
-#  define parcFutureTask_OptionalAssertValid(_instance_) parcFutureTask_AssertValid(_instance_)
-#endif
-
-/**
- * Assert that the given `PARCFutureTask` instance is valid.
- *
- * @param [in] instance A pointer to a valid PARCFutureTask instance.
- *
- * Example:
- * @code
- * {
- *     PARCFutureTask *a = parcFutureTask_Create();
- *
- *     parcFutureTask_AssertValid(a);
- *
- *     printf("Instance is valid.\n");
- *
- *     parcFutureTask_Release(&b);
- * }
- * @endcode
- */
-void parcFutureTask_AssertValid(const PARCFutureTask *instance);
-
-/**
- * Create an instance of `PARCFutureTask`
- *
- * If the parameter is an instance of `PARCObject` a reference to the object will
- * be created and ultimately released via `parcFutureTask_Release`
- *
- * @param [in] function A pointer to a function to call.
- * @param [in] parameter A pointer that will be passed to the function when invoked.
- *
- * @return non-NULL A pointer to a valid `PARCFutureTask` instance.
- * @return NULL An error occurred.
- *
- * Example:
- * @code
- * {
- *     PARCFutureTask *a = parcFutureTask_Create(function, parameter);
- *
- *     parcFutureTask_Release(&a);
- * }
- * @endcode
- */
-PARCFutureTask *parcFutureTask_Create(void *(*runnable)(PARCFutureTask *task, void *parameter), void *parameter);
-
-/**
- * Compares @p instance with @p other for order.
- *
- * Returns a negative integer, zero, or a positive integer as @p instance
- * is less than, equal to, or greater than @p other.
- *
- * @param [in] instance A pointer to a valid PARCFutureTask instance.
- * @param [in] other A pointer to a valid PARCFutureTask instance.
- *
- * @return <0 Instance is less than @p other.
- * @return 0 Instance a and instance b compare the same.
- * @return >0 Instance a is greater than instance b.
- *
- * Example:
- * @code
- * {
- *     PARCFutureTask *a = parcFutureTask_Create();
- *     PARCFutureTask *b = parcFutureTask_Create();
- *
- *     if (parcFutureTask_Compare(a, b) == 0) {
- *         printf("Instances are equal.\n");
- *     }
- *
- *     parcFutureTask_Release(&a);
- *     parcFutureTask_Release(&b);
- * }
- * @endcode
- *
- * @see parcFutureTask_Equals
- */
-int parcFutureTask_Compare(const PARCFutureTask *instance, const PARCFutureTask *other);
-
-/**
- * Create an independent copy the given `PARCBuffer`
- *
- * A new buffer is created as a complete copy of the original.
- *
- * @param [in] original A pointer to a valid PARCFutureTask instance.
- *
- * @return NULL Memory could not be allocated.
- * @return non-NULL A pointer to a new `PARCFutureTask` instance.
- *
- * Example:
- * @code
- * {
- *     PARCFutureTask *a = parcFutureTask_Create();
- *
- *     PARCFutureTask *copy = parcFutureTask_Copy(&b);
- *
- *     parcFutureTask_Release(&b);
- *     parcFutureTask_Release(&copy);
- * }
- * @endcode
- */
-PARCFutureTask *parcFutureTask_Copy(const PARCFutureTask *original);
-
-/**
- * Print a human readable representation of the given `PARCFutureTask`.
- *
- * @param [in] instance A pointer to a valid `PARCFutureTask` instance.
- * @param [in] indentation The indentation level to use for printing.
- *
- * Example:
- * @code
- * {
- *     PARCFutureTask *a = parcFutureTask_Create();
- *
- *     parcFutureTask_Display(a, 0);
- *
- *     parcFutureTask_Release(&a);
- * }
- * @endcode
- */
-void parcFutureTask_Display(const PARCFutureTask *instance, int indentation);
-
-/**
- * Determine if two `PARCFutureTask` instances are equal.
- *
- * The following equivalence relations on non-null `PARCFutureTask` instances are maintained: *
- *   * It is reflexive: for any non-null reference value x, `parcFutureTask_Equals(x, x)` must return true.
- *
- *   * It is symmetric: for any non-null reference values x and y, `parcFutureTask_Equals(x, y)` must return true if and only if
- *        `parcFutureTask_Equals(y x)` returns true.
- *
- *   * It is transitive: for any non-null reference values x, y, and z, if
- *        `parcFutureTask_Equals(x, y)` returns true and
- *        `parcFutureTask_Equals(y, z)` returns true,
- *        then `parcFutureTask_Equals(x, z)` must return true.
- *
- *   * It is consistent: for any non-null reference values x and y, multiple invocations of `parcFutureTask_Equals(x, y)`
- *         consistently return true or consistently return false.
- *
- *   * For any non-null reference value x, `parcFutureTask_Equals(x, NULL)` must return false.
- *
- * @param [in] x A pointer to a valid PARCFutureTask instance.
- * @param [in] y A pointer to a valid PARCFutureTask instance.
- *
- * @return true The instances x and y are equal.
- *
- * Example:
- * @code
- * {
- *     PARCFutureTask *a = parcFutureTask_Create();
- *     PARCFutureTask *b = parcFutureTask_Create();
- *
- *     if (parcFutureTask_Equals(a, b)) {
- *         printf("Instances are equal.\n");
- *     }
- *
- *     parcFutureTask_Release(&a);
- *     parcFutureTask_Release(&b);
- * }
- * @endcode
- * @see parcFutureTask_HashCode
- */
-bool parcFutureTask_Equals(const PARCFutureTask *x, const PARCFutureTask *y);
-
-/**
- * Returns a hash code value for the given instance.
- *
- * The general contract of `HashCode` is:
- *
- * Whenever it is invoked on the same instance more than once during an execution of an application,
- * the `HashCode` function must consistently return the same value,
- * provided no information used in a corresponding comparisons on the instance is modified.
- *
- * This value need not remain consistent from one execution of an application to another execution of the same application.
- * If two instances are equal according to the {@link parcFutureTask_Equals} method,
- * then calling the {@link parcFutureTask_HashCode} method on each of the two instances must produce the same integer result.
- *
- * It is not required that if two instances are unequal according to the
- * {@link parcFutureTask_Equals} function,
- * then calling the `parcFutureTask_HashCode`
- * method on each of the two objects must produce distinct integer results.
- *
- * @param [in] instance A pointer to a valid PARCFutureTask instance.
- *
- * @return The hashcode for the given instance.
- *
- * Example:
- * @code
- * {
- *     PARCFutureTask *a = parcFutureTask_Create();
- *
- *     PARCHashCode hashValue = parcFutureTask_HashCode(buffer);
- *     parcFutureTask_Release(&a);
- * }
- * @endcode
- */
-PARCHashCode parcFutureTask_HashCode(const PARCFutureTask *instance);
-
-/**
- * Determine if an instance of `PARCFutureTask` is valid.
- *
- * Valid means the internal state of the type is consistent with its required current or future behaviour.
- * This may include the validation of internal instances of types.
- *
- * @param [in] instance A pointer to a valid PARCFutureTask instance.
- *
- * @return true The instance is valid.
- * @return false The instance is not valid.
- *
- * Example:
- * @code
- * {
- *     PARCFutureTask *a = parcFutureTask_Create();
- *
- *     if (parcFutureTask_IsValid(a)) {
- *         printf("Instance is valid.\n");
- *     }
- *
- *     parcFutureTask_Release(&a);
- * }
- * @endcode
- *
- */
-bool parcFutureTask_IsValid(const PARCFutureTask *instance);
-
-/**
- * Release a previously acquired reference to the given `PARCFutureTask` instance,
- * decrementing the reference count for the instance.
- *
- * The pointer to the instance is set to NULL as a side-effect of this function.
- *
- * If the invocation causes the last reference to the instance to be released,
- * the instance is deallocated and the instance's implementation will perform
- * additional cleanup and release other privately held references.
- *
- * @param [in,out] instancePtr A pointer to a pointer to the instance to release.
- *
- * Example:
- * @code
- * {
- *     PARCFutureTask *a = parcFutureTask_Create();
- *
- *     parcFutureTask_Release(&a);
- * }
- * @endcode
- */
-void parcFutureTask_Release(PARCFutureTask **instancePtr);
-
-/**
- * Create a `PARCJSON` instance (representation) of the given object.
- *
- * @param [in] instance A pointer to a valid PARCFutureTask instance.
- *
- * @return NULL Memory could not be allocated to contain the `PARCJSON` instance.
- * @return non-NULL An allocated C string that must be deallocated via parcMemory_Deallocate().
- *
- * Example:
- * @code
- * {
- *     PARCFutureTask *a = parcFutureTask_Create();
- *
- *     PARCJSON *json = parcFutureTask_ToJSON(a);
- *
- *     printf("JSON representation: %s\n", parcJSON_ToString(json));
- *     parcJSON_Release(&json);
- *
- *     parcFutureTask_Release(&a);
- * }
- * @endcode
- */
-PARCJSON *parcFutureTask_ToJSON(const PARCFutureTask *instance);
-
-/**
- * Produce a null-terminated string representation of the specified `PARCFutureTask`.
- *
- * The result must be freed by the caller via {@link parcMemory_Deallocate}.
- *
- * @param [in] instance A pointer to a valid PARCFutureTask instance.
- *
- * @return NULL Cannot allocate memory.
- * @return non-NULL A pointer to an allocated, null-terminated C string that must be deallocated via {@link parcMemory_Deallocate}.
- *
- * Example:
- * @code
- * {
- *     PARCFutureTask *a = parcFutureTask_Create();
- *
- *     char *string = parcFutureTask_ToString(a);
- *
- *     parcFutureTask_Release(&a);
- *
- *     parcMemory_Deallocate(&string);
- * }
- * @endcode
- *
- * @see parcFutureTask_Display
- */
-char *parcFutureTask_ToString(const PARCFutureTask *instance);
-
-/**
- * Wakes up a single thread that is waiting on this object (see `parcFutureTask_Wait)`.
- * If any threads are waiting on this object, one of them is chosen to be awakened.
- * The choice is arbitrary and occurs at the discretion of the underlying implementation.
- *
- * The awakened thread will not be able to proceed until the current thread relinquishes the lock on this object.
- * The awakened thread will compete in the usual manner with any other threads that might be actively
- * competing to synchronize on this object;
- * for example, the awakened thread enjoys no reliable privilege or disadvantage in being the next thread to lock this object.
- *
- * @param [in] object A pointer to a valid PARCFutureTask instance.
- *
- * Example:
- * @code
- * {
- *     if (parcFutureTask_Lock(object)) {
- *         parcFutureTask_Notify(object);
- *         parcFutureTask_Unlock(object);
- *     }
- * }
- * @endcode
- */
-parcObject_ImplementNotify(parcFutureTask, PARCFutureTask);
-
-/**
- * Wakes up all threads that are waiting on the given object's lock.
- *
- * A thread waits on an object by calling one of the wait methods, `parcFutureTask_Wait`, `parcFutureTask_WaitFor`, `parcFutureTask_WaitUntil`.
- * The awakened threads will proceed after the current thread relinquishes the lock on the given object.
- * The awakened threads will compete in the usual manner with any other threads that might be actively competing
- * to synchronize on this object.
- * Awakened threads have no priority between them in being the next thread to lock this object.
- *
- * This method can only be called by a thread that is the owner of this object's lock.
- *
- * @param [in] object A pointer to a valid `PARCFutureTask` instance.
- *
- * Example:
- * @code
- * {
- *     if (parcFutureTask_Lock(object)) {
- *         parcFutureTask_NotifyAll(object);
- *         parcFutureTask_Unlock(object);
- *     }
- * }
- * @endcode
- */
-parcObject_ImplementNotifyAll(parcFutureTask, PARCFutureTask);
-
-/**
- * Causes the calling thread to wait until either another thread invokes the parcFutureTask_Notify() function on the same object.
- *  *
- * @param [in] object A pointer to a valid `PARCFutureTask` instance.
- *
- * Example:
- * @code
- * {
- *
- *     parcFutureTask_Wait(object);
- * }
- * @endcode
- */
-parcObject_ImplementWait(parcFutureTask, PARCFutureTask);
-
-/**
- * Obtain the lock on the given `PARCFutureTask` instance.
- *
- * If the lock is already held by another thread, this function will block.
- * If the lock is aleady held by the current thread, this function will return `false`.
- *
- * Implementors must avoid deadlock by attempting to lock the object a second time within the same calling thread.
- *
- * @param [in] object A pointer to a valid `PARCFutureTask` instance.
- *
- * @return true The lock was obtained successfully.
- * @return false The lock is already held by the current thread, or the `PARCFutureTask` is invalid.
- *
- * Example:
- * @code
- * {
- *     if (parcFutureTask_Lock(object)) {
- *
- *     }
- * }
- * @endcode
- */
-parcObject_ImplementLock(parcFutureTask, PARCFutureTask);
-
-/**
- * Try to obtain the advisory lock on the given PARCFutureTask instance.
- *
- * Once the lock is obtained, the caller must release the lock as soon as possible.
- *
- * @param [in] object A pointer to a valid PARCFutureTask instance.
- *
- * @return true The PARCFutureTask is locked.
- * @return false The PARCFutureTask is unlocked.
- *
- * Example:
- * @code
- * {
- *     parcFutureTask_TryLock(object);
- * }
- * @endcode
- */
-parcObject_ImplementTryLock(parcFutureTask, PARCFutureTask);
-
-/**
- * Try to unlock the advisory lock on the given `PARCFutureTask` instance.
- *
- * @param [in] object A pointer to a valid `PARCFutureTask` instance.
- *
- * @return true The `PARCFutureTask` was locked and now is unlocked.
- * @return false The `PARCFutureTask` was not locked and remains unlocked.
- *
- * Example:
- * @code
- * {
- *     parcFutureTask_Unlock(object);
- * }
- * @endcode
- */
-parcObject_ImplementUnlock(parcFutureTask, PARCFutureTask);
-
-/**
- * Determine if the advisory lock on the given `PARCFutureTask` instance is locked.
- *
- * @param [in] object A pointer to a valid `PARCFutureTask` instance.
- *
- * @return true The `PARCFutureTask` is locked.
- * @return false The `PARCFutureTask` is unlocked.
- * Example:
- * @code
- * {
- *     if (parcFutureTask_IsLocked(object)) {
- *         ...
- *     }
- * }
- * @endcode
- */
-parcObject_ImplementIsLocked(parcFutureTask, PARCFutureTask);
-
-/**
- * Attempt to cancel the execution of this task.
- *
- * This will return `false` if the task is already done or has already been cancelled.
- * Otherswise, if this task has not started when `parcFutureTask_Cancel` is called, this task will never run.
- *
- * If the task is already running, the boolean `mayInterruptIfRunning` may cause the task to be interrupted,
- * otherwise this function will have no effect.
- *
- * After this function returns, subsequent calls to `parcFutureTask_IsDone` will always return true.
- * Subsequent calls to  `parcFutureTask_isCancelled` will always return true if this function returned true.
- *
- * @param [in] object A pointer to a valid `PARCFutureTask` instance.
- *
- * @return true The task was cancelled.
- *
- * Example:
- * @code
- * {
- *     <#example#>
- * }
- * @endcode
- */
-bool parcFutureTask_Cancel(PARCFutureTask *task, bool mayInterruptIfRunning);
-
-/**
- * Waits if necessary for at most the given time for the computation to complete, and then retrieves its result, if available.
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [<#in#> | <#out#> | <#in,out#>] <#name#> <#description#>
- *
- * @return <#value#> <#explanation#>
- *
- * Example:
- * @code
- * {
- *     <#example#>
- * }
- * @endcode
- */
-PARCFutureTaskResult parcFutureTask_Get(const PARCFutureTask *futureTask, const PARCTimeout *timeout);
-
-/**
- * Returns true if this task was cancelled before it completed normally.
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [<#in#> | <#out#> | <#in,out#>] <#name#> <#description#>
- *
- * @return <#value#> <#explanation#>
- *
- * Example:
- * @code
- * {
- *     <#example#>
- * }
- * @endcode
- */
-bool parcFutureTask_IsCancelled(const PARCFutureTask *futureTask);
-
-/**
- * Returns true if this task completed.
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [<#in#> | <#out#> | <#in,out#>] <#name#> <#description#>
- *
- * @return <#value#> <#explanation#>
- *
- * Example:
- * @code
- * {
- *     <#example#>
- * }
- * @endcode
- */
-bool parcFutureTask_IsDone(const PARCFutureTask *futureTask);
-
-/**
- * Sets this Future to the result of its computation unless it has been cancelled.
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [<#in#> | <#out#> | <#in,out#>] <#name#> <#description#>
- *
- * @return The result returned by the task function.
- *
- * Example:
- * @code
- * {
- *     <#example#>
- * }
- * @endcode
- */
-void *parcFutureTask_Run(PARCFutureTask *futureTask);
-
-/**
- * Executes the computation without setting its result, and then resets this future to initial state, failing to do so if the computation encounters an exception or is cancelled.
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [<#in#> | <#out#> | <#in,out#>] <#name#> <#description#>
- *
- * @return true The task was executed.
- * @retval false The task was not executed because it was previously completed, or it was cancelled.
- *
- * Example:
- * @code
- * {
- *     <#example#>
- * }
- * @endcode
- */
-bool parcFutureTask_RunAndReset(PARCFutureTask *futureTask);
-
-/**
- * Reset the given PARCFutureTask to the intial state, a subsequent ecutes the computation without setting its result, and then resets this future to initial state, failing to do so if the computation encounters an exception or is cancelled.
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [<#in#> | <#out#> | <#in,out#>] <#name#> <#description#>
- *
- * @return true The task was successfully run
- *
- * Example:
- * @code
- * {
- *     <#example#>
- * }
- * @endcode
- */
-void parcFutureTask_Reset(PARCFutureTask *task);
-#endif
diff --git a/libparc/parc/concurrent/parc_Lock.c b/libparc/parc/concurrent/parc_Lock.c
deleted file mode 100755
index 493fd44f..00000000
--- a/libparc/parc/concurrent/parc_Lock.c
+++ /dev/null
@@ -1,202 +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 <config.h>
-
-#include <pthread.h>
-#include <errno.h>
-
-#include <parc/algol/parc_Object.h>
-#include <parc/algol/parc_DisplayIndented.h>
-
-#include <parc/concurrent/parc_Lock.h>
-
-struct PARCLock {
-    pthread_mutex_t lock;
-    pthread_mutexattr_t lockAttributes;
-    pthread_cond_t notification;
-    bool locked;
-
-    bool notified;
-};
-
-static void
-_parcLock_Finalize(PARCLock **instancePtr)
-{
-    parcAssertNotNull(instancePtr, "Parameter must be a non-null pointer to a PARCLock pointer.");
-
-    parcLock_OptionalAssertValid(*instancePtr);
-
-    /* cleanup the instance fields here */
-}
-
-parcObject_ImplementAcquire(parcLock, PARCLock);
-
-parcObject_ImplementRelease(parcLock, PARCLock);
-
-parcObject_ExtendPARCObject(PARCLock, _parcLock_Finalize, NULL, parcLock_ToString, NULL, NULL, NULL, NULL);
-
-void
-parcLock_AssertValid(const PARCLock *instance)
-{
-    parcAssertTrue(parcLock_IsValid(instance),
-               "PARCLock is not valid.");
-}
-
-PARCLock *
-parcLock_Create(void)
-{
-    PARCLock *result = parcObject_CreateInstance(PARCLock);
-
-    pthread_mutexattr_init(&result->lockAttributes);
-    pthread_mutexattr_settype(&result->lockAttributes, PTHREAD_MUTEX_ERRORCHECK);
-
-    pthread_mutex_init(&result->lock, &result->lockAttributes);
-
-    result->locked = false;
-    pthread_cond_init(&result->notification, NULL);
-    result->notified = false;
-    return result;
-}
-
-void
-parcLock_Display(const PARCLock *lock, int indentation)
-{
-    parcDisplayIndented_PrintLine(indentation, "PARCLock@%p {", lock);
-    parcDisplayIndented_PrintLine(indentation + 1, ".locked=%s", lock->locked ? "true" : "false");
-
-    parcDisplayIndented_PrintLine(indentation, "}");
-}
-
-bool
-parcLock_IsValid(const PARCLock *instance)
-{
-    bool result = false;
-
-    if (instance != NULL) {
-        result = true;
-    }
-
-    return result;
-}
-
-PARCBufferComposer *
-parcLock_BuildString(const PARCLock *lock, PARCBufferComposer *composer)
-{
-    parcBufferComposer_Format(composer, "lock{.state=%s }", lock->locked ? "true" : "false");
-
-    return composer;
-}
-
-char *
-parcLock_ToString(const PARCLock *lock)
-{
-    char *result = NULL;
-
-    PARCBufferComposer *composer = parcBufferComposer_Create();
-    if (composer != NULL) {
-        parcLock_BuildString(lock, composer);
-        result = parcBufferComposer_ToString(composer);
-        parcBufferComposer_Release(&composer);
-    }
-
-    return result;
-}
-
-bool
-parcLock_Unlock(PARCLock *lock)
-{
-    bool result = false;
-
-    parcLock_OptionalAssertValid(lock);
-
-    if (lock->locked) {
-        result = (pthread_mutex_unlock(&lock->lock) == 0);
-    }
-
-    return result;
-}
-
-bool
-parcLock_Lock(PARCLock *lock)
-{
-    bool result = false;
-
-    parcLock_OptionalAssertValid(lock);
-
-    int error = pthread_mutex_lock(&lock->lock);
-
-    if (error == 0) {
-        lock->locked = true;
-        result = true;
-        errno = 0;
-    } else {
-        errno = error;
-    }
-
-    return result;
-}
-
-bool
-parcLock_TryLock(PARCLock *lock)
-{
-    bool result = false;
-
-    parcLock_OptionalAssertValid(lock);
-
-    result = (pthread_mutex_trylock(&lock->lock) == 0);
-    if (result) {
-        lock->locked = true;
-    }
-
-    return result;
-}
-
-bool
-parcLock_IsLocked(const PARCLock *lock)
-{
-    parcLock_OptionalAssertValid(lock);
-
-    return lock->locked;
-}
-
-void
-parcLock_Wait(PARCLock *lock)
-{
-    parcLock_OptionalAssertValid(lock);
-
-    parcTrapUnexpectedStateIf(lock->locked == false,
-                          "You must Lock the object before calling parcLock_Wait");
-
-    lock->notified = false;
-    while (lock->notified == false) {
-        pthread_cond_wait(&lock->notification, &lock->lock);
-    }
-}
-
-void
-parcLock_Notify(PARCLock *lock)
-{
-    parcLock_OptionalAssertValid(lock);
-
-    parcTrapUnexpectedStateIf(lock->locked == false,
-                          "You must Lock the object before calling parcLock_Notify");
-
-    lock->notified = true;
-    pthread_cond_signal(&lock->notification);
-}
-
diff --git a/libparc/parc/concurrent/parc_Lock.h b/libparc/parc/concurrent/parc_Lock.h
deleted file mode 100755
index ecba1c19..00000000
--- a/libparc/parc/concurrent/parc_Lock.h
+++ /dev/null
@@ -1,377 +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 parc_Lock.h
- * @ingroup threading
- * @brief <#Brief Description#>
- *
- * <#Detailed Description#>
- *
- */
-#ifndef PARCLibrary_parc_Lock
-#define PARCLibrary_parc_Lock
-#include <stdbool.h>
-
-#include <parc/algol/parc_HashCode.h>
-#include <parc/algol/parc_JSON.h>
-
-struct PARCLock;
-typedef struct PARCLock PARCLock;
-
-/**
- * Increase the number of references to a `PARCLock` instance.
- *
- * Note that new `PARCLock` is not created,
- * only that the given `PARCLock` reference count is incremented.
- * Discard the reference by invoking `parcLock_Release`.
- *
- * @param [in] instance A pointer to a valid PARCLock instance.
- *
- * @return The same value as @p instance.
- *
- * Example:
- * @code
- * {
- *     PARCLock *a = parcLock_Create();
- *
- *     PARCLock *b = parcLock_Acquire();
- *
- *     parcLock_Release(&a);
- *     parcLock_Release(&b);
- * }
- * @endcode
- */
-PARCLock *parcLock_Acquire(const PARCLock *instance);
-
-#ifdef PARCLibrary_DISABLE_VALIDATION
-#  define parcLock_OptionalAssertValid(_instance_)
-#else
-#  define parcLock_OptionalAssertValid(_instance_) parcLock_AssertValid(_instance_)
-#endif
-
-/**
- * Assert that the given `PARCLock` instance is valid.
- *
- * @param [in] instance A pointer to a valid PARCLock instance.
- *
- * Example:
- * @code
- * {
- *     PARCLock *a = parcLock_Create();
- *
- *     parcLock_AssertValid(a);
- *
- *     printf("Instance is valid.\n");
- *
- *     parcLock_Release(&b);
- * }
- * @endcode
- */
-void parcLock_AssertValid(const PARCLock *instance);
-
-/**
- * Create an instance of PARCLock
- *
- * <#Paragraphs Of Explanation#>
- *
- * @return non-NULL A pointer to a valid PARCLock instance.
- * @return NULL An error occurred.
- *
- * Example:
- * @code
- * {
- *     PARCLock *a = parcLock_Create();
- *
- *     parcLock_Release(&a);
- * }
- * @endcode
- */
-PARCLock *parcLock_Create(void);
-
-/**
- * Compares @p instance with @p other for order.
- *
- * Returns a negative integer, zero, or a positive integer as @p instance
- * is less than, equal to, or greater than @p other.
- *
- * @param [in] instance A pointer to a valid PARCLock instance.
- * @param [in] other A pointer to a valid PARCLock instance.
- *
- * @return <0 Instance is less than @p other.
- * @return 0 Instance a and instance b compare the same.
- * @return >0 Instance a is greater than instance b.
- *
- * Example:
- * @code
- * {
- *     PARCLock *a = parcLock_Create();
- *     PARCLock *b = parcLock_Create();
- *
- *     if (parcLock_Compare(a, b) == 0) {
- *         printf("Instances are equal.\n");
- *     }
- *
- *     parcLock_Release(&a);
- *     parcLock_Release(&b);
- * }
- * @endcode
- *
- * @see parcLock_Equals
- */
-int parcLock_Compare(const PARCLock *instance, const PARCLock *other);
-
-/**
- * Print a human readable representation of the given `PARCLock`.
- *
- * @param [in] instance A pointer to a valid PARCLock instance.
- * @param [in] indentation The indentation level to use for printing.
- *
- * Example:
- * @code
- * {
- *     PARCLock *a = parcLock_Create();
- *
- *     parcLock_Display(a, 0);
- *
- *     parcLock_Release(&a);
- * }
- * @endcode
- */
-void parcLock_Display(const PARCLock *instance, int indentation);
-
-/**
- * Determine if an instance of `PARCLock` is valid.
- *
- * Valid means the internal state of the type is consistent with its required current or future behaviour.
- * This may include the validation of internal instances of types.
- *
- * @param [in] instance A pointer to a valid PARCLock instance.
- *
- * @return true The instance is valid.
- * @return false The instance is not valid.
- *
- * Example:
- * @code
- * {
- *     PARCLock *a = parcLock_Create();
- *
- *     if (parcLock_IsValid(a)) {
- *         printf("Instance is valid.\n");
- *     }
- *
- *     parcLock_Release(&a);
- * }
- * @endcode
- *
- */
-bool parcLock_IsValid(const PARCLock *instance);
-
-/**
- * Release a previously acquired reference to the given `PARCLock` instance,
- * decrementing the reference count for the instance.
- *
- * The pointer to the instance is set to NULL as a side-effect of this function.
- *
- * If the invocation causes the last reference to the instance to be released,
- * the instance is deallocated and the instance's implementation will perform
- * additional cleanup and release other privately held references.
- *
- * @param [in,out] instancePtr A pointer to a pointer to the instance to release.
- *
- * Example:
- * @code
- * {
- *     PARCLock *a = parcLock_Create();
- *
- *     parcLock_Release(&a);
- * }
- * @endcode
- */
-void parcLock_Release(PARCLock **instancePtr);
-
-/**
- * Append a representation of the specified `PARCLock` instance to the given `PARCBufferComposer`.
- *
- * @param [in] name A pointer to a `PARCLock` instance whose representation should be appended to the @p composer.
- * @param [in,out] composer A pointer to a `PARCBufferComposer` instance to be modified.
- *
- * @return NULL Cannot allocate memory.
- * @return non-NULL The @p composer.
- *
- * Example:
- * @code
- * {
- *     PARCBufferComposer *result = parcBufferComposer_Create();
- *
- *     parcLock_BuildString(instance, result);
- *
- *     char *string = parcBufferComposer_ToString(result);
- *     printf("Hello: %s\n", string);
- *     parcMemory_Deallocate(string);
- *
- *     parcBufferComposer_Release(&result);
- * }
- * @endcode
- */
-PARCBufferComposer *parcLock_BuildString(const PARCLock *name, PARCBufferComposer *composer);
-
-/**
- * Produce a null-terminated string representation of the specified `PARCLock`.
- *
- * The result must be freed by the caller via {@link parcMemory_Deallocate}.
- *
- * @param [in] instance A pointer to a valid PARCLock instance.
- *
- * @return NULL Cannot allocate memory.
- * @return non-NULL A pointer to an allocated, null-terminated C string that must be deallocated via {@link parcMemory_Deallocate}.
- *
- * Example:
- * @code
- * {
- *     PARCLock *a = parcLock_Create();
- *
- *     char *string = parcLock_ToString(a);
- *
- *     parcLock_Release(&a);
- *
- *     parcMemory_Deallocate(&string);
- * }
- * @endcode
- *
- * @see parcLock_Display
- */
-char *parcLock_ToString(const PARCLock *instance);
-
-/**
- * Obtain the lock on the given `PARCLock` instance.
- *
- * If the lock is already held by another thread, this function will block.
- * If the lock is aleady held by the current thread, this function will return `false`.
- *
- * Implementors must avoid deadlock by attempting to lock the object a second time within the same calling thread.
- *
- * @param [in] lock A pointer to a valid `PARCLock` instance.
- *
- * @return true The lock was obtained successfully.
- * @return false The lock is already held by the current thread, or the `PARCLock` is invalid.
- *
- * Example:
- * @code
- * {
- *     if (parcLock_Lock(lock)) {
- *
- *     }
- * }
- * @endcode
- */
-bool parcLock_Lock(PARCLock *lock);
-
-/**
- * Try to obtain the advisory lock on the given `PARCObject` instance.
- *
- * Once the lock is obtained, the caller must release the lock via `parcObject_Unlock`.
- *
- * @param [in] lock A pointer to a valid `PARCObject` instance.
- *
- * @return true The `PARCObject` is locked.
- * @return false The `PARCObject` is unlocked.
- *
- * Example:
- * @code
- * {
- *     while (parcLock_TryLock(object))
- *         ;
- * }
- * @endcode
- */
-bool parcLock_TryLock(PARCLock *lock);
-
-/**
- * Try to unlock the advisory lock on the given PARCObject instance.
- *
- * @param [in] lock A pointer to a valid PARCObject instance.
- *
- * @return true The PARCObject was locked and now is unlocked.
- * @return false The PARCObject was not locked and remains unlocked.
- *
- * Example:
- * @code
- * {
- *     parcLock_Unlock(object);
- * }
- * @endcode
- */
-bool parcLock_Unlock(PARCLock *lock);
-
-/**
- * Determine if the advisory lock on the given PARCObject instance is locked.
- *
- * @param [in] lock A pointer to a valid PARCObject instance.
- *
- * @return true The PARCObject is locked.
- * @return false The PARCObject is unlocked.
- * Example:
- * @code
- * {
- *     <#example#>
- * }
- * @endcode
- */
-bool parcLock_IsLocked(const PARCLock *lock);
-
-/**
- * Causes the calling thread to wait until either another thread invokes the parcObject_Notify() function on the same object.
- *
- * The calling thread must own this object's lock.
- * The calling thread will release ownership of this lock and wait until another thread invokes `parcObject_Notify`
- * on the same object. The original calling thread then re-obtains ownership of the lock and resumes execution.
- *
- * This function must only be called by a thread that is the owner of this object's lock.
- *
- * @param [in] lock A pointer to a valid PARCObject instance.
- *
- * Example:
- * @code
- * {
- *
- *     parcObject_Wait(object);
- * }
- * @endcode
- */
-void parcLock_Wait(PARCLock *lock);
-
-/**
- * Wakes up a single thread that is waiting on this object (see `parcObject_Wait)`.
- * If any threads are waiting on this object, one of them is chosen to be awakened.
- * The choice is arbitrary and occurs at the discretion of the underlying implementation.
- *
- * The awakened thread will not be able to proceed until the current thread relinquishes the lock on this object.
- * The awakened thread will compete in the usual manner with any other threads that might be actively
- * competing to synchronize on this object;
- * for example, the awakened thread enjoys no reliable privilege or disadvantage in being the next thread to lock this object.
- *
- * @param [in] lock A pointer to a valid `PARCObject` instance.
- *
- * Example:
- * @code
- * {
- *
- *     parcObject_Notify(object);
- * }
- * @endcode
- */
-void parcLock_Notify(PARCLock *lock);
-#endif
diff --git a/libparc/parc/concurrent/parc_Notifier.c b/libparc/parc/concurrent/parc_Notifier.c
deleted file mode 100755
index 67e8cfb3..00000000
--- a/libparc/parc/concurrent/parc_Notifier.c
+++ /dev/null
@@ -1,149 +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 <config.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <errno.h>
-#include <fcntl.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/concurrent/parc_Notifier.h>
-#include <parc/algol/parc_Object.h>
-
-#ifdef __GNUC__
-#define ATOMIC_ADD_AND_FETCH(ptr, increment)      __sync_add_and_fetch(ptr, increment)
-#define ATOMIC_BOOL_CAS(ptr, oldvalue, newvalue)  __sync_bool_compare_and_swap(ptr, oldvalue, newvalue)
-#define ATOMIC_FETCH(ptr)                         ATOMIC_ADD_AND_FETCH(ptr, 0)
-#define ATOMIC_SET(ptr, oldvalue, newvalue)       ATOMIC_BOOL_CAS(ptr, oldvalue, newvalue)
-#else
-#error "Only GNUC supported, we need atomic operations"
-#endif
-
-struct parc_notifier {
-    volatile int paused;
-
-    // If the notifications are paused and there is an event,
-    // we indicate that we skipped a notify
-    volatile int skippedNotify;
-
-#define PARCNotifierWriteFd 1
-#define PARCNotifierReadFd 0
-    int fds[2];
-};
-
-static void
-_parcNotifier_Finalize(PARCNotifier **notifierPtr)
-{
-    PARCNotifier *notifier = *notifierPtr;
-
-    close(notifier->fds[0]);
-    close(notifier->fds[1]);
-}
-
-parcObject_ExtendPARCObject(PARCNotifier, _parcNotifier_Finalize, NULL, NULL, NULL, NULL, NULL, NULL);
-
-static bool
-_parcNotifier_MakeNonblocking(PARCNotifier *notifier)
-{
-    // set the read side to be non-blocking
-    int flags = fcntl(notifier->fds[PARCNotifierReadFd], F_GETFL, 0);
-    if (flags == 0) {
-        if (fcntl(notifier->fds[PARCNotifierReadFd], F_SETFL, flags | O_NONBLOCK) == 0) {
-            return true;
-        }
-    }
-    perror("fcntl error");
-    return false;
-}
-
-PARCNotifier *
-parcNotifier_Create(void)
-{
-    PARCNotifier *notifier = parcObject_CreateInstance(PARCNotifier);
-    if (notifier) {
-        notifier->paused = false;
-        notifier->skippedNotify = false;
-
-        int failure = pipe(notifier->fds);
-        parcAssertFalse(failure, "Error on pipe: %s", strerror(errno));
-
-        if (!_parcNotifier_MakeNonblocking(notifier)) {
-            parcObject_Release((void **) &notifier);
-        }
-    }
-
-    return notifier;
-}
-
-parcObject_ImplementAcquire(parcNotifier, PARCNotifier);
-
-parcObject_ImplementRelease(parcNotifier, PARCNotifier);
-
-
-int
-parcNotifier_Socket(PARCNotifier *notifier)
-{
-    return notifier->fds[PARCNotifierReadFd];
-}
-
-bool
-parcNotifier_Notify(PARCNotifier *notifier)
-{
-    if (ATOMIC_BOOL_CAS(&notifier->paused, 0, 1)) {
-        // old value was "0" so we need to send a notification
-        uint8_t one = 1;
-        ssize_t written;
-        do {
-            written = write(notifier->fds[PARCNotifierWriteFd], &one, 1);
-            parcAssertTrue(written >= 0, "Error writing to socket %d: %s", notifier->fds[PARCNotifierWriteFd], strerror(errno));
-        } while (written == 0);
-
-        return true;
-    } else {
-        // we're paused, so count up the pauses
-        ATOMIC_ADD_AND_FETCH(&notifier->skippedNotify, 1);
-        return false;
-    }
-}
-
-void
-parcNotifier_PauseEvents(PARCNotifier *notifier)
-{
-    // reset the skipped counter so we count from now until the StartEvents call
-    notifier->skippedNotify = 0;
-    ATOMIC_BOOL_CAS(&notifier->paused, 0, 1);
-
-    // now clear out the socket
-    uint8_t buffer[16];
-    while (read(notifier->fds[PARCNotifierReadFd], &buffer, 16) > 0) {
-        ;
-    }
-}
-
-void
-parcNotifier_StartEvents(PARCNotifier *notifier)
-{
-    ATOMIC_BOOL_CAS(&notifier->paused, 1, 0);
-    if (notifier->skippedNotify) {
-        // we missed some notifications, so re-signal ourself
-        parcNotifier_Notify(notifier);
-    }
-}
diff --git a/libparc/parc/concurrent/parc_Notifier.h b/libparc/parc/concurrent/parc_Notifier.h
deleted file mode 100755
index 44eda3b5..00000000
--- a/libparc/parc/concurrent/parc_Notifier.h
+++ /dev/null
@@ -1,178 +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 parc_Notifier.h
- * @ingroup threading
- * @brief Inter-thread/process notification
- *
- * A 1-way event notification system.  The first call to parcNotifier_SetEvent() will post an
- * event to the parcNotifier_Socket().  Subsequent calls will not post an event.  When the
- * event consumer is ready to handle the event, it calls parcNotifier_PauseEvents(), then processes
- * the events, then calls parcNotifier_StartEvents().
- *
- * @code
- * {
- *    // example code on the event consumer's side
- *    struct pollfd pfd;
- *    pfd.fd = parcNotifier_Socket(notifier);
- *    pfd.events = POLLIN;
- *
- *    while(1) {
- *       if (poll(&fd, 1, -1)) {
- *           parcNotifier_PauseEvents(notifier);
- *
- *           // process events, such as reading from a RingBuffer
- *           void *data;
- *           while (parcRingBuffer1x1_Get(ring, &data)) {
- *              // handle data
- *           }
- *
- *           parcNotifier_StartEvents(notifier);
- *       }
- *    }
- * }
- * @endcode
- *
- * The notification system guarantees that no notifications will be missed.  However, there may be
- * extra notifications.  For example, in the above code, if an event is signalled between the
- * parcNotifier_PauseEvents() and parcRingBuffer1x1_Get() calls, then on parcNotifier_StartEvents()
- * an extra event will be triggered, even though the ring buffer is empty.
- *
- */
-
-#ifndef libparc_parc_Notifier_h
-#define libparc_parc_Notifier_h
-
-#include <stdbool.h>
-
-struct parc_notifier;
-typedef struct parc_notifier PARCNotifier;
-
-/**
- * Create a new instance of `PARCNotifier`
- *
- * @return  A new instance of `PARCNotifier`
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-PARCNotifier *parcNotifier_Create(void);
-
-/**
- * Increase the number of references to a `PARCNotifier`.
- *
- * Note that new `PARCNotifier` is not created,
- * only that the given `PARCNotifier` reference count is incremented.
- * Discard the reference by invoking `parcNotifier_Release`.
- *
- * @param [in] instance A pointer to a `PARCNotifier` instance.
- *
- * @return The input `PARCNotifier` pointer.
- *
- * Example:
- * @code
- * {
- *     PARCNotifier *a = parcNotifier_Create(...);
- *
- *     PARCNotifier *b = parcNotifier_Acquire(a);
- *
- *     parcNotifier_Release(&a);
- *     parcNotifier_Release(&b);
- * }
- * @endcode
- */
-PARCNotifier *parcNotifier_Acquire(const PARCNotifier *notifier);
-
-/**
- * Release a previously acquired reference to the specified instance,
- * decrementing the reference count for the instance.
- *
- * The pointer to the instance is set to NULL as a side-effect of this function.
- *
- * If the invocation causes the last reference to the instance to be released,
- * the instance is deallocated and the instance's implementation will perform
- * additional cleanup and release other privately held references.
- *
- * @param [in,out] instancePtr A pointer to a pointer to the instance to release, which will be set to NULL.
- *
- * Example:
- * @code
- * {
- *     PARCNotifier *a = parcNotifier_Create(...);
- *
- *     parcNotifier_Release(&a);
- * }
- * @endcode
- */
-void parcNotifier_Release(PARCNotifier **notifier);
-
-/**
- * Fetches the notification socket
- *
- * The notification socket may be used in select() or poll() or similar
- * functions.  You should not read or write to the socket.
- *
- * @param [in] notifier The instance of `PARCNotifier`
- *
- * @return The notification socket.
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-int parcNotifier_Socket(PARCNotifier *notifier);
-
-/**
- * Sends a notification to the notifier socket
- *
- * @param [in] notifier The instance of `PARCNotifier`
- *
- * @return True is successsful, else false.
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-bool parcNotifier_Notify(PARCNotifier *notifier);
-
-/**
- * Pause the event stream of the Notifier
- *
- * @param [in] notifier The instance of `PARCNotifier`
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-void parcNotifier_PauseEvents(PARCNotifier *notifier);
-
-/**
- * Restart the event stream of the Notifier
- *
- * @param [in] notifier The instance of `PARCNotifier`
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-void parcNotifier_StartEvents(PARCNotifier *notifier);
-#endif // libparc_parc_Notifier_h
diff --git a/libparc/parc/concurrent/parc_RingBuffer.c b/libparc/parc/concurrent/parc_RingBuffer.c
deleted file mode 100755
index d5fb677b..00000000
--- a/libparc/parc/concurrent/parc_RingBuffer.c
+++ /dev/null
@@ -1,75 +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.
- */
-
-/**
- * This is a facade over the 1x1 or NxM ring buffers.
- *
- */
-
-#include <config.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <pthread.h>
-#include <errno.h>
-#include <string.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Object.h>
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/concurrent/parc_RingBuffer.h>
-
-struct parc_ringbuffer {
-    PARCRingBufferInterface *interface;
-};
-
-static void
-_parcRingBuffer_Finalize(PARCRingBuffer **pointer)
-{
-    PARCRingBuffer *buffer = *pointer;
-    buffer->interface->release(&(buffer->interface));
-}
-
-parcObject_ExtendPARCObject(PARCRingBuffer, _parcRingBuffer_Finalize, NULL, NULL, NULL, NULL, NULL, NULL);
-
-PARCRingBuffer *
-parcRingBuffer_Create(PARCRingBufferInterface *interface)
-{
-    PARCRingBuffer *ring = parcObject_CreateInstance(PARCRingBuffer);
-    ring->interface = interface;
-    return ring;
-}
-
-parcObject_ImplementAcquire(parcRingBuffer, PARCRingBuffer);
-
-parcObject_ImplementRelease(parcRingBuffer, PARCRingBuffer);
-
-bool
-parcRingBuffer_Put(PARCRingBuffer *ring, void *data)
-{
-    return ring->interface->put(ring->interface->instance, data);
-}
-
-bool
-parcRingBuffer_Get(PARCRingBuffer *ring, void **outputDataPtr)
-{
-    return ring->interface->put(ring->interface->instance, outputDataPtr);
-}
-
-uint32_t
-parcRingBuffer_Remaining(PARCRingBuffer *ring)
-{
-    return ring->interface->remaining(ring->interface->instance);
-}
diff --git a/libparc/parc/concurrent/parc_RingBuffer.h b/libparc/parc/concurrent/parc_RingBuffer.h
deleted file mode 100755
index 211f044e..00000000
--- a/libparc/parc/concurrent/parc_RingBuffer.h
+++ /dev/null
@@ -1,162 +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 parc_RingBuffer.h
- * @ingroup threading
- * @brief A thread-safe ring buffer.
- *
- * A fixed size, thread safe ring buffer. It can have multiple producers and multiple
- * consumers. All exclusion is done inside the ring buffer.
- *
- * This is a non-blocking data structure.
- *
- * If the user knows there is only one producer and one consumer, you can create the ring buffer with
- * `parcRingBuffer_CreateSingleProducerSingleConsumer`. Such a ring buffer can have at most 2 references.
- *
- */
-
-#ifndef libparc_parc_RingBuffer_h
-#define libparc_parc_RingBuffer_h
-
-#include <stdbool.h>
-#include <stdint.h>
-
-struct parc_ringbuffer;
-typedef struct parc_ringbuffer PARCRingBuffer;
-
-/**< Will be called for each data item on destroy */
-typedef void (RingBufferEntryDestroyer)(void **entryPtr);
-
-struct parc_ringbuffer_impl;
-typedef struct parc_ringbuffer_interface PARCRingBufferInterface;
-
-struct parc_ringbuffer_interface {
-    void *instance;
-    void * (*acquire)(PARCRingBufferInterface *ring);
-    void (*release)(PARCRingBufferInterface **ring);
-    bool (*put)(PARCRingBufferInterface *ring, void *data);
-    bool (*get)(PARCRingBufferInterface *ring, void *outputDataPtr);
-    bool (*remaining)(PARCRingBufferInterface *ring);
-};
-
-/**
- * Creates a ring buffer of the given size, which must be a power of 2.
- *
- * The ring buffer can store up to (elements-1) items in the buffer.  The buffer can
- * be shared between multiple producers and consumers.  Each of them should be
- * given out from a call to {@link parcRingBuffer_Acquire} to create reference counted
- * copies.
- *
- * The reference count is "1" on return.
- *
- * @param [in] interface A pointer to the underlying instance and the interface functions for acquire,
- * release,put,get,and remaining.
- *
- * @return non-null An pointer to a new allocated `PARCRingBuffer`.
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-PARCRingBuffer *parcRingBuffer_Create(PARCRingBufferInterface *interface);
-
-/**
- * Acquire a new reference to an instance of `PARCRingBuffer`.
- *
- * A RING WITHOUT LOCKS CAN ONLY HAVE 2 REFERENCES.
- * The reference count to the instance is incremented.
- *
- * @param [in] ring The instance of `PARCRingBuffer` to which to refer.
- *
- * @return The same value as the input parameter @p ring
- *
- * Example:
- * @code
- * {
- *     <#example#>
- * }
- * @endcode
- */
-
-PARCRingBuffer *parcRingBuffer_Acquire(const PARCRingBuffer *ring);
-
-/**
- * Releases a reference.  The buffer will be destroyed after the last release.
- *
- * If the destroyer was specified on create, it will be called on each entry in the buffer
- * when the buffer is destroyed.
- *
- * @param [in,out] ringPtr The pointer to the pointer of the `PARCRingBuffer` to be destroyed.
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-void parcRingBuffer_Release(PARCRingBuffer **ringPtr);
-
-/**
- * Non-blocking attempt to put item on ring.  May return false if ring is full.
- *
- * @param [in,out] ring The instance of `PARCRingBuffer` to modify'
- * @param [in] data A pointer to teh data to put on the ring.
- *
- * @return true Data was put on the queue
- * @return false Would have blocked, the queue was full
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-bool parcRingBuffer_Put(PARCRingBuffer *ring, void *data);
-
-/**
- * Gets the next item off the ring, or returns false if would have blocked.
- *
- * Non-blocking, gets an item off the ring, or returns false if would block
- *
- * @param [in] ring The pointer to the `PARCRingBuffer`
- * @param [out] outputDataPtr The output pointer
- *
- * @return true Data returned in the output argument
- * @return false Ring is empty, no data returned.
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-bool parcRingBuffer_Get(PARCRingBuffer *ring, void **outputDataPtr);
-
-/**
- * Returns the remaining capacity of the ring
- *
- * Returns the remaining capacity of the ring.  This does not guarantee the next
- * Put will not block, as other producers might consumer the space between calls.
- *
- * @param [in] ring The pointer to the `PARCRingBuffer`
- *
- * @return  The uint32_t remaining capacity of the ring.
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-uint32_t parcRingBuffer_Remaining(PARCRingBuffer *ring);
-#endif // libparc_parc_RingBuffer_h
diff --git a/libparc/parc/concurrent/parc_RingBuffer_1x1.c b/libparc/parc/concurrent/parc_RingBuffer_1x1.c
deleted file mode 100755
index a93049eb..00000000
--- a/libparc/parc/concurrent/parc_RingBuffer_1x1.c
+++ /dev/null
@@ -1,235 +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.
- */
-
-/**
- * A thread-safe fixed size ring buffer.
- *
- * A single-producer/single-consumer version is lock-free, along the lines of Lamport, "Proving the
- * Correctness of Multiprocess Programs," IEEE Trans on Software Engineering 3(2), Mar 1977, which
- * is based on reading/writing native types upto the data bus width being atomic operations.
- *
- * It can hold (elements-1) data items.  elements must be a power of 2.
- *
- * The writer_head is where the next element should be inserted.  The reader_tail is where the next element
- * should be read.
- *
- * All index variables are unbounded uint32_t.  This means they just keep counting up.  To get the actual
- * index in the ring, we mask with (elements-1).  For example, a ring with 16 elements will be masked with
- * 0x0000000F.  We call this the "ring_mask".
- *
- * Because we never let the writer_head and reader_tail differ by more than (elements-1), this technique of
- * masking works just the same as taking the modulus.  There's no problems at the uint32_t wraparound either.
- * The only math operation we are doing is "+1" which works just fine to wrap a uint32_t.
- *
- * Let's look at some exampls.  I'm going to use a uint16_t so its easier to write the numbers.  Let's assume
- * that the ring size is 16, so the first ring is (0 - 15).
- *              head     tail
- * initialize      0        0
- * put x 3         3        0
- * get x 2         3        2
- * put x 13       16        2
- * put x 1        17        2
- * put x 1      blocks          # (0x11 + 1) & 0x0F  == tail & 0x0F
- * get x 14       17       16
- * get x 1        17       17   # ring is now empty
- * ...
- * empty       65534    65534   # 0xFFFE  0xFFFE masked =  14   14
- * put x1      65535    65534   # 0xFFFF  0xFFFE masked =  15   14
- * put x1          0    65534   # 0x0000  0xFFFE masked =   0   14
- * ...
- *
- * The number of remaining available items is (ring_mask + reader_tail - writer_head) & ring_mask.
- *              head     tail   remaining
- * initialize      0        0   15 + 0 - 0 = 15
- * put x 3         3        0   15 + 0 - 3 = 12
- * get x 2         3        2
- * put x 13       16        2   15 + 2 - 16 = 1
- * put x 1        17        2   15 + 2 - 17 = 0
- * put x 1      blocks
- * get x 14       17       16   15 + 16 - 17 = 14
- * get x 1        17       17   15 + 17 - 17 = 15
- * ...
- * empty       65534    65534   15 + 65534 - 65534 = 13 - 65534 = 13 - (-2) = 15
- * put x1      65535    65534   15 + 65534 - 65535 = 13 - 65535 = 13 - (-1) = 14
- * put x1          0    65534   15 + 65534 -     0 = 13 - 65535 = 13 - ( 0) = 13
- * ...
- *
- * If (writer_head + 1) & ring_mask == reader_tail, then the ring is full.
- * If writer_head == reader_tail, then the ring is empty.
- *
- */
-
-#include <config.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <pthread.h>
-#include <errno.h>
-#include <string.h>
-#include <unistd.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Object.h>
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/concurrent/parc_RingBuffer_1x1.h>
-
-#ifdef __GNUC__
-
-// on x86 or x86_64, simple assignment will work
-#if (__x86_64__ || __i386__)
-#define ATOMIC_ADD_AND_FETCH(ptr, increment)      __sync_add_and_fetch(ptr, increment)
-#define ATOMIC_BOOL_CAS(ptr, oldvalue, newvalue)  __sync_bool_compare_and_swap(ptr, oldvalue, newvalue)
-#define ATOMIC_FETCH(ptr)                        *(ptr)
-#define ATOMIC_SET(ptr, oldvalue, newvalue)      *(ptr) = newvalue
-#else
-#define ATOMIC_ADD_AND_FETCH(ptr, increment)      __sync_add_and_fetch(ptr, increment)
-#define ATOMIC_BOOL_CAS(ptr, oldvalue, newvalue)  __sync_bool_compare_and_swap(ptr, oldvalue, newvalue)
-#define ATOMIC_FETCH(ptr)                         ATOMIC_ADD_AND_FETCH(ptr, 0)
-#define ATOMIC_SET(ptr, oldvalue, newvalue)       ATOMIC_BOOL_CAS(ptr, oldvalue, newvalue)
-#endif
-
-#else
-#error "Only GNUC supported, we need atomic operations"
-#endif
-
-struct parc_ringbuffer_1x1 {
-    // LP64     LP32
-    volatile uint32_t writer_head;          //  0- 3       0
-    volatile uint32_t reader_tail;          //  4- 7       4
-    uint32_t elements;                      //  8-11       8
-    uint32_t ring_mask;                     // 12-15      12
-
-    RingBufferEntryDestroyer *destroyer;    // 16-23      16
-    void **buffer;                          // 24-31      24
-};
-
-static bool
-_isPowerOfTwo(uint32_t x)
-{
-    return ((x != 0) && !(x & (x - 1)));
-}
-
-static void
-_destroy(PARCRingBuffer1x1 **ringptr)
-{
-    PARCRingBuffer1x1 *ring = *ringptr;
-
-    if (ring->destroyer) {
-        void *ptr = NULL;
-        while (parcRingBuffer1x1_Get(ring, &ptr)) {
-            ring->destroyer(&ptr);
-        }
-    }
-    parcMemory_Deallocate((void **) &(ring->buffer));
-}
-
-parcObject_ExtendPARCObject(PARCRingBuffer1x1, _destroy, NULL, NULL, NULL, NULL, NULL, NULL);
-
-static PARCRingBuffer1x1 *
-_create(uint32_t elements, RingBufferEntryDestroyer *destroyer)
-{
-    PARCRingBuffer1x1 *ring = parcObject_CreateInstance(PARCRingBuffer1x1);
-    parcAssertNotNull(ring, "parcObject_Create returned NULL");
-
-    ring->buffer = parcMemory_AllocateAndClear(sizeof(void *) * elements);
-    parcAssertNotNull((ring->buffer), "parcMemory_AllocateAndClear() failed to allocate array of %u pointers", elements);
-
-    ring->writer_head = 0;
-    ring->reader_tail = 0;
-    ring->elements = elements;
-    ring->destroyer = destroyer;
-    ring->ring_mask = elements - 1;
-
-    return ring;
-}
-
-PARCRingBuffer1x1 *
-parcRingBuffer1x1_Create(uint32_t elements, RingBufferEntryDestroyer *destroyer)
-{
-    parcAssertTrue(_isPowerOfTwo(elements), "Parameter elements must be a power of 2, got %u", elements);
-    return _create(elements, destroyer);
-}
-
-
-parcObject_ImplementAcquire(parcRingBuffer1x1, PARCRingBuffer1x1);
-
-parcObject_ImplementRelease(parcRingBuffer1x1, PARCRingBuffer1x1);
-
-/**
- * Put is protected by the writer mutex.  This means that the tail mutex could
- * actually increase while this is happening. That's ok.  Increasing the tail
- * just means there is _more_ room in the ring.  We only modify writer_head.
- */
-bool
-parcRingBuffer1x1_Put(PARCRingBuffer1x1 *ring, void *data)
-{
-    // Our speculative operation
-    // The consumer modifies reader_tail, so make sure that's an atomic read.
-    // only the prodcuer modifies writer_head, so there's only us
-
-    uint32_t writer_head = ring->writer_head;
-    uint32_t reader_tail = ATOMIC_FETCH(&ring->reader_tail);
-
-    uint32_t writer_next = (writer_head + 1) & ring->ring_mask;
-
-    // ring is full
-    if (writer_next == reader_tail) {
-        return false;
-    }
-
-    parcAssertNull(ring->buffer[writer_head], "Ring index %u is not null!", writer_head);
-    ring->buffer[writer_head] = data;
-
-    // we're using this just for atomic write to the integer
-    ATOMIC_SET(&ring->writer_head, writer_head, writer_next);
-
-    return true;
-}
-
-bool
-parcRingBuffer1x1_Get(PARCRingBuffer1x1 *ring, void **outputDataPtr)
-{
-    // do our speculative operation.
-    // The producer modifies writer_head, so make sure that's an atomic read.
-    // only the consumer modifies reader_tail, so there's only us
-
-    uint32_t writer_head = ATOMIC_FETCH(&ring->writer_head); // native type assignment is atomic
-    uint32_t reader_tail = ring->reader_tail;
-    uint32_t reader_next = (reader_tail + 1) & ring->ring_mask;
-
-    // ring is empty
-    if (writer_head == reader_tail) {
-        return false;
-    }
-
-    // now try to commit it
-    ATOMIC_SET(&ring->reader_tail, reader_tail, reader_next);
-
-    *outputDataPtr = ring->buffer[reader_tail];
-
-    // for sanity's sake
-    ring->buffer[reader_tail] = NULL;
-
-    return true;
-}
-
-uint32_t
-parcRingBuffer1x1_Remaining(PARCRingBuffer1x1 *ring)
-{
-    uint32_t writer_head = ATOMIC_FETCH(&ring->writer_head);
-    uint32_t reader_tail = ATOMIC_FETCH(&ring->reader_tail);
-
-    return (ring->ring_mask + reader_tail - writer_head) & ring->ring_mask;
-}
diff --git a/libparc/parc/concurrent/parc_RingBuffer_1x1.h b/libparc/parc/concurrent/parc_RingBuffer_1x1.h
deleted file mode 100755
index 4fd48e6b..00000000
--- a/libparc/parc/concurrent/parc_RingBuffer_1x1.h
+++ /dev/null
@@ -1,143 +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 parc_RingBuffer_1x1.h
- * @ingroup threading
- * @brief A single producer, single consumer ring buffer
- *
- * This is useful for synchronizing two (and exactly two) threads in one direction.  The
- * implementation will use a lock-free algorithm.
- *
- * Complies with the PARCRingBuffer generic facade.
- *
- */
-
-#ifndef libparc_parc_RingBuffer_1x1_h
-#define libparc_parc_RingBuffer_1x1_h
-
-#include <stdbool.h>
-#include <stdint.h>
-
-struct parc_ringbuffer_1x1;
-typedef struct parc_ringbuffer_1x1 PARCRingBuffer1x1;
-
-/**< Will be called for each data item on destroy */
-typedef void (RingBufferEntryDestroyer)(void **entryPtr);
-
-/**
- * Creates a ring buffer of the given size, which must be a power of 2.
- *
- * The ring buffer can store up to (elements-1) items in the buffer.  The buffer can
- * be shared between multiple producers and consumers.  Each of them should be
- * given out from a call to {@link parcRingBuffer_Acquire} to create reference counted
- * copies.
- *
- * The reference count is "1" on return.
- *
- * @param [in] elements A power of 2, indicating the maximum size of the buffer.
- * @param [in] destroyer Will be called for each ring entry when when the ring is destroyed.  May be null.
- *
- * @return non-null An allocated ring buffer.
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-PARCRingBuffer1x1 *parcRingBuffer1x1_Create(uint32_t elements, RingBufferEntryDestroyer *destroyer);
-
-/**
- * A reference counted copy of the buffer.
- *
- * A RING WITHOUT LOCKS CAN ONLY HAVE 2 REFERENCES.
- *
- * @param [in] ring The instance of `PARCRingBuffer1x1` to acquire.
- *
- * @return non-null A reference counted copy of the ring buffer.
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-PARCRingBuffer1x1 *parcRingBuffer1x1_Acquire(const PARCRingBuffer1x1 *ring);
-
-/**
- * Releases a reference.  The buffer will be destroyed after the last release.
- *
- * If the destroyer was specified on create, it will be called on each entry in the buffer
- * when the buffer is destroyed.
- *
- * @param [in,out] ringPtr The pointer to the pointer of the `PARCRingBuffer1x1` to be released.
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-void parcRingBuffer1x1_Release(PARCRingBuffer1x1 **ringPtr);
-
-/**
- * Non-blocking attempt to put item on ring.  May return `false` if ring is full.
- *
- * @param [in,out] ring The instance of `PARCRingBuffer1x1` on which to put the @p data.
- * @param [in] data The data to put on the @p ring.
- *
- * @return `true` Data was put on the queue
- * @return `false` Would have blocked, the queue was full
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-bool parcRingBuffer1x1_Put(PARCRingBuffer1x1 *ring, void *data);
-
-/**
- * Gets the next item off the ring, or returns false if would have blocked.
- *
- * Non-blocking, gets an item off the ring, or returns false if would block
- *
- * @param [in] ring The ring buffer
- * @param [out] outputDataPtr The output pointer
- *
- * @return true Data returned in the output argument
- * @return false Ring is empty, no data returned.
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-bool parcRingBuffer1x1_Get(PARCRingBuffer1x1 *ring, void **outputDataPtr);
-
-/**
- * Returns the remaining capacity of the ring
- *
- * Returns the remaining capacity of the ring.  This does not guarantee the next
- * Put will not block, as other producers might consumer the space between calls.
- *
- * @param [in] ring The instance of `PARCRingBuffer1x1` .
- *
- * @return The remaining capacity on the ring.
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-uint32_t parcRingBuffer1x1_Remaining(PARCRingBuffer1x1 *ring);
-#endif // libparc_parc_RingBuffer_1x1_h
diff --git a/libparc/parc/concurrent/parc_RingBuffer_NxM.c b/libparc/parc/concurrent/parc_RingBuffer_NxM.c
deleted file mode 100755
index 4ea69e58..00000000
--- a/libparc/parc/concurrent/parc_RingBuffer_NxM.c
+++ /dev/null
@@ -1,167 +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.
- */
-
-/**
- * A thread-safe fixed size ring buffer.
- *
- * The multiple producer, multiple consumer version uses a pthread mutex around a NxM ring buffer.
- *
- */
-
-#include <config.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <pthread.h>
-#include <errno.h>
-#include <string.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Object.h>
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/concurrent/parc_RingBuffer_1x1.h>
-#include <parc/concurrent/parc_RingBuffer_NxM.h>
-
-struct parc_ringbuffer_NxM {
-    PARCRingBuffer1x1 *onebyone;
-
-    // This protectes the overall data structure for Acquire and Release
-    pthread_mutex_t allocation_mutex;
-
-    pthread_mutex_t writer_mutex;
-    pthread_mutex_t reader_mutex;
-
-    RingBufferEntryDestroyer *destroyer;
-};
-
-/*
- * Attemps a lock and returns false if we cannot get it.
- *
- * @endcode
- */
-static bool
-_lock(pthread_mutex_t *mutex)
-{
-    int failure = pthread_mutex_lock(mutex);
-    parcAssertFalse(failure, "Error locking mutex: (%d) %s\n", errno, strerror(errno));
-    return true;
-}
-
-static bool
-_unlock(pthread_mutex_t *mutex)
-{
-    int failure = pthread_mutex_unlock(mutex);
-    parcAssertFalse(failure, "Error unlocking mutex: (%d) %s\n", errno, strerror(errno));
-    return true;
-}
-
-static void
-_destroy(PARCRingBufferNxM **ringptr)
-{
-    PARCRingBufferNxM *ring = *ringptr;
-
-    if (ring->destroyer) {
-        void *ptr = NULL;
-        while (parcRingBufferNxM_Get(ring, &ptr)) {
-            ring->destroyer(&ptr);
-        }
-    }
-    parcRingBuffer1x1_Release(&ring->onebyone);
-}
-
-
-parcObject_ExtendPARCObject(PARCRingBufferNxM, _destroy, NULL, NULL, NULL, NULL, NULL, NULL);
-
-static PARCRingBufferNxM *
-_create(uint32_t elements, RingBufferEntryDestroyer *destroyer)
-{
-    PARCRingBufferNxM *ring = parcObject_CreateInstance(PARCRingBufferNxM);
-    parcAssertNotNull(ring, "parcObject_Create returned NULL");
-
-    ring->onebyone = parcRingBuffer1x1_Create(elements, destroyer);
-    ring->destroyer = destroyer;
-    pthread_mutex_init(&ring->allocation_mutex, NULL);
-    pthread_mutex_init(&ring->writer_mutex, NULL);
-    pthread_mutex_init(&ring->reader_mutex, NULL);
-    return ring;
-}
-
-PARCRingBufferNxM *
-parcRingBufferNxM_Create(uint32_t elements, RingBufferEntryDestroyer *destroyer)
-{
-    return _create(elements, destroyer);
-}
-
-PARCRingBufferNxM *
-parcRingBufferNxM_Acquire(PARCRingBufferNxM *ring)
-{
-    PARCRingBufferNxM *acquired;
-
-    _lock(&ring->allocation_mutex);
-    acquired = parcObject_Acquire(ring);
-    _unlock(&ring->allocation_mutex);
-
-    return acquired;
-}
-
-void
-parcRingBufferNxM_Release(PARCRingBufferNxM **ringPtr)
-{
-    PARCRingBufferNxM *ring = *ringPtr;
-    _lock(&ring->allocation_mutex);
-    parcObject_Release((void **) ringPtr);
-    _unlock(&ring->allocation_mutex);
-}
-
-/**
- * Put is protected by the writer mutex.  This means that the tail mutex could
- * actually increase while this is happening. That's ok.  Increasing the tail
- * just means there is _more_ room in the ring.  We only modify writer_head.
- */
-bool
-parcRingBufferNxM_Put(PARCRingBufferNxM *ring, void *data)
-{
-    // **** LOCK
-    _lock(&ring->writer_mutex);
-    bool success = parcRingBuffer1x1_Put(ring->onebyone, data);
-    // **** UNLOCK
-    _unlock(&ring->writer_mutex);
-    return success;
-}
-
-bool
-parcRingBufferNxM_Get(PARCRingBufferNxM *ring, void **outputDataPtr)
-{
-    // **** LOCK
-    _lock(&ring->reader_mutex);
-    bool success = parcRingBuffer1x1_Get(ring->onebyone, outputDataPtr);
-    // **** UNLOCK
-    _unlock(&ring->reader_mutex);
-    return success;
-}
-
-uint32_t
-parcRingBufferNxM_Remaining(PARCRingBufferNxM *ring)
-{
-    _lock(&ring->writer_mutex);
-    _lock(&ring->reader_mutex);
-
-    uint32_t remaining = parcRingBuffer1x1_Remaining(ring->onebyone);
-
-    _unlock(&ring->reader_mutex);
-    _unlock(&ring->writer_mutex);
-
-    return remaining;
-}
diff --git a/libparc/parc/concurrent/parc_RingBuffer_NxM.h b/libparc/parc/concurrent/parc_RingBuffer_NxM.h
deleted file mode 100755
index 8cf38fdc..00000000
--- a/libparc/parc/concurrent/parc_RingBuffer_NxM.h
+++ /dev/null
@@ -1,146 +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 parc_RingBuffer_NxM.h
- * @ingroup threading
- * @brief A multiple producer, multiple consumer ring buffer
- *
- * This is useful for synchronizing one or more producers with one or more consumers.
- * The implementation may use locks.
- *
- * Complies with the PARCRingBuffer generic facade.
- *
- */
-
-#ifndef libparc_parc_RingBuffer_NxM_h
-#define libparc_parc_RingBuffer_NxM_h
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <parc/concurrent/parc_RingBuffer_1x1.h>
-
-struct parc_ringbuffer_NxM;
-/**
- * @typedef PARCRingBufferNxM
- */
-typedef struct parc_ringbuffer_NxM PARCRingBufferNxM;
-
-/**
- * Creates a ring buffer of the given size, which must be a power of 2.
- *
- * The ring buffer can store up to (elements-1) items in the buffer.  The buffer can
- * be shared between multiple producers and consumers.  Each of them should be
- * given out from a call to {@link parcRingBuffer_Acquire} to create reference counted
- * copies.
- *
- * The reference count is "1" on return.
- *
- * @param [in] elements A power of 2, indicating the maximum size of the buffer.
- * @param [in] destroyer Will be called for each ring entry when when the ring is destroyed.  May be null.
- *
- * @return non-null An allocated ring buffer.
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-PARCRingBufferNxM *parcRingBufferNxM_Create(uint32_t elements, RingBufferEntryDestroyer *destroyer);
-
-/**
- * A reference counted copy of the buffer.
- *
- * A RING WITHOUT LOCKS CAN ONLY HAVE 2 REFERENCES.
- *
- * @param [in] ring A pointer to the `PARCRingBufferNxM` to be acquired.
- *
- * @return non-null A reference counted copy of the ring buffer
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-PARCRingBufferNxM *parcRingBufferNxM_Acquire(PARCRingBufferNxM *ring);
-
-/**
- * Releases a reference.  The buffer will be destroyed after the last release.
- *
- * If the destroyer was specified on create, it will be called on each entry in the buffer
- * when the buffer is destroyed.
- *
- * @param [in,out] ringPtr A pointer to the pointer to the `PARCRingBufferNxM` to be released.
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-void parcRingBufferNxM_Release(PARCRingBufferNxM **ringPtr);
-
-/**
- * Non-blocking attempt to put item on ring.  May return false if ring is full.
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [in,out] ring A pointer to the `PARCRingBufferNxM` on which to put @p data.
- * @param [in] data A pointer to data to put on @p ring.
- *
- * @return `true` Data was put on the queue
- * @return `false` Would have blocked, the queue was full
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-bool parcRingBufferNxM_Put(PARCRingBufferNxM *ring, void *data);
-
-/**
- * Gets the next item off the ring, or returns false if would have blocked.
- *
- * Non-blocking, gets an item off the ring, or returns false if would block
- *
- * @param [in] ring The ring buffer
- * @param [out] outputDataPtr The output pointer
- *
- * @return `true` Data returned in the output argument
- * @return `false` Ring is empty, no data returned.
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-bool parcRingBufferNxM_Get(PARCRingBufferNxM *ring, void **outputDataPtr);
-
-/**
- * Returns the remaining capacity of the ring
- *
- * Returns the remaining capacity of the ring.  This does not guarantee the next
- * Put will not block, as other producers might consumer the space between calls.
- *
- * @param [in] ring The ring buffer
- *
- * @return the remaining capacity of @p ring.
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-uint32_t parcRingBufferNxM_Remaining(PARCRingBufferNxM *ring);
-#endif // libparc_parc_RingBuffer_NxM_h
diff --git a/libparc/parc/concurrent/parc_ScheduledTask.c b/libparc/parc/concurrent/parc_ScheduledTask.c
deleted file mode 100755
index 4875abf7..00000000
--- a/libparc/parc/concurrent/parc_ScheduledTask.c
+++ /dev/null
@@ -1,203 +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 <config.h>
-#include <sys/time.h>
-
-#include <parc/algol/parc_Object.h>
-#include <parc/algol/parc_DisplayIndented.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Time.h>
-
-#include <parc/concurrent/parc_ScheduledTask.h>
-#include <parc/concurrent/parc_FutureTask.h>
-
-struct PARCScheduledTask {
-    PARCFutureTask *task;
-    uint64_t executionTime;
-};
-
-static bool
-_parcScheduledTask_Destructor(PARCScheduledTask **instancePtr)
-{
-    parcAssertNotNull(instancePtr, "Parameter must be a non-null pointer to a PARCScheduledTask pointer.");
-    PARCScheduledTask *task = *instancePtr;
-
-    parcFutureTask_Release(&task->task);
-    return true;
-}
-
-parcObject_ImplementAcquire(parcScheduledTask, PARCScheduledTask);
-
-parcObject_ImplementRelease(parcScheduledTask, PARCScheduledTask);
-
-parcObject_Override(PARCScheduledTask, PARCObject,
-                    .isLockable = true,
-                    .destructor = (PARCObjectDestructor *) _parcScheduledTask_Destructor,
-                    .copy = (PARCObjectCopy *) parcScheduledTask_Copy,
-                    .toString = (PARCObjectToString *) parcScheduledTask_ToString,
-                    .equals = (PARCObjectEquals *) parcScheduledTask_Equals,
-                    .compare = (PARCObjectCompare *) parcScheduledTask_Compare,
-                    .hashCode = (PARCObjectHashCode *) parcScheduledTask_HashCode,
-                    .display = (PARCObjectDisplay *) parcScheduledTask_Display);
-
-void
-parcScheduledTask_AssertValid(const PARCScheduledTask *instance)
-{
-    parcAssertTrue(parcScheduledTask_IsValid(instance),
-               "PARCScheduledTask is not valid.");
-}
-
-
-PARCScheduledTask *
-parcScheduledTask_Create(PARCFutureTask *task, uint64_t executionTime)
-{
-    PARCScheduledTask *result = parcObject_CreateInstance(PARCScheduledTask);
-
-    if (result != NULL) {
-        result->task = parcFutureTask_Acquire(task);
-        result->executionTime = executionTime;
-    }
-
-    return result;
-}
-
-int
-parcScheduledTask_Compare(const PARCScheduledTask *instance, const PARCScheduledTask *other)
-{
-    int result = 0;
-
-    return result;
-}
-
-PARCScheduledTask *
-parcScheduledTask_Copy(const PARCScheduledTask *original)
-{
-    PARCScheduledTask *result = parcScheduledTask_Create(original->task, original->executionTime);
-
-    return result;
-}
-
-void
-parcScheduledTask_Display(const PARCScheduledTask *instance, int indentation)
-{
-    parcDisplayIndented_PrintLine(indentation, "PARCScheduledTask@%p {", instance);
-    /* Call Display() functions for the fields here. */
-    parcDisplayIndented_PrintLine(indentation, "}");
-}
-
-bool
-parcScheduledTask_Equals(const PARCScheduledTask *x, const PARCScheduledTask *y)
-{
-    bool result = false;
-
-    if (x == y) {
-        result = true;
-    } else if (x == NULL || y == NULL) {
-        result = false;
-    } else {
-        if (parcFutureTask_Equals(x->task, y->task)) {
-            if (x->executionTime == y->executionTime) {
-                result = true;
-            }
-        }
-    }
-
-    return result;
-}
-
-PARCHashCode
-parcScheduledTask_HashCode(const PARCScheduledTask *instance)
-{
-    PARCHashCode result = 0;
-
-    return result;
-}
-
-bool
-parcScheduledTask_IsValid(const PARCScheduledTask *instance)
-{
-    bool result = false;
-
-    if (instance != NULL) {
-        result = true;
-    }
-
-    return result;
-}
-
-PARCJSON *
-parcScheduledTask_ToJSON(const PARCScheduledTask *instance)
-{
-    PARCJSON *result = parcJSON_Create();
-
-    if (result != NULL) {
-    }
-
-    return result;
-}
-
-char *
-parcScheduledTask_ToString(const PARCScheduledTask *instance)
-{
-    char *result = parcMemory_Format("PARCScheduledTask@%p\n", instance);
-
-    return result;
-}
-
-uint64_t
-parcScheduledTask_GetExecutionTime(const PARCScheduledTask *task)
-{
-    return task->executionTime;
-}
-
-bool
-parcScheduledTask_Cancel(PARCScheduledTask *task, bool mayInterruptIfRunning)
-{
-    return parcFutureTask_Cancel(task->task, mayInterruptIfRunning);
-}
-
-PARCFutureTaskResult
-parcScheduledTask_Get(const PARCScheduledTask *task, const PARCTimeout *timeout)
-{
-    return parcFutureTask_Get(task->task, timeout);
-}
-
-PARCFutureTask *
-parcScheduledTask_GetTask(const PARCScheduledTask *task)
-{
-    return task->task;
-}
-
-void *
-parcScheduledTask_Run(const PARCScheduledTask *task)
-{
-    return parcFutureTask_Run(task->task);
-}
-
-bool
-parcScheduledTask_IsCancelled(const PARCScheduledTask *task)
-{
-    return parcFutureTask_IsCancelled(task->task);
-}
-
-bool
-parcScheduledTask_IsDone(const PARCScheduledTask *task)
-{
-    return parcFutureTask_IsDone(task->task);
-}
diff --git a/libparc/parc/concurrent/parc_ScheduledTask.h b/libparc/parc/concurrent/parc_ScheduledTask.h
deleted file mode 100755
index e56fb5f5..00000000
--- a/libparc/parc/concurrent/parc_ScheduledTask.h
+++ /dev/null
@@ -1,467 +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 parc_ScheduledTask.h
- * @ingroup threading
- * @brief <#Brief Description#>
- *
- * <#Detailed Description#>
- *
- */
-#ifndef PARCLibrary_parc_ScheduledTask
-#define PARCLibrary_parc_ScheduledTask
-#include <stdbool.h>
-#include <stdint.h>
-
-#include <parc/algol/parc_JSON.h>
-#include <parc/algol/parc_HashCode.h>
-#include <parc/concurrent/parc_FutureTask.h>
-#include <parc/concurrent/parc_Timeout.h>
-
-struct PARCScheduledTask;
-typedef struct PARCScheduledTask PARCScheduledTask;
-
-/**
- * Increase the number of references to a `PARCScheduledTask` instance.
- *
- * Note that new `PARCScheduledTask` is not created,
- * only that the given `PARCScheduledTask` reference count is incremented.
- * Discard the reference by invoking `parcScheduledTask_Release`.
- *
- * @param [in] instance A pointer to a valid PARCScheduledTask instance.
- *
- * @return The same value as @p instance.
- *
- * Example:
- * @code
- * {
- *     PARCScheduledTask *a = parcScheduledTask_Create();
- *
- *     PARCScheduledTask *b = parcScheduledTask_Acquire();
- *
- *     parcScheduledTask_Release(&a);
- *     parcScheduledTask_Release(&b);
- * }
- * @endcode
- */
-PARCScheduledTask *parcScheduledTask_Acquire(const PARCScheduledTask *instance);
-
-#ifdef PARCLibrary_DISABLE_VALIDATION
-#  define parcScheduledTask_OptionalAssertValid(_instance_)
-#else
-#  define parcScheduledTask_OptionalAssertValid(_instance_) parcScheduledTask_AssertValid(_instance_)
-#endif
-
-/**
- * Assert that the given `PARCScheduledTask` instance is valid.
- *
- * @param [in] instance A pointer to a valid PARCScheduledTask instance.
- *
- * Example:
- * @code
- * {
- *     PARCScheduledTask *a = parcScheduledTask_Create();
- *
- *     parcScheduledTask_AssertValid(a);
- *
- *     printf("Instance is valid.\n");
- *
- *     parcScheduledTask_Release(&b);
- * }
- * @endcode
- */
-void parcScheduledTask_AssertValid(const PARCScheduledTask *instance);
-
-/**
- * Create an instance of PARCScheduledTask
- *
- * <#Paragraphs Of Explanation#>
- *
- * @return non-NULL A pointer to a valid PARCScheduledTask instance.
- * @return NULL An error occurred.
- *
- * Example:
- * @code
- * {
- *     PARCScheduledTask *a = parcScheduledTask_Create();
- *
- *     parcScheduledTask_Release(&a);
- * }
- * @endcode
- */
-PARCScheduledTask *parcScheduledTask_Create(PARCFutureTask *task, uint64_t executionTime);
-
-/**
- * Compares @p instance with @p other for order.
- *
- * Returns a negative integer, zero, or a positive integer as @p instance
- * is less than, equal to, or greater than @p other.
- *
- * @param [in] instance A pointer to a valid PARCScheduledTask instance.
- * @param [in] other A pointer to a valid PARCScheduledTask instance.
- *
- * @return <0 Instance is less than @p other.
- * @return 0 Instance a and instance b compare the same.
- * @return >0 Instance a is greater than instance b.
- *
- * Example:
- * @code
- * {
- *     PARCScheduledTask *a = parcScheduledTask_Create();
- *     PARCScheduledTask *b = parcScheduledTask_Create();
- *
- *     if (parcScheduledTask_Compare(a, b) == 0) {
- *         printf("Instances are equal.\n");
- *     }
- *
- *     parcScheduledTask_Release(&a);
- *     parcScheduledTask_Release(&b);
- * }
- * @endcode
- *
- * @see parcScheduledTask_Equals
- */
-int parcScheduledTask_Compare(const PARCScheduledTask *instance, const PARCScheduledTask *other);
-
-/**
- * Create an independent copy the given `PARCBuffer`
- *
- * A new buffer is created as a complete copy of the original.
- *
- * @param [in] original A pointer to a valid PARCScheduledTask instance.
- *
- * @return NULL Memory could not be allocated.
- * @return non-NULL A pointer to a new `PARCScheduledTask` instance.
- *
- * Example:
- * @code
- * {
- *     PARCScheduledTask *a = parcScheduledTask_Create();
- *
- *     PARCScheduledTask *copy = parcScheduledTask_Copy(&b);
- *
- *     parcScheduledTask_Release(&b);
- *     parcScheduledTask_Release(&copy);
- * }
- * @endcode
- */
-PARCScheduledTask *parcScheduledTask_Copy(const PARCScheduledTask *original);
-
-/**
- * Print a human readable representation of the given `PARCScheduledTask`.
- *
- * @param [in] instance A pointer to a valid PARCScheduledTask instance.
- * @param [in] indentation The indentation level to use for printing.
- *
- * Example:
- * @code
- * {
- *     PARCScheduledTask *a = parcScheduledTask_Create();
- *
- *     parcScheduledTask_Display(a, 0);
- *
- *     parcScheduledTask_Release(&a);
- * }
- * @endcode
- */
-void parcScheduledTask_Display(const PARCScheduledTask *instance, int indentation);
-
-/**
- * Determine if two `PARCScheduledTask` instances are equal.
- *
- * The following equivalence relations on non-null `PARCScheduledTask` instances are maintained: *
- *   * It is reflexive: for any non-null reference value x, `parcScheduledTask_Equals(x, x)` must return true.
- *
- *   * It is symmetric: for any non-null reference values x and y, `parcScheduledTask_Equals(x, y)` must return true if and only if
- *        `parcScheduledTask_Equals(y x)` returns true.
- *
- *   * It is transitive: for any non-null reference values x, y, and z, if
- *        `parcScheduledTask_Equals(x, y)` returns true and
- *        `parcScheduledTask_Equals(y, z)` returns true,
- *        then `parcScheduledTask_Equals(x, z)` must return true.
- *
- *   * It is consistent: for any non-null reference values x and y, multiple invocations of `parcScheduledTask_Equals(x, y)`
- *         consistently return true or consistently return false.
- *
- *   * For any non-null reference value x, `parcScheduledTask_Equals(x, NULL)` must return false.
- *
- * @param [in] x A pointer to a valid PARCScheduledTask instance.
- * @param [in] y A pointer to a valid PARCScheduledTask instance.
- *
- * @return true The instances x and y are equal.
- *
- * Example:
- * @code
- * {
- *     PARCScheduledTask *a = parcScheduledTask_Create();
- *     PARCScheduledTask *b = parcScheduledTask_Create();
- *
- *     if (parcScheduledTask_Equals(a, b)) {
- *         printf("Instances are equal.\n");
- *     }
- *
- *     parcScheduledTask_Release(&a);
- *     parcScheduledTask_Release(&b);
- * }
- * @endcode
- * @see parcScheduledTask_HashCode
- */
-bool parcScheduledTask_Equals(const PARCScheduledTask *x, const PARCScheduledTask *y);
-
-/**
- * Returns a hash code value for the given instance.
- *
- * The general contract of `HashCode` is:
- *
- * Whenever it is invoked on the same instance more than once during an execution of an application,
- * the `HashCode` function must consistently return the same value,
- * provided no information used in a corresponding comparisons on the instance is modified.
- *
- * This value need not remain consistent from one execution of an application to another execution of the same application.
- * If two instances are equal according to the {@link parcScheduledTask_Equals} method,
- * then calling the {@link parcScheduledTask_HashCode} method on each of the two instances must produce the same integer result.
- *
- * It is not required that if two instances are unequal according to the
- * {@link parcScheduledTask_Equals} function,
- * then calling the `parcScheduledTask_HashCode`
- * method on each of the two objects must produce distinct integer results.
- *
- * @param [in] instance A pointer to a valid PARCScheduledTask instance.
- *
- * @return The hashcode for the given instance.
- *
- * Example:
- * @code
- * {
- *     PARCScheduledTask *a = parcScheduledTask_Create();
- *
- *     PARCHashCode hashValue = parcScheduledTask_HashCode(buffer);
- *     parcScheduledTask_Release(&a);
- * }
- * @endcode
- */
-PARCHashCode parcScheduledTask_HashCode(const PARCScheduledTask *instance);
-
-/**
- * Determine if an instance of `PARCScheduledTask` is valid.
- *
- * Valid means the internal state of the type is consistent with its required current or future behaviour.
- * This may include the validation of internal instances of types.
- *
- * @param [in] instance A pointer to a valid PARCScheduledTask instance.
- *
- * @return true The instance is valid.
- * @return false The instance is not valid.
- *
- * Example:
- * @code
- * {
- *     PARCScheduledTask *a = parcScheduledTask_Create();
- *
- *     if (parcScheduledTask_IsValid(a)) {
- *         printf("Instance is valid.\n");
- *     }
- *
- *     parcScheduledTask_Release(&a);
- * }
- * @endcode
- *
- */
-bool parcScheduledTask_IsValid(const PARCScheduledTask *instance);
-
-/**
- * Release a previously acquired reference to the given `PARCScheduledTask` instance,
- * decrementing the reference count for the instance.
- *
- * The pointer to the instance is set to NULL as a side-effect of this function.
- *
- * If the invocation causes the last reference to the instance to be released,
- * the instance is deallocated and the instance's implementation will perform
- * additional cleanup and release other privately held references.
- *
- * @param [in,out] instancePtr A pointer to a pointer to the instance to release.
- *
- * Example:
- * @code
- * {
- *     PARCScheduledTask *a = parcScheduledTask_Create();
- *
- *     parcScheduledTask_Release(&a);
- * }
- * @endcode
- */
-void parcScheduledTask_Release(PARCScheduledTask **instancePtr);
-
-/**
- * Create a `PARCJSON` instance (representation) of the given object.
- *
- * @param [in] instance A pointer to a valid PARCScheduledTask instance.
- *
- * @return NULL Memory could not be allocated to contain the `PARCJSON` instance.
- * @return non-NULL An allocated C string that must be deallocated via parcMemory_Deallocate().
- *
- * Example:
- * @code
- * {
- *     PARCScheduledTask *a = parcScheduledTask_Create();
- *
- *     PARCJSON *json = parcScheduledTask_ToJSON(a);
- *
- *     printf("JSON representation: %s\n", parcJSON_ToString(json));
- *     parcJSON_Release(&json);
- *
- *     parcScheduledTask_Release(&a);
- * }
- * @endcode
- */
-PARCJSON *parcScheduledTask_ToJSON(const PARCScheduledTask *instance);
-
-/**
- * Produce a null-terminated string representation of the specified `PARCScheduledTask`.
- *
- * The result must be freed by the caller via {@link parcMemory_Deallocate}.
- *
- * @param [in] instance A pointer to a valid PARCScheduledTask instance.
- *
- * @return NULL Cannot allocate memory.
- * @return non-NULL A pointer to an allocated, null-terminated C string that must be deallocated via {@link parcMemory_Deallocate}.
- *
- * Example:
- * @code
- * {
- *     PARCScheduledTask *a = parcScheduledTask_Create();
- *
- *     char *string = parcScheduledTask_ToString(a);
- *
- *     parcScheduledTask_Release(&a);
- *
- *     parcMemory_Deallocate(&string);
- * }
- * @endcode
- *
- * @see parcScheduledTask_Display
- */
-char *parcScheduledTask_ToString(const PARCScheduledTask *instance);
-
-/**
- * Returns the remaining delay associated with this object.
- *
- * @param [in] task A pointer to a valid PARCScheduledTask instance.
- *
- * @return the remaining delay; zero or negative values indicate that the delay has already elapsed
- *
- * Example:
- * @code
- * {
- *     <#example#>
- * }
- * @endcode
- */
-uint64_t parcScheduledTask_GetExecutionTime(const PARCScheduledTask *task);
-
-/**
- * Attempts to cancel execution of this task.
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [<#in#> | <#out#> | <#in,out#>] <#name#> <#description#>
- *
- * @return <#value#> <#explanation#>
- *
- * Example:
- * @code
- * {
- *     <#example#>
- * }
- * @endcode
- */
-bool parcScheduledTask_Cancel(PARCScheduledTask *task, bool mayInterruptIfRunning);
-
-/**
- * Waits if necessary for at most the given time for the computation to complete, and then retrieves its result, if available.
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [<#in#> | <#out#> | <#in,out#>] <#name#> <#description#>
- *
- * @return <#value#> <#explanation#>
- *
- * Example:
- * @code
- * {
- *     <#example#>
- * }
- * @endcode
- */
-PARCFutureTaskResult parcScheduledTask_Get(const PARCScheduledTask *task, const PARCTimeout *timeout);
-
-
-void *parcScheduledTask_Run(const PARCScheduledTask *task);
-
-
-/**
- * Get the `PARCFutureTask` instance for the given `PARCScheduledTask`
- *
- * @param [in] task A pointer to a valid `PARCScheduledTask` instance.
- *
- * @return the `PARCFutureTask` instance for the given `PARCScheduledTask`
- *
- * Example:
- * @code
- * {
- *     <#example#>
- * }
- * @endcode
- */
-PARCFutureTask *parcScheduledTask_GetTask(const PARCScheduledTask *task);
-
-/**
- * Returns true if this task was cancelled before it completed normally.
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [<#in#> | <#out#> | <#in,out#>] <#name#> <#description#>
- *
- * @return <#value#> <#explanation#>
- *
- * Example:
- * @code
- * {
- *     <#example#>
- * }
- * @endcode
- */
-bool parcScheduledTask_IsCancelled(const PARCScheduledTask *task);
-
-/**
- * Returns true if this task completed.
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [<#in#> | <#out#> | <#in,out#>] <#name#> <#description#>
- *
- * @return <#value#> <#explanation#>
- *
- * Example:
- * @code
- * {
- *     <#example#>
- * }
- * @endcode
- */
-bool parcScheduledTask_IsDone(const PARCScheduledTask *task);
-#endif
diff --git a/libparc/parc/concurrent/parc_ScheduledThreadPool.c b/libparc/parc/concurrent/parc_ScheduledThreadPool.c
deleted file mode 100644
index 0b77372e..00000000
--- a/libparc/parc/concurrent/parc_ScheduledThreadPool.c
+++ /dev/null
@@ -1,323 +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 <config.h>
-#include <stdio.h>
-
-#include <parc/algol/parc_Object.h>
-#include <parc/algol/parc_DisplayIndented.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_SortedList.h>
-#include <parc/algol/parc_LinkedList.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Time.h>
-
-#include <parc/concurrent/parc_ScheduledThreadPool.h>
-#include <parc/concurrent/parc_Thread.h>
-#include <parc/concurrent/parc_ThreadPool.h>
-
-struct PARCScheduledThreadPool {
-    bool continueExistingPeriodicTasksAfterShutdown;
-    bool executeExistingDelayedTasksAfterShutdown;
-    bool removeOnCancel;
-    PARCSortedList *workQueue;
-    PARCThread *workerThread;
-    PARCThreadPool *threadPool;
-    int poolSize;
-};
-
-static void *
-_workerThread(PARCThread *thread, PARCScheduledThreadPool *pool)
-{
-    while (parcThread_IsCancelled(thread) == false) {
-        if (parcSortedList_Lock(pool->workQueue)) {
-            if (parcSortedList_Size(pool->workQueue) > 0) {
-                PARCScheduledTask *task = parcSortedList_GetFirst(pool->workQueue);
-                int64_t executionDelay = parcScheduledTask_GetExecutionTime(task) - parcTime_NowNanoseconds();
-                if (task != NULL && executionDelay <= 0) {
-                    parcSortedList_RemoveFirst(pool->workQueue);
-                    parcSortedList_Unlock(pool->workQueue);
-                    parcThreadPool_Execute(pool->threadPool, parcScheduledTask_GetTask(task));
-                    parcScheduledTask_Release(&task);
-                    parcSortedList_Lock(pool->workQueue);
-
-                    parcSortedList_Notify(pool->workQueue);
-                } else {
-                    parcSortedList_WaitFor(pool->workQueue, executionDelay);
-                }
-            } else {
-                parcSortedList_Wait(pool->workQueue);
-            }
-        }
-        parcSortedList_Unlock(pool->workQueue);
-    }
-
-    return NULL;
-}
-
-static bool
-_parcScheduledThreadPool_Destructor(PARCScheduledThreadPool **instancePtr)
-{
-    parcAssertNotNull(instancePtr, "Parameter must be a non-null pointer to a PARCScheduledThreadPool pointer.");
-    PARCScheduledThreadPool *pool = *instancePtr;
-    parcThreadPool_Release(&pool->threadPool);
-
-    parcThread_Release(&pool->workerThread);
-
-    if (parcObject_Lock(pool->workQueue)) {
-        parcSortedList_Release(&pool->workQueue);
-    } else {
-        parcAssertTrue(false, "Cannot lock the work queue.");
-    }
-
-    return true;
-}
-
-parcObject_ImplementAcquire(parcScheduledThreadPool, PARCScheduledThreadPool);
-
-parcObject_ImplementRelease(parcScheduledThreadPool, PARCScheduledThreadPool);
-
-parcObject_Override(PARCScheduledThreadPool, PARCObject,
-                    .isLockable = true,
-                    .destructor = (PARCObjectDestructor *) _parcScheduledThreadPool_Destructor,
-                    .copy = (PARCObjectCopy *) parcScheduledThreadPool_Copy,
-                    .toString = (PARCObjectToString *) parcScheduledThreadPool_ToString,
-                    .equals = (PARCObjectEquals *) parcScheduledThreadPool_Equals,
-                    .compare = (PARCObjectCompare *) parcScheduledThreadPool_Compare,
-                    .hashCode = (PARCObjectHashCode *) parcScheduledThreadPool_HashCode);
-
-void
-parcScheduledThreadPool_AssertValid(const PARCScheduledThreadPool *instance)
-{
-    parcAssertTrue(parcScheduledThreadPool_IsValid(instance),
-               "PARCScheduledThreadPool is not valid.");
-}
-
-PARCScheduledThreadPool *
-parcScheduledThreadPool_Create(int poolSize)
-{
-    PARCScheduledThreadPool *result = parcObject_CreateInstance(PARCScheduledThreadPool);
-
-    if (result != NULL) {
-        result->poolSize = poolSize;
-        result->workQueue = parcSortedList_Create();
-        result->threadPool = parcThreadPool_Create(poolSize);
-
-        result->continueExistingPeriodicTasksAfterShutdown = false;
-        result->executeExistingDelayedTasksAfterShutdown = false;
-        result->removeOnCancel = true;
-
-        if (parcObject_Lock(result)) {
-            result->workerThread = parcThread_Create((void *(*)(PARCThread *, PARCObject *))_workerThread, (PARCObject *) result);
-            parcThread_Start(result->workerThread);
-            parcObject_Unlock(result);
-        }
-    }
-
-    return result;
-}
-
-int
-parcScheduledThreadPool_Compare(const PARCScheduledThreadPool *instance, const PARCScheduledThreadPool *other)
-{
-    int result = 0;
-
-    return result;
-}
-
-PARCScheduledThreadPool *
-parcScheduledThreadPool_Copy(const PARCScheduledThreadPool *original)
-{
-    PARCScheduledThreadPool *result = parcScheduledThreadPool_Create(original->poolSize);
-
-    return result;
-}
-
-void
-parcScheduledThreadPool_Display(const PARCScheduledThreadPool *instance, int indentation)
-{
-    parcDisplayIndented_PrintLine(indentation, "PARCScheduledThreadPool@%p {", instance);
-    /* Call Display() functions for the fields here. */
-    parcDisplayIndented_PrintLine(indentation, "}");
-}
-
-bool
-parcScheduledThreadPool_Equals(const PARCScheduledThreadPool *x, const PARCScheduledThreadPool *y)
-{
-    bool result = false;
-
-    if (x == y) {
-        result = true;
-    } else if (x == NULL || y == NULL) {
-        result = false;
-    } else {
-        if (x->poolSize == y->poolSize) {
-            result = true;
-        }
-    }
-
-    return result;
-}
-
-PARCHashCode
-parcScheduledThreadPool_HashCode(const PARCScheduledThreadPool *instance)
-{
-    PARCHashCode result = 0;
-
-    return result;
-}
-
-bool
-parcScheduledThreadPool_IsValid(const PARCScheduledThreadPool *instance)
-{
-    bool result = false;
-
-    if (instance != NULL) {
-        result = true;
-    }
-
-    return result;
-}
-
-PARCJSON *
-parcScheduledThreadPool_ToJSON(const PARCScheduledThreadPool *instance)
-{
-    PARCJSON *result = parcJSON_Create();
-
-    if (result != NULL) {
-    }
-
-    return result;
-}
-
-char *
-parcScheduledThreadPool_ToString(const PARCScheduledThreadPool *instance)
-{
-    char *result = parcMemory_Format("PARCScheduledThreadPool@%p\n", instance);
-
-    return result;
-}
-
-void
-parcScheduledThreadPool_Execute(PARCScheduledThreadPool *pool, PARCFutureTask *command)
-{
-}
-
-bool
-parcScheduledThreadPool_GetContinueExistingPeriodicTasksAfterShutdownPolicy(PARCScheduledThreadPool *pool)
-{
-    return pool->continueExistingPeriodicTasksAfterShutdown;
-}
-
-bool
-parcScheduledThreadPool_GetExecuteExistingDelayedTasksAfterShutdownPolicy(PARCScheduledThreadPool *pool)
-{
-    return pool->executeExistingDelayedTasksAfterShutdown;
-}
-
-PARCSortedList *
-parcScheduledThreadPool_GetQueue(const PARCScheduledThreadPool *pool)
-{
-    return pool->workQueue;
-}
-
-bool
-parcScheduledThreadPool_GetRemoveOnCancelPolicy(const PARCScheduledThreadPool *pool)
-{
-    return pool->removeOnCancel;
-}
-
-PARCScheduledTask *
-parcScheduledThreadPool_Schedule(PARCScheduledThreadPool *pool, PARCFutureTask *task, const PARCTimeout *delay)
-{
-    uint64_t executionTime = parcTime_NowNanoseconds() + parcTimeout_InNanoSeconds(delay);
-
-    PARCScheduledTask *scheduledTask = parcScheduledTask_Create(task, executionTime);
-
-    if (parcSortedList_Lock(pool->workQueue)) {
-        parcSortedList_Add(pool->workQueue, scheduledTask);
-        parcScheduledTask_Release(&scheduledTask);
-        parcSortedList_Notify(pool->workQueue);
-        parcSortedList_Unlock(pool->workQueue);
-    }
-    return scheduledTask;
-}
-
-PARCScheduledTask *
-parcScheduledThreadPool_ScheduleAtFixedRate(PARCScheduledThreadPool *pool, PARCFutureTask *task, PARCTimeout initialDelay, PARCTimeout period)
-{
-    return NULL;
-}
-
-PARCScheduledTask *
-parcScheduledThreadPool_ScheduleWithFixedDelay(PARCScheduledThreadPool *pool, PARCFutureTask *task, PARCTimeout initialDelay, PARCTimeout delay)
-{
-    return NULL;
-}
-
-void
-parcScheduledThreadPool_SetContinueExistingPeriodicTasksAfterShutdownPolicy(PARCScheduledThreadPool *pool, bool value)
-{
-}
-
-void
-parcScheduledThreadPool_SetExecuteExistingDelayedTasksAfterShutdownPolicy(PARCScheduledThreadPool *pool, bool value)
-{
-}
-
-void
-parcScheduledThreadPool_SetRemoveOnCancelPolicy(PARCScheduledThreadPool *pool, bool value)
-{
-}
-
-void
-parcScheduledThreadPool_Shutdown(PARCScheduledThreadPool *pool)
-{
-    parcScheduledThreadPool_ShutdownNow(pool);
-}
-
-PARCList *
-parcScheduledThreadPool_ShutdownNow(PARCScheduledThreadPool *pool)
-{
-    parcThread_Cancel(pool->workerThread);
-
-    parcThreadPool_ShutdownNow(pool->threadPool);
-
-    // Wake them all up so they detect that they are cancelled.
-    if (parcObject_Lock(pool)) {
-        parcObject_NotifyAll(pool);
-        parcObject_Unlock(pool);
-    }
-    if (parcObject_Lock(pool->workQueue)) {
-        parcObject_NotifyAll(pool->workQueue);
-        parcObject_Unlock(pool->workQueue);
-    }
-
-    parcThread_Join(pool->workerThread);
-
-    return NULL;
-}
-
-PARCScheduledTask *
-parcScheduledThreadPool_Submit(PARCScheduledThreadPool *pool, PARCFutureTask *task)
-{
-    PARCScheduledTask *scheduledTask = parcScheduledTask_Create(task, 0);
-
-    parcSortedList_Add(pool->workQueue, scheduledTask);
-
-    return scheduledTask;
-}
diff --git a/libparc/parc/concurrent/parc_ScheduledThreadPool.h b/libparc/parc/concurrent/parc_ScheduledThreadPool.h
deleted file mode 100755
index 36c26909..00000000
--- a/libparc/parc/concurrent/parc_ScheduledThreadPool.h
+++ /dev/null
@@ -1,429 +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 parc_ScheduledThreadPool.h
- * @ingroup threading
- * @brief <#Brief Description#>
- *
- * <#Detailed Description#>
- *
- */
-#ifndef PARCLibrary_parc_ScheduledThreadPool
-#define PARCLibrary_parc_ScheduledThreadPool
-#include <stdbool.h>
-
-#include <parc/algol/parc_JSON.h>
-#include <parc/algol/parc_HashCode.h>
-#include <parc/algol/parc_SortedList.h>
-#include <parc/concurrent/parc_FutureTask.h>
-#include <parc/concurrent/parc_ScheduledTask.h>
-#include <parc/concurrent/parc_Timeout.h>
-
-struct PARCScheduledThreadPool;
-typedef struct PARCScheduledThreadPool PARCScheduledThreadPool;
-
-/**
- * Increase the number of references to a `PARCScheduledThreadPool` instance.
- *
- * Note that new `PARCScheduledThreadPool` is not created,
- * only that the given `PARCScheduledThreadPool` reference count is incremented.
- * Discard the reference by invoking `parcScheduledThreadPool_Release`.
- *
- * @param [in] instance A pointer to a valid PARCScheduledThreadPool instance.
- *
- * @return The same value as @p instance.
- *
- * Example:
- * @code
- * {
- *     PARCScheduledThreadPool *a = parcScheduledThreadPool_Create();
- *
- *     PARCScheduledThreadPool *b = parcScheduledThreadPool_Acquire();
- *
- *     parcScheduledThreadPool_Release(&a);
- *     parcScheduledThreadPool_Release(&b);
- * }
- * @endcode
- */
-PARCScheduledThreadPool *parcScheduledThreadPool_Acquire(const PARCScheduledThreadPool *instance);
-
-#ifdef PARCLibrary_DISABLE_VALIDATION
-#  define parcScheduledThreadPool_OptionalAssertValid(_instance_)
-#else
-#  define parcScheduledThreadPool_OptionalAssertValid(_instance_) parcScheduledThreadPool_AssertValid(_instance_)
-#endif
-
-/**
- * Assert that the given `PARCScheduledThreadPool` instance is valid.
- *
- * @param [in] instance A pointer to a valid PARCScheduledThreadPool instance.
- *
- * Example:
- * @code
- * {
- *     PARCScheduledThreadPool *a = parcScheduledThreadPool_Create();
- *
- *     parcScheduledThreadPool_AssertValid(a);
- *
- *     printf("Instance is valid.\n");
- *
- *     parcScheduledThreadPool_Release(&b);
- * }
- * @endcode
- */
-void parcScheduledThreadPool_AssertValid(const PARCScheduledThreadPool *instance);
-
-/**
- * Create an instance of PARCScheduledThreadPool
- *
- * <#Paragraphs Of Explanation#>
- *
- * @return non-NULL A pointer to a valid PARCScheduledThreadPool instance.
- * @return NULL An error occurred.
- *
- * Example:
- * @code
- * {
- *     PARCScheduledThreadPool *a = parcScheduledThreadPool_Create();
- *
- *     parcScheduledThreadPool_Release(&a);
- * }
- * @endcode
- */
-PARCScheduledThreadPool *parcScheduledThreadPool_Create(int poolSize);
-
-/**
- * Compares @p instance with @p other for order.
- *
- * Returns a negative integer, zero, or a positive integer as @p instance
- * is less than, equal to, or greater than @p other.
- *
- * @param [in] instance A pointer to a valid PARCScheduledThreadPool instance.
- * @param [in] other A pointer to a valid PARCScheduledThreadPool instance.
- *
- * @return <0 Instance is less than @p other.
- * @return 0 Instance a and instance b compare the same.
- * @return >0 Instance a is greater than instance b.
- *
- * Example:
- * @code
- * {
- *     PARCScheduledThreadPool *a = parcScheduledThreadPool_Create();
- *     PARCScheduledThreadPool *b = parcScheduledThreadPool_Create();
- *
- *     if (parcScheduledThreadPool_Compare(a, b) == 0) {
- *         printf("Instances are equal.\n");
- *     }
- *
- *     parcScheduledThreadPool_Release(&a);
- *     parcScheduledThreadPool_Release(&b);
- * }
- * @endcode
- *
- * @see parcScheduledThreadPool_Equals
- */
-int parcScheduledThreadPool_Compare(const PARCScheduledThreadPool *instance, const PARCScheduledThreadPool *other);
-
-/**
- * Create an independent copy the given `PARCBuffer`
- *
- * A new buffer is created as a complete copy of the original.
- *
- * @param [in] original A pointer to a valid PARCScheduledThreadPool instance.
- *
- * @return NULL Memory could not be allocated.
- * @return non-NULL A pointer to a new `PARCScheduledThreadPool` instance.
- *
- * Example:
- * @code
- * {
- *     PARCScheduledThreadPool *a = parcScheduledThreadPool_Create();
- *
- *     PARCScheduledThreadPool *copy = parcScheduledThreadPool_Copy(&b);
- *
- *     parcScheduledThreadPool_Release(&b);
- *     parcScheduledThreadPool_Release(&copy);
- * }
- * @endcode
- */
-PARCScheduledThreadPool *parcScheduledThreadPool_Copy(const PARCScheduledThreadPool *original);
-
-/**
- * Print a human readable representation of the given `PARCScheduledThreadPool`.
- *
- * @param [in] instance A pointer to a valid PARCScheduledThreadPool instance.
- * @param [in] indentation The indentation level to use for printing.
- *
- * Example:
- * @code
- * {
- *     PARCScheduledThreadPool *a = parcScheduledThreadPool_Create();
- *
- *     parcScheduledThreadPool_Display(a, 0);
- *
- *     parcScheduledThreadPool_Release(&a);
- * }
- * @endcode
- */
-void parcScheduledThreadPool_Display(const PARCScheduledThreadPool *instance, int indentation);
-
-/**
- * Determine if two `PARCScheduledThreadPool` instances are equal.
- *
- * The following equivalence relations on non-null `PARCScheduledThreadPool` instances are maintained: *
- *   * It is reflexive: for any non-null reference value x, `parcScheduledThreadPool_Equals(x, x)` must return true.
- *
- *   * It is symmetric: for any non-null reference values x and y, `parcScheduledThreadPool_Equals(x, y)` must return true if and only if
- *        `parcScheduledThreadPool_Equals(y x)` returns true.
- *
- *   * It is transitive: for any non-null reference values x, y, and z, if
- *        `parcScheduledThreadPool_Equals(x, y)` returns true and
- *        `parcScheduledThreadPool_Equals(y, z)` returns true,
- *        then `parcScheduledThreadPool_Equals(x, z)` must return true.
- *
- *   * It is consistent: for any non-null reference values x and y, multiple invocations of `parcScheduledThreadPool_Equals(x, y)`
- *         consistently return true or consistently return false.
- *
- *   * For any non-null reference value x, `parcScheduledThreadPool_Equals(x, NULL)` must return false.
- *
- * @param [in] x A pointer to a valid PARCScheduledThreadPool instance.
- * @param [in] y A pointer to a valid PARCScheduledThreadPool instance.
- *
- * @return true The instances x and y are equal.
- *
- * Example:
- * @code
- * {
- *     PARCScheduledThreadPool *a = parcScheduledThreadPool_Create();
- *     PARCScheduledThreadPool *b = parcScheduledThreadPool_Create();
- *
- *     if (parcScheduledThreadPool_Equals(a, b)) {
- *         printf("Instances are equal.\n");
- *     }
- *
- *     parcScheduledThreadPool_Release(&a);
- *     parcScheduledThreadPool_Release(&b);
- * }
- * @endcode
- * @see parcScheduledThreadPool_HashCode
- */
-bool parcScheduledThreadPool_Equals(const PARCScheduledThreadPool *x, const PARCScheduledThreadPool *y);
-
-/**
- * Returns a hash code value for the given instance.
- *
- * The general contract of `HashCode` is:
- *
- * Whenever it is invoked on the same instance more than once during an execution of an application,
- * the `HashCode` function must consistently return the same value,
- * provided no information used in a corresponding comparisons on the instance is modified.
- *
- * This value need not remain consistent from one execution of an application to another execution of the same application.
- * If two instances are equal according to the {@link parcScheduledThreadPool_Equals} method,
- * then calling the {@link parcScheduledThreadPool_HashCode} method on each of the two instances must produce the same integer result.
- *
- * It is not required that if two instances are unequal according to the
- * {@link parcScheduledThreadPool_Equals} function,
- * then calling the `parcScheduledThreadPool_HashCode`
- * method on each of the two objects must produce distinct integer results.
- *
- * @param [in] instance A pointer to a valid PARCScheduledThreadPool instance.
- *
- * @return The hashcode for the given instance.
- *
- * Example:
- * @code
- * {
- *     PARCScheduledThreadPool *a = parcScheduledThreadPool_Create();
- *
- *     PARCHashCode hashValue = parcScheduledThreadPool_HashCode(buffer);
- *     parcScheduledThreadPool_Release(&a);
- * }
- * @endcode
- */
-PARCHashCode parcScheduledThreadPool_HashCode(const PARCScheduledThreadPool *instance);
-
-/**
- * Determine if an instance of `PARCScheduledThreadPool` is valid.
- *
- * Valid means the internal state of the type is consistent with its required current or future behaviour.
- * This may include the validation of internal instances of types.
- *
- * @param [in] instance A pointer to a valid PARCScheduledThreadPool instance.
- *
- * @return true The instance is valid.
- * @return false The instance is not valid.
- *
- * Example:
- * @code
- * {
- *     PARCScheduledThreadPool *a = parcScheduledThreadPool_Create();
- *
- *     if (parcScheduledThreadPool_IsValid(a)) {
- *         printf("Instance is valid.\n");
- *     }
- *
- *     parcScheduledThreadPool_Release(&a);
- * }
- * @endcode
- *
- */
-bool parcScheduledThreadPool_IsValid(const PARCScheduledThreadPool *instance);
-
-/**
- * Release a previously acquired reference to the given `PARCScheduledThreadPool` instance,
- * decrementing the reference count for the instance.
- *
- * The pointer to the instance is set to NULL as a side-effect of this function.
- *
- * If the invocation causes the last reference to the instance to be released,
- * the instance is deallocated and the instance's implementation will perform
- * additional cleanup and release other privately held references.
- *
- * @param [in,out] instancePtr A pointer to a pointer to the instance to release.
- *
- * Example:
- * @code
- * {
- *     PARCScheduledThreadPool *a = parcScheduledThreadPool_Create();
- *
- *     parcScheduledThreadPool_Release(&a);
- * }
- * @endcode
- */
-void parcScheduledThreadPool_Release(PARCScheduledThreadPool **instancePtr);
-
-/**
- * Create a `PARCJSON` instance (representation) of the given object.
- *
- * @param [in] instance A pointer to a valid PARCScheduledThreadPool instance.
- *
- * @return NULL Memory could not be allocated to contain the `PARCJSON` instance.
- * @return non-NULL An allocated C string that must be deallocated via parcMemory_Deallocate().
- *
- * Example:
- * @code
- * {
- *     PARCScheduledThreadPool *a = parcScheduledThreadPool_Create();
- *
- *     PARCJSON *json = parcScheduledThreadPool_ToJSON(a);
- *
- *     printf("JSON representation: %s\n", parcJSON_ToString(json));
- *     parcJSON_Release(&json);
- *
- *     parcScheduledThreadPool_Release(&a);
- * }
- * @endcode
- */
-PARCJSON *parcScheduledThreadPool_ToJSON(const PARCScheduledThreadPool *instance);
-
-/**
- * Produce a null-terminated string representation of the specified `PARCScheduledThreadPool`.
- *
- * The result must be freed by the caller via {@link parcMemory_Deallocate}.
- *
- * @param [in] instance A pointer to a valid PARCScheduledThreadPool instance.
- *
- * @return NULL Cannot allocate memory.
- * @return non-NULL A pointer to an allocated, null-terminated C string that must be deallocated via {@link parcMemory_Deallocate}.
- *
- * Example:
- * @code
- * {
- *     PARCScheduledThreadPool *a = parcScheduledThreadPool_Create();
- *
- *     char *string = parcScheduledThreadPool_ToString(a);
- *
- *     parcScheduledThreadPool_Release(&a);
- *
- *     parcMemory_Deallocate(&string);
- * }
- * @endcode
- *
- * @see parcScheduledThreadPool_Display
- */
-char *parcScheduledThreadPool_ToString(const PARCScheduledThreadPool *instance);
-
-/**
- * Executes command with zero required delay.
- */
-void parcScheduledThreadPool_Execute(PARCScheduledThreadPool *pool, PARCFutureTask *command);
-
-/**
- * Gets the policy on whether to continue executing existing periodic tasks even when this executor has been shutdown.
- */
-bool parcScheduledThreadPool_GetContinueExistingPeriodicTasksAfterShutdownPolicy(PARCScheduledThreadPool *pool);
-
-/**
- * Gets the policy on whether to execute existing delayed tasks even when this executor has been shutdown.
- */
-bool parcScheduledThreadPool_GetExecuteExistingDelayedTasksAfterShutdownPolicy(PARCScheduledThreadPool *pool);
-
-/**
- * Returns the task queue used by this executor.
- */
-PARCSortedList *parcScheduledThreadPool_GetQueue(const PARCScheduledThreadPool *pool);
-
-/**
- * Gets the policy on whether cancelled tasks should be immediately removed from the work queue at time of cancellation.
- */
-bool parcScheduledThreadPool_GetRemoveOnCancelPolicy(const PARCScheduledThreadPool *pool);
-
-/**
- * Creates and executes a one-shot action that becomes enabled after the given delay.
- */
-PARCScheduledTask *parcScheduledThreadPool_Schedule(PARCScheduledThreadPool *pool, PARCFutureTask *task, const PARCTimeout *delay);
-
-/**
- * Creates and executes a periodic action that becomes enabled first after the given initial delay, and subsequently with the given period; that is executions will commence after initialDelay then initialDelay+period, then initialDelay + 2 * period, and so on.
- */
-PARCScheduledTask *parcScheduledThreadPool_ScheduleAtFixedRate(PARCScheduledThreadPool *pool, PARCFutureTask *task, PARCTimeout initialDelay, PARCTimeout period);
-
-/**
- * Creates and executes a periodic action that becomes enabled first after the given initial delay, and subsequently with the given delay between the termination of one execution and the commencement of the next.
- */
-PARCScheduledTask *parcScheduledThreadPool_ScheduleWithFixedDelay(PARCScheduledThreadPool *pool, PARCFutureTask *task, PARCTimeout initialDelay, PARCTimeout delay);
-
-/**
- * Sets the policy on whether to continue executing existing periodic tasks even when this executor has been shutdown.
- */
-void parcScheduledThreadPool_SetContinueExistingPeriodicTasksAfterShutdownPolicy(PARCScheduledThreadPool *pool, bool value);
-
-/**
- * Sets the policy on whether to execute existing delayed tasks even when this executor has been shutdown.
- */
-void parcScheduledThreadPool_SetExecuteExistingDelayedTasksAfterShutdownPolicy(PARCScheduledThreadPool *pool, bool value);
-
-/**
- * Sets the policy on whether cancelled tasks should be immediately removed from the work queue at time of cancellation.
- */
-void parcScheduledThreadPool_SetRemoveOnCancelPolicy(PARCScheduledThreadPool *pool, bool value);
-
-/**
- * Initiates an orderly shutdown in which previously submitted tasks are executed, but no new tasks will be accepted.
- */
-void parcScheduledThreadPool_Shutdown(PARCScheduledThreadPool *pool);
-
-/**
- * Attempts to stop all actively executing tasks, halts the processing of waiting tasks, and returns a list of the tasks that were awaiting execution.
- */
-PARCList *parcScheduledThreadPool_ShutdownNow(PARCScheduledThreadPool *pool);
-
-/**
- * Submits a PARCFutureTask task for execution and returns the PARCFutureTask representing that task.
- */
-PARCScheduledTask *parcScheduledThreadPool_Submit(PARCScheduledThreadPool *pool, PARCFutureTask *task);
-#endif
diff --git a/libparc/parc/concurrent/parc_Synchronizer.c b/libparc/parc/concurrent/parc_Synchronizer.c
deleted file mode 100755
index ab331442..00000000
--- a/libparc/parc/concurrent/parc_Synchronizer.c
+++ /dev/null
@@ -1,146 +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 <config.h>
-
-#include <parc/algol/parc_Object.h>
-#include <parc/algol/parc_DisplayIndented.h>
-
-#include <parc/concurrent/parc_Synchronizer.h>
-
-#ifdef PARCLibrary_DISABLE_ATOMICS
-#  include <pthread.h>
-#else
-//#  include <pthread.h>
-#endif
-
-typedef enum {
-    _PARCSynchronizer_Unlocked = 0,
-    _PARCSynchronizer_Locked = 1
-} _PARCSynchronizer;
-
-struct PARCSynchronizer {
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    pthread_mutex_t mutex;
-#else
-    int mutex;
-#endif
-};
-
-static void
-_parcSynchronizer_Finalize(PARCSynchronizer **instancePtr)
-{
-    parcAssertNotNull(instancePtr, "Parameter must be a non-null pointer to a PARCSynchronizer pointer.");
-
-    parcSynchronizer_OptionalAssertValid((*instancePtr));
-}
-
-parcObject_ImplementAcquire(parcSynchronizer, PARCSynchronizer);
-
-parcObject_ImplementRelease(parcSynchronizer, PARCSynchronizer);
-
-parcObject_ExtendPARCObject(PARCSynchronizer, _parcSynchronizer_Finalize, NULL, NULL, NULL, NULL, NULL, NULL);
-
-void
-parcSynchronizer_AssertValid(const PARCSynchronizer *instance)
-{
-    parcAssertTrue(parcSynchronizer_IsValid(instance),
-               "PARCSynchronizer is not valid.");
-}
-
-PARCSynchronizer *
-parcSynchronizer_Create(void)
-{
-    PARCSynchronizer *result = parcObject_CreateInstance(PARCSynchronizer);
-
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    pthread_mutex_init(&result->mutex, NULL);
-#else
-    result->mutex = _PARCSynchronizer_Unlocked;
-#endif
-
-    return result;
-}
-
-void
-parcSynchronizer_Display(const PARCSynchronizer *instance, int indentation)
-{
-    parcDisplayIndented_PrintLine(indentation, "PARCSynchronizer@%p {", instance);
-    /* Call Display() functions for the fields here. */
-    parcDisplayIndented_PrintLine(indentation, "}");
-}
-
-bool
-parcSynchronizer_IsValid(const PARCSynchronizer *instance)
-{
-    bool result = false;
-
-    if (instance != NULL) {
-        result = true;
-    }
-
-    return result;
-}
-
-bool
-parcSynchronizer_TryLock(PARCSynchronizer *instance)
-{
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    bool result = pthread_mutex_trylock(&instance->mutex) == 0;
-#else
-    bool result = __sync_bool_compare_and_swap(&instance->mutex, _PARCSynchronizer_Unlocked, _PARCSynchronizer_Locked);
-#endif
-    return result;
-}
-
-void
-parcSynchronizer_Lock(PARCSynchronizer *instance)
-{
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    pthread_mutex_lock(&instance->mutex);
-#else
-    while (!__sync_bool_compare_and_swap(&instance->mutex, _PARCSynchronizer_Unlocked, _PARCSynchronizer_Locked)) {
-        ;
-    }
-#endif
-}
-
-void
-parcSynchronizer_Unlock(PARCSynchronizer *instance)
-{
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    pthread_mutex_unlock(&instance->mutex);
-#else
-    while (!__sync_bool_compare_and_swap(&instance->mutex, _PARCSynchronizer_Locked, _PARCSynchronizer_Unlocked)) {
-        ;
-    }
-#endif
-}
-
-bool
-parcSynchronizer_IsLocked(const PARCSynchronizer *barrier)
-{
-#ifdef PARCLibrary_DISABLE_ATOMICS
-    PARCSynchronizer *instance = (PARCSynchronizer *) barrier;
-
-    bool result = pthread_mutex_trylock(&instance->mutex) != 0;
-    pthread_mutex_unlock(&instance->mutex);
-    return result;
-#else
-    return barrier->mutex == _PARCSynchronizer_Locked;
-#endif
-}
diff --git a/libparc/parc/concurrent/parc_Synchronizer.h b/libparc/parc/concurrent/parc_Synchronizer.h
deleted file mode 100755
index a387888f..00000000
--- a/libparc/parc/concurrent/parc_Synchronizer.h
+++ /dev/null
@@ -1,277 +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 parc_Synchronizer.h
- * @ingroup threading
- * @brief A simple mutual exclusive synchronization implementation.
- *
- * Detailed Description
- *
- */
-#ifndef PARCLibrary_parc_Barrier
-#define PARCLibrary_parc_Barrier
-#include <stdbool.h>
-
-#include <parc/algol/parc_JSON.h>
-
-struct PARCSynchronizer;
-typedef struct PARCSynchronizer PARCSynchronizer;
-
-/**
- * Increase the number of references to a `PARCSynchronizer` instance.
- *
- * Note that new `PARCSynchronizer` is not created,
- * only that the given `PARCSynchronizer` reference count is incremented.
- * Discard the reference by invoking `parcSynchronizer_Release`.
- *
- * @param [in] instance A pointer to a valid PARCSynchronizer instance.
- *
- * @return The same value as @p instance.
- *
- * Example:
- * @code
- * {
- *     PARCSynchronizer *a = parcSynchronizer_Create();
- *
- *     PARCSynchronizer *b = parcSynchronizer_Acquire();
- *
- *     parcSynchronizer_Release(&a);
- *     parcSynchronizer_Release(&b);
- * }
- * @endcode
- */
-PARCSynchronizer *parcSynchronizer_Acquire(const PARCSynchronizer *instance);
-
-#ifdef PARCLibrary_DISABLE_VALIDATION
-#  define parcSynchronizer_OptionalAssertValid(_instance_)
-#else
-#  define parcSynchronizer_OptionalAssertValid(_instance_) parcSynchronizer_AssertValid(_instance_)
-#endif
-
-/**
- * Assert that the given `PARCSynchronizer` instance is valid.
- *
- * @param [in] instance A pointer to a valid PARCSynchronizer instance.
- *
- * Example:
- * @code
- * {
- *     PARCSynchronizer *a = parcSynchronizer_Create();
- *
- *     parcSynchronizer_AssertValid(a);
- *
- *     printf("Instance is valid.\n");
- *
- *     parcSynchronizer_Release(&b);
- * }
- * @endcode
- */
-void parcSynchronizer_AssertValid(const PARCSynchronizer *instance);
-
-/**
- * Create an instance of PARCSynchronizer
- *
- * <#Paragraphs Of Explanation#>
- *
- * @return non-NULL A pointer to a valid PARCSynchronizer instance.
- * @return NULL An error occurred.
- *
- * Example:
- * @code
- * {
- *     PARCSynchronizer *a = parcSynchronizer_Create();
- *
- *     parcSynchronizer_Release(&a);
- * }
- * @endcode
- */
-PARCSynchronizer *parcSynchronizer_Create(void);
-
-/**
- * Print a human readable representation of the given `PARCSynchronizer`.
- *
- * @param [in] instance A pointer to a valid PARCSynchronizer instance.
- * @param [in] indentation The indentation level to use for printing.
- *
- * Example:
- * @code
- * {
- *     PARCSynchronizer *a = parcSynchronizer_Create();
- *
- *     parcSynchronizer_Display(a, 0);
- *
- *     parcSynchronizer_Release(&a);
- * }
- * @endcode
- */
-void parcSynchronizer_Display(const PARCSynchronizer *instance, int indentation);
-
-/**
- * Returns a hash code value for the given instance.
- *
- * The general contract of `HashCode` is:
- *
- * Whenever it is invoked on the same instance more than once during an execution of an application,
- * the `HashCode` function must consistently return the same value,
- * provided no information used in a corresponding comparisons on the instance is modified.
- *
- * This value need not remain consistent from one execution of an application to another execution of the same application.
- * If two instances are equal according to the {@link parcSynchronizer_Equals} method,
- * then calling the {@link parcSynchronizer_HashCode} method on each of the two instances must produce the same integer result.
- *
- * It is not required that if two instances are unequal according to the
- * {@link parcSynchronizer_Equals} function,
- * then calling the `parcSynchronizer_HashCode`
- * method on each of the two objects must produce distinct integer results.
- *
- * @param [in] instance A pointer to a valid PARCSynchronizer instance.
- *
- * @return The hashcode for the given instance.
- *
- * Example:
- * @code
- * {
- *     PARCSynchronizer *a = parcSynchronizer_Create();
- *
- *     uint32_t hashValue = parcSynchronizer_HashCode(buffer);
- *     parcSynchronizer_Release(&a);
- * }
- * @endcode
- */
-int parcSynchronizer_HashCode(const PARCSynchronizer *instance);
-
-/**
- * Determine if an instance of `PARCSynchronizer` is valid.
- *
- * Valid means the internal state of the type is consistent with its required current or future behaviour.
- * This may include the validation of internal instances of types.
- *
- * @param [in] instance A pointer to a valid PARCSynchronizer instance.
- *
- * @return true The instance is valid.
- * @return false The instance is not valid.
- *
- * Example:
- * @code
- * {
- *     PARCSynchronizer *a = parcSynchronizer_Create();
- *
- *     if (parcSynchronizer_IsValid(a)) {
- *         printf("Instance is valid.\n");
- *     }
- *
- *     parcSynchronizer_Release(&a);
- * }
- * @endcode
- *
- */
-bool parcSynchronizer_IsValid(const PARCSynchronizer *instance);
-
-/**
- * Release a previously acquired reference to the given `PARCSynchronizer` instance,
- * decrementing the reference count for the instance.
- *
- * The pointer to the instance is set to NULL as a side-effect of this function.
- *
- * If the invocation causes the last reference to the instance to be released,
- * the instance is deallocated and the instance's implementation will perform
- * additional cleanup and release other privately held references.
- *
- * @param [in,out] instancePtr A pointer to a pointer to the instance to release.
- *
- * Example:
- * @code
- * {
- *     PARCSynchronizer *a = parcSynchronizer_Create();
- *
- *     parcSynchronizer_Release(&a);
- * }
- * @endcode
- */
-void parcSynchronizer_Release(PARCSynchronizer **instancePtr);
-
-/**
- * Attempt to lock the given PARCSynchronizer.
- *
- * If the synchronizer is already locked, this function returns `false`.
- * Otherwise, the lock is established and this function returns `true`.
- *
- * @param [in] barrier A pointer to a valid PARCSynchronizer instance.
- *
- * @return `true` The PARCSynchronizer was successfully set.
- * @return `false` The PARCSynchronizer could not be set.
- *
- * Example:
- * @code
- * {
- *     <#example#>
- * }
- * @endcode
- */
-bool parcSynchronizer_TryLock(PARCSynchronizer *barrier);
-
-/**
- * Lock the given PARCSynchronizer.
- *
- * If the synchronizer is already locked, this function blocks the caller until it is able to acquire the lock.
- *
- * @param [in] barrier A pointer to a valid PARCSynchronizer instance.
- *
- * Example:
- * @code
- * {
- *     <#example#>
- * }
- * @endcode
- */
-void parcSynchronizer_Lock(PARCSynchronizer *barrier);
-
-/**
- * Unlock the given PARCSynchronizer.
- *
- * @param [in] barrier A pointer to a valid PARCSynchronizer instance.
- *
- * Example:
- * @code
- * {
- *     <#example#>
- * }
- * @endcode
- */
-void parcSynchronizer_Unlock(PARCSynchronizer *barrier);
-
-/**
- * Check if a PARCSynchronizer is locked.
- *
- * @param [in] synchronizer A pointer to a valid PARCSynchronizer instance.
- *
- * @return true The specified synchronizer is currently locked.
- *
- * Example:
- * @code
- * {
- *     PARCSynchronizer *a = parcSynchronizer_Create();
- *
- *     if (parcSynchronizer_IsLocked(a) == true) {
- *         printf("A PARCSynchronizer cannot be created in the locked state.\n");
- *     }
- *
- *     parcSynchronizer_Release(&a);
- * }
- * @endcode
- */
-bool parcSynchronizer_IsLocked(const PARCSynchronizer *synchronizer);
-#endif
diff --git a/libparc/parc/concurrent/parc_Thread.c b/libparc/parc/concurrent/parc_Thread.c
deleted file mode 100644
index 50be042d..00000000
--- a/libparc/parc/concurrent/parc_Thread.c
+++ /dev/null
@@ -1,232 +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 <config.h>
-#include <pthread.h>
-#include <stdio.h>
-
-#include <parc/algol/parc_Object.h>
-#include <parc/algol/parc_DisplayIndented.h>
-#include <parc/algol/parc_Memory.h>
-
-#include <parc/concurrent/parc_Thread.h>
-
-struct PARCThread {
-    void *(*run)(PARCThread *, PARCObject *param);
-    PARCObject *argument;
-    bool isCancelled;
-    bool isRunning;
-    pthread_t thread;
-};
-
-static bool
-_parcThread_Destructor(PARCThread **instancePtr)
-{
-    parcAssertNotNull(instancePtr, "Parameter must be a non-null pointer to a PARCThread pointer.");
-    PARCThread *thread = *instancePtr;
-
-    if (thread->argument != NULL) {
-        parcObject_Release(&thread->argument);
-    }
-
-    thread->isCancelled = true;
-    parcThread_Join(thread);
-
-    return true;
-}
-
-parcObject_ImplementAcquire(parcThread, PARCThread);
-
-parcObject_ImplementRelease(parcThread, PARCThread);
-
-parcObject_Override(PARCThread, PARCObject,
-                    .isLockable = true,
-                    .destructor = (PARCObjectDestructor *) _parcThread_Destructor,
-                    .copy = (PARCObjectCopy *) parcThread_Copy,
-                    .toString = (PARCObjectToString *) parcThread_ToString,
-                    .equals = (PARCObjectEquals *) parcThread_Equals,
-                    .compare = (PARCObjectCompare *) parcThread_Compare,
-                    .hashCode = (PARCObjectHashCode *) parcThread_HashCode,
-                    .display = (PARCObjectDisplay *) parcThread_Display
-                    );
-
-void
-parcThread_AssertValid(const PARCThread *instance)
-{
-    parcAssertTrue(parcThread_IsValid(instance),
-               "PARCThread is not valid.");
-}
-
-PARCThread *
-parcThread_Create(void *(*runFunction)(PARCThread *, PARCObject *), PARCObject *restrict parameter)
-{
-    parcAssertNotNull(parameter, "Parameter cannot be NULL.");
-
-    PARCThread *result = parcObject_CreateAndClearInstance(PARCThread);
-
-    if (result) {
-        result->run = runFunction;
-        result->argument = parcObject_Acquire(parameter);
-        result->isCancelled = false;
-        result->isRunning = false;
-    }
-
-    return result;
-}
-
-int
-parcThread_Compare(const PARCThread *instance, const PARCThread *other)
-{
-    int result = 0;
-    return result;
-}
-
-PARCThread *
-parcThread_Copy(const PARCThread *original)
-{
-    PARCThread *result = parcThread_Create(original->run, original->argument);
-    result->isCancelled = original->isCancelled;
-    result->isRunning = original->isRunning;
-
-    return result;
-}
-
-void
-parcThread_Display(const PARCThread *instance, int indentation)
-{
-    parcDisplayIndented_PrintLine(indentation, "PARCThread@%p {", instance);
-    /* Call Display() functions for the fields here. */
-    parcDisplayIndented_PrintLine(indentation, "}");
-}
-
-bool
-parcThread_Equals(const PARCThread *x, const PARCThread *y)
-{
-    bool result = false;
-
-    if (x == y) {
-        result = true;
-    } else if (x == NULL || y == NULL) {
-        result = false;
-    } else {
-        result = pthread_equal(x->thread, y->thread);
-    }
-
-    return result;
-}
-
-PARCHashCode
-parcThread_HashCode(const PARCThread *instance)
-{
-    PARCHashCode result = 0;
-
-    return result;
-}
-
-bool
-parcThread_IsValid(const PARCThread *thread)
-{
-    bool result = false;
-
-    if (thread != NULL) {
-        result = true;
-    }
-
-    return result;
-}
-
-PARCJSON *
-parcThread_ToJSON(const PARCThread *thread)
-{
-    PARCJSON *result = parcJSON_Create();
-
-    return result;
-}
-
-char *
-parcThread_ToString(const PARCThread *thread)
-{
-    char *result = parcMemory_Format("PARCThread@%p{.id=%p, .isCancelled=%s}", thread, thread->thread, thread->isCancelled ? "true" : "false");
-
-    return result;
-}
-
-static void *
-_parcThread_Run(PARCThread *thread)
-{
-    thread->isRunning = true;
-    thread->run(thread, thread->argument);
-    thread->isRunning = false;
-
-    // The thread is done, release the reference to the argument acquired when this PARCThread was created.
-    // This prevents the reference from lingering leading to memory leaks if the thread is not properly joined.
-    if (thread->argument != NULL) {
-        parcObject_Release(&thread->argument);
-    }
-    //  Release the thread reference that was acquired *before* this thread was started.
-    parcThread_Release(&thread);
-
-    return NULL;
-}
-
-void
-parcThread_Start(PARCThread *thread)
-{
-    PARCThread *parameter = parcThread_Acquire(thread);
-    pthread_create(&thread->thread, NULL, (void *(*)(void *))_parcThread_Run, parameter);
-}
-
-PARCObject *
-parcThread_GetParameter(const PARCThread *thread)
-{
-    return thread->argument;
-}
-
-bool
-parcThread_Cancel(PARCThread *thread)
-{
-    if (parcThread_Lock(thread)) {
-        thread->isCancelled = true;
-        parcThread_Notify(thread);
-        parcThread_Unlock(thread);
-    }
-    return true;
-}
-
-int
-parcThread_GetId(const PARCThread *thread)
-{
-    return (int) thread->thread;
-}
-
-bool
-parcThread_IsRunning(const PARCThread *thread)
-{
-    return thread->isRunning;
-}
-
-bool
-parcThread_IsCancelled(const PARCThread *thread)
-{
-    return thread->isCancelled;
-}
-
-void
-parcThread_Join(PARCThread *thread)
-{
-    pthread_join(thread->thread, NULL);
-}
diff --git a/libparc/parc/concurrent/parc_Thread.h b/libparc/parc/concurrent/parc_Thread.h
deleted file mode 100755
index f24306ae..00000000
--- a/libparc/parc/concurrent/parc_Thread.h
+++ /dev/null
@@ -1,601 +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 parc_Thread.h
- * @ingroup threading
- * @brief <#Brief Description#>
- *
- * <#Detailed Description#>
- *
- */
-#ifndef PARCLibrary_parc_Thread
-#define PARCLibrary_parc_Thread
-#include <stdbool.h>
-
-#include <parc/algol/parc_JSON.h>
-#include <parc/algol/parc_HashCode.h>
-
-struct PARCThread;
-typedef struct PARCThread PARCThread;
-
-/**
- * Increase the number of references to a `PARCThread` instance.
- *
- * Note that new `PARCThread` is not created,
- * only that the given `PARCThread` reference count is incremented.
- * Discard the reference by invoking `parcThread_Release`.
- *
- * @param [in] instance A pointer to a valid PARCThread instance.
- *
- * @return The same value as @p instance.
- *
- * Example:
- * @code
- * {
- *     PARCThread *a = parcThread_Create();
- *
- *     PARCThread *b = parcThread_Acquire();
- *
- *     parcThread_Release(&a);
- *     parcThread_Release(&b);
- * }
- * @endcode
- */
-PARCThread *parcThread_Acquire(const PARCThread *instance);
-
-#ifdef PARCLibrary_DISABLE_VALIDATION
-#  define parcThread_OptionalAssertValid(_instance_)
-#else
-#  define parcThread_OptionalAssertValid(_instance_) parcThread_AssertValid(_instance_)
-#endif
-
-/**
- * Assert that the given `PARCThread` instance is valid.
- *
- * @param [in] instance A pointer to a valid PARCThread instance.
- *
- * Example:
- * @code
- * {
- *     PARCThread *a = parcThread_Create();
- *
- *     parcThread_AssertValid(a);
- *
- *     printf("Instance is valid.\n");
- *
- *     parcThread_Release(&b);
- * }
- * @endcode
- */
-void parcThread_AssertValid(const PARCThread *instance);
-
-/**
- * Create an instance of PARCThread
- *
- * @return non-NULL A pointer to a valid PARCThread instance.
- * @return NULL An error occurred.
- *
- * Example:
- * @code
- * {
- *
- *     MyTask *task = myTask_Create();
- *     PARCThread *thread = parcThread_Create(myTask_Run, myTask);
- *
- *     parcThread_Start(a);
- *
- *     parcThread_Release(&a);
- * }
- * @endcode
- */
-//#define parcThread_Create(_runFunction_, _argument_) parcThread_CreateImpl((void (*)(PARCObject *)) _runFunction_, (PARCObject *) _argument_)
-
-PARCThread *parcThread_Create(void *(*run)(PARCThread *, PARCObject *), PARCObject *restrict argument);
-
-/**
- * Compares @p instance with @p other for order.
- *
- * Returns a negative integer, zero, or a positive integer as @p instance
- * is less than, equal to, or greater than @p other.
- *
- * @param [in] instance A pointer to a valid PARCThread instance.
- * @param [in] other A pointer to a valid PARCThread instance.
- *
- * @return <0 Instance is less than @p other.
- * @return 0 Instance a and instance b compare the same.
- * @return >0 Instance a is greater than instance b.
- *
- * Example:
- * @code
- * {
- *     PARCThread *a = parcThread_Create();
- *     PARCThread *b = parcThread_Create();
- *
- *     if (parcThread_Compare(a, b) == 0) {
- *         printf("Instances are equal.\n");
- *     }
- *
- *     parcThread_Release(&a);
- *     parcThread_Release(&b);
- * }
- * @endcode
- *
- * @see parcThread_Equals
- */
-int parcThread_Compare(const PARCThread *instance, const PARCThread *other);
-
-/**
- * Create an independent copy the given `PARCBuffer`
- *
- * A new buffer is created as a complete copy of the original.
- *
- * @param [in] original A pointer to a valid PARCThread instance.
- *
- * @return NULL Memory could not be allocated.
- * @return non-NULL A pointer to a new `PARCThread` instance.
- *
- * Example:
- * @code
- * {
- *     PARCThread *a = parcThread_Create();
- *
- *     PARCThread *copy = parcThread_Copy(&b);
- *
- *     parcThread_Release(&b);
- *     parcThread_Release(&copy);
- * }
- * @endcode
- */
-PARCThread *parcThread_Copy(const PARCThread *original);
-
-/**
- * Print a human readable representation of the given `PARCThread`.
- *
- * @param [in] instance A pointer to a valid PARCThread instance.
- * @param [in] indentation The indentation level to use for printing.
- *
- * Example:
- * @code
- * {
- *     PARCThread *a = parcThread_Create();
- *
- *     parcThread_Display(a, 0);
- *
- *     parcThread_Release(&a);
- * }
- * @endcode
- */
-void parcThread_Display(const PARCThread *instance, int indentation);
-
-/**
- * Determine if two `PARCThread` instances are equal.
- *
- * The following equivalence relations on non-null `PARCThread` instances are maintained: *
- *   * It is reflexive: for any non-null reference value x, `parcThread_Equals(x, x)` must return true.
- *
- *   * It is symmetric: for any non-null reference values x and y, `parcThread_Equals(x, y)` must return true if and only if
- *        `parcThread_Equals(y x)` returns true.
- *
- *   * It is transitive: for any non-null reference values x, y, and z, if
- *        `parcThread_Equals(x, y)` returns true and
- *        `parcThread_Equals(y, z)` returns true,
- *        then `parcThread_Equals(x, z)` must return true.
- *
- *   * It is consistent: for any non-null reference values x and y, multiple invocations of `parcThread_Equals(x, y)`
- *         consistently return true or consistently return false.
- *
- *   * For any non-null reference value x, `parcThread_Equals(x, NULL)` must return false.
- *
- * @param [in] x A pointer to a valid PARCThread instance.
- * @param [in] y A pointer to a valid PARCThread instance.
- *
- * @return true The instances x and y are equal.
- *
- * Example:
- * @code
- * {
- *     PARCThread *a = parcThread_Create();
- *     PARCThread *b = parcThread_Create();
- *
- *     if (parcThread_Equals(a, b)) {
- *         printf("Instances are equal.\n");
- *     }
- *
- *     parcThread_Release(&a);
- *     parcThread_Release(&b);
- * }
- * @endcode
- * @see parcThread_HashCode
- */
-bool parcThread_Equals(const PARCThread *x, const PARCThread *y);
-
-/**
- * Returns a hash code value for the given instance.
- *
- * The general contract of `HashCode` is:
- *
- * Whenever it is invoked on the same instance more than once during an execution of an application,
- * the `HashCode` function must consistently return the same value,
- * provided no information used in a corresponding comparisons on the instance is modified.
- *
- * This value need not remain consistent from one execution of an application to another execution of the same application.
- * If two instances are equal according to the {@link parcThread_Equals} method,
- * then calling the {@link parcThread_HashCode} method on each of the two instances must produce the same integer result.
- *
- * It is not required that if two instances are unequal according to the
- * {@link parcThread_Equals} function,
- * then calling the `parcThread_HashCode`
- * method on each of the two objects must produce distinct integer results.
- *
- * @param [in] instance A pointer to a valid PARCThread instance.
- *
- * @return The hashcode for the given instance.
- *
- * Example:
- * @code
- * {
- *     PARCThread *a = parcThread_Create();
- *
- *     PARCHashCode hashValue = parcThread_HashCode(buffer);
- *     parcThread_Release(&a);
- * }
- * @endcode
- */
-PARCHashCode parcThread_HashCode(const PARCThread *instance);
-
-/**
- * Determine if an instance of `PARCThread` is valid.
- *
- * Valid means the internal state of the type is consistent with its required current or future behaviour.
- * This may include the validation of internal instances of types.
- *
- * @param [in] instance A pointer to a valid PARCThread instance.
- *
- * @return true The instance is valid.
- * @return false The instance is not valid.
- *
- * Example:
- * @code
- * {
- *     PARCThread *a = parcThread_Create();
- *
- *     if (parcThread_IsValid(a)) {
- *         printf("Instance is valid.\n");
- *     }
- *
- *     parcThread_Release(&a);
- * }
- * @endcode
- *
- */
-bool parcThread_IsValid(const PARCThread *instance);
-
-/**
- * Release a previously acquired reference to the given `PARCThread` instance,
- * decrementing the reference count for the instance.
- *
- * The pointer to the instance is set to NULL as a side-effect of this function.
- *
- * If the invocation causes the last reference to the instance to be released,
- * the instance is deallocated and the instance's implementation will perform
- * additional cleanup and release other privately held references.
- *
- * @param [in,out] instancePtr A pointer to a pointer to the instance to release.
- *
- * Example:
- * @code
- * {
- *     PARCThread *a = parcThread_Create();
- *
- *     parcThread_Release(&a);
- * }
- * @endcode
- */
-void parcThread_Release(PARCThread **instancePtr);
-
-/**
- * Create a `PARCJSON` instance (representation) of the given object.
- *
- * @param [in] instance A pointer to a valid PARCThread instance.
- *
- * @return NULL Memory could not be allocated to contain the `PARCJSON` instance.
- * @return non-NULL An allocated C string that must be deallocated via parcMemory_Deallocate().
- *
- * Example:
- * @code
- * {
- *     PARCThread *a = parcThread_Create();
- *
- *     PARCJSON *json = parcThread_ToJSON(a);
- *
- *     printf("JSON representation: %s\n", parcJSON_ToString(json));
- *     parcJSON_Release(&json);
- *
- *     parcThread_Release(&a);
- * }
- * @endcode
- */
-PARCJSON *parcThread_ToJSON(const PARCThread *instance);
-
-/**
- * Produce a null-terminated string representation of the specified `PARCThread`.
- *
- * The result must be freed by the caller via {@link parcMemory_Deallocate}.
- *
- * @param [in] instance A pointer to a valid PARCThread instance.
- *
- * @return NULL Cannot allocate memory.
- * @return non-NULL A pointer to an allocated, null-terminated C string that must be deallocated via {@link parcMemory_Deallocate}.
- *
- * Example:
- * @code
- * {
- *     PARCThread *a = parcThread_Create();
- *
- *     char *string = parcThread_ToString(a);
- *
- *     parcThread_Release(&a);
- *
- *     parcMemory_Deallocate(&string);
- * }
- * @endcode
- *
- * @see parcThread_Display
- */
-char *parcThread_ToString(const PARCThread *instance);
-
-/**
- * Wakes up a single thread that is waiting on this object (see `parcLinkedList_Wait)`.
- * If any threads are waiting on this object, one of them is chosen to be awakened.
- * The choice is arbitrary and occurs at the discretion of the underlying implementation.
- *
- * The awakened thread will not be able to proceed until the current thread relinquishes the lock on this object.
- * The awakened thread will compete in the usual manner with any other threads that might be actively
- * competing to synchronize on this object;
- * for example, the awakened thread enjoys no reliable privilege or disadvantage in being the next thread to lock this object.
- *
- * @param [in] object A pointer to a valid PARCThread instance.
- *
- * Example:
- * @code
- * {
- *
- *     parcThread_Notify(object);
- * }
- * @endcode
- */
-parcObject_ImplementNotify(parcThread, PARCThread);
-
-/**
- * Causes the calling thread to wait until either another thread invokes the parcHashMap_Notify() function on the same object.
- *  *
- * @param [in] object A pointer to a valid `PARCThread` instance.
- *
- * Example:
- * @code
- * {
- *
- *     parcThread_Wait(object);
- * }
- * @endcode
- */
-parcObject_ImplementWait(parcThread, PARCThread);
-
-/**
- * Obtain the lock on the given `PARCThread` instance.
- *
- * If the lock is already held by another thread, this function will block.
- * If the lock is aleady held by the current thread, this function will return `false`.
- *
- * Implementors must avoid deadlock by attempting to lock the object a second time within the same calling thread.
- *
- * @param [in] object A pointer to a valid `PARCThread` instance.
- *
- * @return true The lock was obtained successfully.
- * @return false The lock is already held by the current thread, or the `PARCThread` is invalid.
- *
- * Example:
- * @code
- * {
- *     if (parcThread_Lock(object)) {
- *
- *     }
- * }
- * @endcode
- */
-parcObject_ImplementLock(parcThread, PARCThread);
-
-/**
- * Try to obtain the advisory lock on the given PARCThread instance.
- *
- * Once the lock is obtained, the caller must release the lock as soon as possible.
- *
- * @param [in] object A pointer to a valid PARCThread instance.
- *
- * @return true The PARCThread is locked.
- * @return false The PARCThread is unlocked.
- *
- * Example:
- * @code
- * {
- *     parcThread_TryLock(object);
- * }
- * @endcode
- */
-parcObject_ImplementTryLock(parcThread, PARCThread);
-
-/**
- * Try to unlock the advisory lock on the given `PARCHashMap` instance.
- *
- * @param [in] object A pointer to a valid `PARCThread` instance.
- *
- * @return true The `PARCThread` was locked and now is unlocked.
- * @return false The `PARCThread` was not locked and remains unlocked.
- *
- * Example:
- * @code
- * {
- *     parcThread_Unlock(object);
- * }
- * @endcode
- */
-parcObject_ImplementUnlock(parcThread, PARCThread);
-
-/**
- * Determine if the advisory lock on the given `PARCThread` instance is locked.
- *
- * @param [in] object A pointer to a valid `PARCThread` instance.
- *
- * @return true The `PARCThread` is locked.
- * @return false The `PARCThread` is unlocked.
- * Example:
- * @code
- * {
- *     if (parcThread_IsLocked(object)) {
- *         ...
- *     }
- * }
- * @endcode
- */
-parcObject_ImplementIsLocked(parcThread, PARCThread);
-
-
-/**
- * <#One Line Description#>
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [<#in#> | <#out#> | <#in,out#>] <#name#> <#description#>
- *
- * @return <#value#> <#explanation#>
- *
- * Example:
- * @code
- * {
- *     <#example#>
- * }
- * @endcode
- */
-void parcThread_Start(PARCThread *thread);
-
-/**
- * <#One Line Description#>
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [<#in#> | <#out#> | <#in,out#>] <#name#> <#description#>
- *
- * @return <#value#> <#explanation#>
- *
- * Example:
- * @code
- * {
- *     <#example#>
- * }
- * @endcode
- */
-PARCObject *parcThread_GetParameter(const PARCThread *thread);
-
-/**
- * <#One Line Description#>
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [<#in#> | <#out#> | <#in,out#>] <#name#> <#description#>
- *
- * @return <#value#> <#explanation#>
- *
- * Example:
- * @code
- * {
- *     <#example#>
- * }
- * @endcode
- */
-bool parcThread_Cancel(PARCThread *thread);
-
-/**
- * <#One Line Description#>
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [<#in#> | <#out#> | <#in,out#>] <#name#> <#description#>
- *
- * @return <#value#> <#explanation#>
- *
- * Example:
- * @code
- * {
- *     <#example#>
- * }
- * @endcode
- */
-bool parcThread_IsCancelled(const PARCThread *thread);
-
-/**
- * <#One Line Description#>
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [<#in#> | <#out#> | <#in,out#>] <#name#> <#description#>
- *
- * @return <#value#> <#explanation#>
- *
- * Example:
- * @code
- * {
- *     <#example#>
- * }
- * @endcode
- */
-bool parcThread_IsRunning(const PARCThread *thread);
-
-/**
- * <#One Line Description#>
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [<#in#> | <#out#> | <#in,out#>] <#name#> <#description#>
- *
- * @return <#value#> <#explanation#>
- *
- * Example:
- * @code
- * {
- *     <#example#>
- * }
- * @endcode
- */
-int parcThread_GetId(const PARCThread *thread);
-
-/**
- * <#One Line Description#>
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [<#in#> | <#out#> | <#in,out#>] <#name#> <#description#>
- *
- * @return <#value#> <#explanation#>
- *
- * Example:
- * @code
- * {
- *     <#example#>
- * }
- * @endcode
- */
-void parcThread_Join(PARCThread *thread);
-#endif
diff --git a/libparc/parc/concurrent/parc_ThreadPool.c b/libparc/parc/concurrent/parc_ThreadPool.c
deleted file mode 100644
index 2d9ef6d6..00000000
--- a/libparc/parc/concurrent/parc_ThreadPool.c
+++ /dev/null
@@ -1,457 +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 <config.h>
-#include <stdio.h>
-
-#include <parc/algol/parc_Object.h>
-#include <parc/algol/parc_DisplayIndented.h>
-#include <parc/algol/parc_Memory.h>
-
-#include <parc/algol/parc_SortedList.h>
-#include <parc/algol/parc_LinkedList.h>
-
-#include <parc/concurrent/parc_AtomicUint64.h>
-#include <parc/concurrent/parc_ThreadPool.h>
-#include <parc/concurrent/parc_Thread.h>
-
-struct PARCThreadPool {
-    bool continueExistingPeriodicTasksAfterShutdown;
-    bool executeExistingDelayedTasksAfterShutdown;
-    bool removeOnCancel;
-    PARCLinkedList *workQueue;
-    PARCLinkedList *threads;
-    int poolSize;
-    int maximumPoolSize;
-    long taskCount;
-    bool isShutdown;
-    bool isTerminated;
-    bool isTerminating;
-
-    PARCAtomicUint64 *completedTaskCount;
-};
-
-static void *
-_parcThreadPool_Worker(const PARCThread *thread, const PARCThreadPool *pool)
-{
-    while (parcThread_IsCancelled(thread) == false && pool->isTerminated == false) {
-        if (parcLinkedList_Lock(pool->workQueue)) {
-            PARCFutureTask *task = parcLinkedList_RemoveFirst(pool->workQueue);
-            if (task != NULL) {
-                parcAtomicUint64_Increment(pool->completedTaskCount);
-                parcLinkedList_Unlock(pool->workQueue);
-                parcFutureTask_Run(task);
-                parcFutureTask_Release(&task);
-                parcLinkedList_Lock(pool->workQueue);
-
-                parcLinkedList_Notify(pool->workQueue);
-            } else {
-                parcLinkedList_WaitFor(pool->workQueue, 1000000000);
-            }
-            parcLinkedList_Unlock(pool->workQueue);
-        }
-    }
-
-    return NULL;
-}
-
-static void
-_parcThreadPool_CancelAll(const PARCThreadPool *pool)
-{
-    PARCIterator *iterator = parcLinkedList_CreateIterator(pool->threads);
-
-    while (parcIterator_HasNext(iterator)) {
-        PARCThread *thread = parcIterator_Next(iterator);
-        parcThread_Cancel(thread);
-    }
-    parcIterator_Release(&iterator);
-}
-
-static void
-_parcThreadPool_JoinAll(const PARCThreadPool *pool)
-{
-    PARCIterator *iterator = parcLinkedList_CreateIterator(pool->threads);
-
-    while (parcIterator_HasNext(iterator)) {
-        PARCThread *thread = parcIterator_Next(iterator);
-        parcThread_Join(thread);
-    }
-    parcIterator_Release(&iterator);
-}
-
-static bool
-_parcThreadPool_Destructor(PARCThreadPool **instancePtr)
-{
-    parcAssertNotNull(instancePtr, "Parameter must be a non-null pointer to a PARCThreadPool pointer.");
-    PARCThreadPool *pool = *instancePtr;
-
-    if (pool->isShutdown == false) {
-        _parcThreadPool_CancelAll(pool);
-        _parcThreadPool_JoinAll(pool);
-    }
-
-    parcAtomicUint64_Release(&pool->completedTaskCount);
-    parcLinkedList_Release(&pool->threads);
-
-    if (parcObject_Lock(pool->workQueue)) {
-        parcLinkedList_Release(&pool->workQueue);
-    }
-
-    return true;
-}
-
-parcObject_ImplementAcquire(parcThreadPool, PARCThreadPool);
-
-parcObject_ImplementRelease(parcThreadPool, PARCThreadPool);
-
-parcObject_Override(PARCThreadPool, PARCObject,
-                    .isLockable = true,
-                    .destructor = (PARCObjectDestructor *) _parcThreadPool_Destructor,
-                    .copy = (PARCObjectCopy *) parcThreadPool_Copy,
-                    .toString = (PARCObjectToString *) parcThreadPool_ToString,
-                    .equals = (PARCObjectEquals *) parcThreadPool_Equals,
-                    .compare = (PARCObjectCompare *) parcThreadPool_Compare,
-                    .hashCode = (PARCObjectHashCode *) parcThreadPool_HashCode);
-
-void
-parcThreadPool_AssertValid(const PARCThreadPool *instance)
-{
-    parcAssertTrue(parcThreadPool_IsValid(instance),
-               "PARCThreadPool is not valid.");
-}
-
-
-PARCThreadPool *
-parcThreadPool_Create(int poolSize)
-{
-    PARCThreadPool *result = parcObject_CreateInstance(PARCThreadPool);
-
-    if (result != NULL) {
-        result->poolSize = poolSize;
-        result->maximumPoolSize = poolSize;
-        result->taskCount = 0;
-        result->isShutdown = false;
-        result->isTerminated = false;
-        result->isTerminating = false;
-        result->workQueue = parcLinkedList_Create();
-        result->threads = parcLinkedList_Create();
-
-        result->completedTaskCount = parcAtomicUint64_Create(0);
-
-        result->continueExistingPeriodicTasksAfterShutdown = false;
-        result->executeExistingDelayedTasksAfterShutdown = false;
-        result->removeOnCancel = true;
-
-        if (parcObject_Lock(result)) {
-            for (int i = 0; i < poolSize; i++) {
-                PARCThread *thread = parcThread_Create((void *(*)(PARCThread *, PARCObject *))_parcThreadPool_Worker, (PARCObject *) result);
-                parcLinkedList_Append(result->threads, thread);
-                parcThread_Start(thread);
-                parcThread_Release(&thread);
-            }
-            parcObject_Unlock(result);
-        }
-    }
-
-    return result;
-}
-
-int
-parcThreadPool_Compare(const PARCThreadPool *instance, const PARCThreadPool *other)
-{
-    int result = 0;
-
-    return result;
-}
-
-PARCThreadPool *
-parcThreadPool_Copy(const PARCThreadPool *original)
-{
-    PARCThreadPool *result = parcThreadPool_Create(original->poolSize);
-
-    return result;
-}
-
-void
-parcThreadPool_Display(const PARCThreadPool *instance, int indentation)
-{
-    parcDisplayIndented_PrintLine(indentation, "PARCThreadPool@%p {", instance);
-    /* Call Display() functions for the fields here. */
-    parcDisplayIndented_PrintLine(indentation, "}");
-}
-
-bool
-parcThreadPool_Equals(const PARCThreadPool *x, const PARCThreadPool *y)
-{
-    bool result = false;
-
-    if (x == y) {
-        result = true;
-    } else if (x == NULL || y == NULL) {
-        result = false;
-    } else {
-        /* perform instance specific equality tests here. */
-        if (x->poolSize == y->poolSize) {
-            result = true;
-        }
-    }
-
-    return result;
-}
-
-PARCHashCode
-parcThreadPool_HashCode(const PARCThreadPool *instance)
-{
-    PARCHashCode result = 0;
-
-    return result;
-}
-
-bool
-parcThreadPool_IsValid(const PARCThreadPool *instance)
-{
-    bool result = false;
-
-    if (instance != NULL) {
-        result = true;
-    }
-
-    return result;
-}
-
-PARCJSON *
-parcThreadPool_ToJSON(const PARCThreadPool *instance)
-{
-    PARCJSON *result = parcJSON_Create();
-
-    if (result != NULL) {
-    }
-
-    return result;
-}
-
-char *
-parcThreadPool_ToString(const PARCThreadPool *instance)
-{
-    char *result = parcMemory_Format("PARCThreadPool@%p\n", instance);
-
-    return result;
-}
-
-void
-parcThreadPool_SetAllowCoreThreadTimeOut(PARCThreadPool *pool, bool value)
-{
-}
-
-bool
-parcThreadPool_GetAllowsCoreThreadTimeOut(const PARCThreadPool *pool)
-{
-    return false;
-}
-
-bool
-parcThreadPool_AwaitTermination(PARCThreadPool *pool, PARCTimeout *timeout)
-{
-    bool result = false;
-
-    if (pool->isTerminating) {
-        if (parcLinkedList_Lock(pool->workQueue)) {
-            while (parcLinkedList_Size(pool->workQueue) > 0) {
-                if (parcTimeout_IsNever(timeout)) {
-                    parcLinkedList_Wait(pool->workQueue);
-                } else {
-                    // This is not accurate as this will continue the delay, rather than keep a cumulative amount of delay.
-                    uint64_t delay = parcTimeout_InNanoSeconds(timeout);
-                    parcLinkedList_WaitFor(pool->workQueue, delay);
-                }
-            }
-            result = true;
-            parcLinkedList_Unlock(pool->workQueue);
-        }
-
-        parcThreadPool_ShutdownNow(pool);
-    }
-
-    return result;
-}
-
-bool
-parcThreadPool_Execute(PARCThreadPool *pool, PARCFutureTask *task)
-{
-    bool result = false;
-
-    if (parcThreadPool_Lock(pool)) {
-        if (pool->isShutdown == false) {
-            parcThreadPool_Unlock(pool);
-            if (parcLinkedList_Lock(pool->workQueue)) {
-                parcLinkedList_Append(pool->workQueue, task);
-                parcLinkedList_Notify(pool->workQueue);
-                parcLinkedList_Unlock(pool->workQueue);
-                result = true;
-            }
-        } else {
-            parcThreadPool_Unlock(pool);
-        }
-    }
-
-    return result;
-}
-
-int
-parcThreadPool_GetActiveCount(const PARCThreadPool *pool)
-{
-    return pool->poolSize;
-}
-
-uint64_t
-parcThreadPool_GetCompletedTaskCount(const PARCThreadPool *pool)
-{
-    return parcAtomicUint64_GetValue(pool->completedTaskCount);
-}
-
-int
-parcThreadPool_GetCorePoolSize(const PARCThreadPool *pool)
-{
-    return pool->poolSize;
-}
-
-PARCTimeout *
-parcThreadPool_GetKeepAliveTime(const PARCThreadPool *pool)
-{
-    return PARCTimeout_Never;
-}
-
-int
-parcThreadPool_GetLargestPoolSize(const PARCThreadPool *pool)
-{
-    return pool->poolSize;
-}
-
-int
-parcThreadPool_GetMaximumPoolSize(const PARCThreadPool *pool)
-{
-    return pool->maximumPoolSize;
-}
-
-int
-parcThreadPool_GetPoolSize(const PARCThreadPool *pool)
-{
-    return pool->poolSize;
-}
-
-PARCLinkedList *
-parcThreadPool_GetQueue(const PARCThreadPool *pool)
-{
-    return pool->workQueue;
-}
-
-long
-parcThreadPool_GetTaskCount(const PARCThreadPool *pool)
-{
-    return pool->taskCount;
-}
-
-bool
-parcThreadPool_IsShutdown(const PARCThreadPool *pool)
-{
-    return pool->isShutdown;
-}
-
-bool
-parcThreadPool_IsTerminated(const PARCThreadPool *pool)
-{
-    return pool->isTerminated;
-}
-
-bool
-parcThreadPool_IsTerminating(const PARCThreadPool *pool)
-{
-    return pool->isTerminating;
-}
-
-int
-parcThreadPool_PrestartAllCoreThreads(PARCThreadPool *pool)
-{
-    return 0;
-}
-
-bool
-parcThreadPool_PrestartCoreThread(PARCThreadPool *pool)
-{
-    return 0;
-}
-
-void
-parcThreadPool_Purge(PARCThreadPool *pool)
-{
-}
-
-bool
-parcThreadPool_Remove(PARCThreadPool *pool, PARCFutureTask *task)
-{
-    return false;
-}
-
-void
-parcThreadPool_SetCorePoolSize(PARCThreadPool *pool, int corePoolSize)
-{
-}
-
-void
-parcThreadPool_SetKeepAliveTime(PARCThreadPool *pool, PARCTimeout *timeout)
-{
-}
-
-void
-parcThreadPool_SetMaximumPoolSize(PARCThreadPool *pool, int maximumPoolSize)
-{
-}
-
-void
-parcThreadPool_Shutdown(PARCThreadPool *pool)
-{
-    if (parcThreadPool_Lock(pool)) {
-        pool->isShutdown = true;
-        pool->isTerminating = true;
-        parcThreadPool_Unlock(pool);
-    }
-}
-
-PARCLinkedList *
-parcThreadPool_ShutdownNow(PARCThreadPool *pool)
-{
-    parcThreadPool_Shutdown(pool);
-
-    // Cause all of the worker threads to exit.
-    _parcThreadPool_CancelAll(pool);
-
-    // Wake them all up so they detect that they are cancelled.
-    if (parcThreadPool_Lock(pool)) {
-        parcThreadPool_NotifyAll(pool);
-        parcThreadPool_Unlock(pool);
-    }
-
-    if (parcLinkedList_Lock(pool->workQueue)) {
-        parcLinkedList_NotifyAll(pool->workQueue);
-        parcLinkedList_Unlock(pool->workQueue);
-    }
-    // Join with all of them, thereby cleaning up all of them.
-    _parcThreadPool_JoinAll(pool);
-
-    pool->isTerminated = true;
-    return NULL;
-}
diff --git a/libparc/parc/concurrent/parc_ThreadPool.h b/libparc/parc/concurrent/parc_ThreadPool.h
deleted file mode 100755
index 7a7b548e..00000000
--- a/libparc/parc/concurrent/parc_ThreadPool.h
+++ /dev/null
@@ -1,625 +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 parc_ThreadPool.h
- * @ingroup threading
- * @brief <#Brief Description#>
- *
- * <#Detailed Description#>
- *
- */
-#ifndef PARCLibrary_parc_ThreadPool
-#define PARCLibrary_parc_ThreadPool
-#include <stdbool.h>
-
-#include <parc/algol/parc_JSON.h>
-#include <parc/algol/parc_HashCode.h>
-#include <parc/algol/parc_LinkedList.h>
-#include <parc/concurrent/parc_Timeout.h>
-#include <parc/concurrent/parc_FutureTask.h>
-
-struct PARCThreadPool;
-typedef struct PARCThreadPool PARCThreadPool;
-
-/**
- * Increase the number of references to a `PARCThreadPool` instance.
- *
- * Note that new `PARCThreadPool` is not created,
- * only that the given `PARCThreadPool` reference count is incremented.
- * Discard the reference by invoking `parcThreadPool_Release`.
- *
- * @param [in] instance A pointer to a valid PARCThreadPool instance.
- *
- * @return The same value as @p instance.
- *
- * Example:
- * @code
- * {
- *     PARCThreadPool *a = parcThreadPool_Create();
- *
- *     PARCThreadPool *b = parcThreadPool_Acquire();
- *
- *     parcThreadPool_Release(&a);
- *     parcThreadPool_Release(&b);
- * }
- * @endcode
- */
-PARCThreadPool *parcThreadPool_Acquire(const PARCThreadPool *instance);
-
-#ifdef PARCLibrary_DISABLE_VALIDATION
-#  define parcThreadPool_OptionalAssertValid(_instance_)
-#else
-#  define parcThreadPool_OptionalAssertValid(_instance_) parcThreadPool_AssertValid(_instance_)
-#endif
-
-/**
- * Assert that the given `PARCThreadPool` instance is valid.
- *
- * @param [in] instance A pointer to a valid PARCThreadPool instance.
- *
- * Example:
- * @code
- * {
- *     PARCThreadPool *a = parcThreadPool_Create();
- *
- *     parcThreadPool_AssertValid(a);
- *
- *     printf("Instance is valid.\n");
- *
- *     parcThreadPool_Release(&b);
- * }
- * @endcode
- */
-void parcThreadPool_AssertValid(const PARCThreadPool *instance);
-
-/**
- * Create an instance of PARCThreadPool
- *
- * <#Paragraphs Of Explanation#>
- *
- * @return non-NULL A pointer to a valid PARCThreadPool instance.
- * @return NULL An error occurred.
- *
- * Example:
- * @code
- * {
- *     PARCThreadPool *a = parcThreadPool_Create();
- *
- *     parcThreadPool_Release(&a);
- * }
- * @endcode
- */
-PARCThreadPool *parcThreadPool_Create(int poolSize);
-
-/**
- * Compares @p instance with @p other for order.
- *
- * Returns a negative integer, zero, or a positive integer as @p instance
- * is less than, equal to, or greater than @p other.
- *
- * @param [in] instance A pointer to a valid PARCThreadPool instance.
- * @param [in] other A pointer to a valid PARCThreadPool instance.
- *
- * @return <0 Instance is less than @p other.
- * @return 0 Instance a and instance b compare the same.
- * @return >0 Instance a is greater than instance b.
- *
- * Example:
- * @code
- * {
- *     PARCThreadPool *a = parcThreadPool_Create();
- *     PARCThreadPool *b = parcThreadPool_Create();
- *
- *     if (parcThreadPool_Compare(a, b) == 0) {
- *         printf("Instances are equal.\n");
- *     }
- *
- *     parcThreadPool_Release(&a);
- *     parcThreadPool_Release(&b);
- * }
- * @endcode
- *
- * @see parcThreadPool_Equals
- */
-int parcThreadPool_Compare(const PARCThreadPool *instance, const PARCThreadPool *other);
-
-/**
- * Create an independent copy the given `PARCBuffer`
- *
- * A new buffer is created as a complete copy of the original.
- *
- * @param [in] original A pointer to a valid PARCThreadPool instance.
- *
- * @return NULL Memory could not be allocated.
- * @return non-NULL A pointer to a new `PARCThreadPool` instance.
- *
- * Example:
- * @code
- * {
- *     PARCThreadPool *a = parcThreadPool_Create();
- *
- *     PARCThreadPool *copy = parcThreadPool_Copy(&b);
- *
- *     parcThreadPool_Release(&b);
- *     parcThreadPool_Release(&copy);
- * }
- * @endcode
- */
-PARCThreadPool *parcThreadPool_Copy(const PARCThreadPool *original);
-
-/**
- * Print a human readable representation of the given `PARCThreadPool`.
- *
- * @param [in] instance A pointer to a valid PARCThreadPool instance.
- * @param [in] indentation The indentation level to use for printing.
- *
- * Example:
- * @code
- * {
- *     PARCThreadPool *a = parcThreadPool_Create();
- *
- *     parcThreadPool_Display(a, 0);
- *
- *     parcThreadPool_Release(&a);
- * }
- * @endcode
- */
-void parcThreadPool_Display(const PARCThreadPool *instance, int indentation);
-
-/**
- * Determine if two `PARCThreadPool` instances are equal.
- *
- * The following equivalence relations on non-null `PARCThreadPool` instances are maintained: *
- *   * It is reflexive: for any non-null reference value x, `parcThreadPool_Equals(x, x)` must return true.
- *
- *   * It is symmetric: for any non-null reference values x and y, `parcThreadPool_Equals(x, y)` must return true if and only if
- *        `parcThreadPool_Equals(y x)` returns true.
- *
- *   * It is transitive: for any non-null reference values x, y, and z, if
- *        `parcThreadPool_Equals(x, y)` returns true and
- *        `parcThreadPool_Equals(y, z)` returns true,
- *        then `parcThreadPool_Equals(x, z)` must return true.
- *
- *   * It is consistent: for any non-null reference values x and y, multiple invocations of `parcThreadPool_Equals(x, y)`
- *         consistently return true or consistently return false.
- *
- *   * For any non-null reference value x, `parcThreadPool_Equals(x, NULL)` must return false.
- *
- * @param [in] x A pointer to a valid PARCThreadPool instance.
- * @param [in] y A pointer to a valid PARCThreadPool instance.
- *
- * @return true The instances x and y are equal.
- *
- * Example:
- * @code
- * {
- *     PARCThreadPool *a = parcThreadPool_Create();
- *     PARCThreadPool *b = parcThreadPool_Create();
- *
- *     if (parcThreadPool_Equals(a, b)) {
- *         printf("Instances are equal.\n");
- *     }
- *
- *     parcThreadPool_Release(&a);
- *     parcThreadPool_Release(&b);
- * }
- * @endcode
- * @see parcThreadPool_HashCode
- */
-bool parcThreadPool_Equals(const PARCThreadPool *x, const PARCThreadPool *y);
-
-/**
- * Returns a hash code value for the given instance.
- *
- * The general contract of `HashCode` is:
- *
- * Whenever it is invoked on the same instance more than once during an execution of an application,
- * the `HashCode` function must consistently return the same value,
- * provided no information used in a corresponding comparisons on the instance is modified.
- *
- * This value need not remain consistent from one execution of an application to another execution of the same application.
- * If two instances are equal according to the {@link parcThreadPool_Equals} method,
- * then calling the {@link parcThreadPool_HashCode} method on each of the two instances must produce the same integer result.
- *
- * It is not required that if two instances are unequal according to the
- * {@link parcThreadPool_Equals} function,
- * then calling the `parcThreadPool_HashCode`
- * method on each of the two objects must produce distinct integer results.
- *
- * @param [in] instance A pointer to a valid PARCThreadPool instance.
- *
- * @return The hashcode for the given instance.
- *
- * Example:
- * @code
- * {
- *     PARCThreadPool *a = parcThreadPool_Create();
- *
- *     PARCHashCode hashValue = parcThreadPool_HashCode(buffer);
- *     parcThreadPool_Release(&a);
- * }
- * @endcode
- */
-PARCHashCode parcThreadPool_HashCode(const PARCThreadPool *instance);
-
-/**
- * Determine if an instance of `PARCThreadPool` is valid.
- *
- * Valid means the internal state of the type is consistent with its required current or future behaviour.
- * This may include the validation of internal instances of types.
- *
- * @param [in] instance A pointer to a valid PARCThreadPool instance.
- *
- * @return true The instance is valid.
- * @return false The instance is not valid.
- *
- * Example:
- * @code
- * {
- *     PARCThreadPool *a = parcThreadPool_Create();
- *
- *     if (parcThreadPool_IsValid(a)) {
- *         printf("Instance is valid.\n");
- *     }
- *
- *     parcThreadPool_Release(&a);
- * }
- * @endcode
- *
- */
-bool parcThreadPool_IsValid(const PARCThreadPool *instance);
-
-/**
- * Release a previously acquired reference to the given `PARCThreadPool` instance,
- * decrementing the reference count for the instance.
- *
- * The pointer to the instance is set to NULL as a side-effect of this function.
- *
- * If the invocation causes the last reference to the instance to be released,
- * the instance is deallocated and the instance's implementation will perform
- * additional cleanup and release other privately held references.
- *
- * @param [in,out] instancePtr A pointer to a pointer to the instance to release.
- *
- * Example:
- * @code
- * {
- *     PARCThreadPool *a = parcThreadPool_Create();
- *
- *     parcThreadPool_Release(&a);
- * }
- * @endcode
- */
-void parcThreadPool_Release(PARCThreadPool **instancePtr);
-
-/**
- * Create a `PARCJSON` instance (representation) of the given object.
- *
- * @param [in] instance A pointer to a valid PARCThreadPool instance.
- *
- * @return NULL Memory could not be allocated to contain the `PARCJSON` instance.
- * @return non-NULL An allocated C string that must be deallocated via parcMemory_Deallocate().
- *
- * Example:
- * @code
- * {
- *     PARCThreadPool *a = parcThreadPool_Create();
- *
- *     PARCJSON *json = parcThreadPool_ToJSON(a);
- *
- *     printf("JSON representation: %s\n", parcJSON_ToString(json));
- *     parcJSON_Release(&json);
- *
- *     parcThreadPool_Release(&a);
- * }
- * @endcode
- */
-PARCJSON *parcThreadPool_ToJSON(const PARCThreadPool *instance);
-
-/**
- * Produce a null-terminated string representation of the specified `PARCThreadPool`.
- *
- * The result must be freed by the caller via {@link parcMemory_Deallocate}.
- *
- * @param [in] instance A pointer to a valid PARCThreadPool instance.
- *
- * @return NULL Cannot allocate memory.
- * @return non-NULL A pointer to an allocated, null-terminated C string that must be deallocated via {@link parcMemory_Deallocate}.
- *
- * Example:
- * @code
- * {
- *     PARCThreadPool *a = parcThreadPool_Create();
- *
- *     char *string = parcThreadPool_ToString(a);
- *
- *     parcThreadPool_Release(&a);
- *
- *     parcMemory_Deallocate(&string);
- * }
- * @endcode
- *
- * @see parcThreadPool_Display
- */
-char *parcThreadPool_ToString(const PARCThreadPool *instance);
-
-/**
- * Wakes up a single thread that is waiting on this object (see `parcThreadPool_Wait)`.
- * If any threads are waiting on this object, one of them is chosen to be awakened.
- * The choice is arbitrary and occurs at the discretion of the underlying implementation.
- *
- * The awakened thread will not be able to proceed until the current thread relinquishes the lock on this object.
- * The awakened thread will compete in the usual manner with any other threads that might be actively
- * competing to synchronize on this object;
- * for example, the awakened thread enjoys no reliable privilege or disadvantage in being the next thread to lock this object.
- *
- * @param [in] object A pointer to a valid PARCThreadPool instance.
- *
- * Example:
- * @code
- * {
- *     if (parcThreadPool_Lock(object)) {
- *         parcThreadPool_Notify(object);
- *         parcThreadPool_Unlock(object);
- *     }
- * }
- * @endcode
- */
-parcObject_ImplementNotify(parcThreadPool, PARCThreadPool);
-
-/**
- * Wakes up all threads that are waiting on the given object's lock.
- *
- * A thread waits on an object by calling one of the wait methods, `parcThreadPool_Wait`, `parcThreadPool_WaitFor`, `parcThreadPool_WaitUntil`.
- * The awakened threads will proceed after the current thread relinquishes the lock on the given object.
- * The awakened threads will compete in the usual manner with any other threads that might be actively competing
- * to synchronize on this object.
- * Awakened threads have no priority between them in being the next thread to lock this object.
- *
- * This method can only be called by a thread that is the owner of this object's lock.
- *
- * @param [in] object A pointer to a valid `PARCThreadPool` instance.
- *
- * Example:
- * @code
- * {
- *     if (parcThreadPool_Lock(object)) {
- *         parcThreadPool_NotifyAll(object);
- *         parcThreadPool_Unlock(object);
- *     }
- * }
- * @endcode
- */
-parcObject_ImplementNotifyAll(parcThreadPool, PARCThreadPool);
-
-/**
- * Causes the calling thread to wait until either another thread invokes the parcThreadPool_Notify() function on the same object.
- *  *
- * @param [in] object A pointer to a valid `PARCThreadPool` instance.
- *
- * Example:
- * @code
- * {
- *
- *     parcThreadPool_Wait(object);
- * }
- * @endcode
- */
-parcObject_ImplementWait(parcThreadPool, PARCThreadPool);
-
-/**
- * Obtain the lock on the given `PARCThreadPool` instance.
- *
- * If the lock is already held by another thread, this function will block.
- * If the lock is aleady held by the current thread, this function will return `false`.
- *
- * Implementors must avoid deadlock by attempting to lock the object a second time within the same calling thread.
- *
- * @param [in] object A pointer to a valid `PARCThreadPool` instance.
- *
- * @return true The lock was obtained successfully.
- * @return false The lock is already held by the current thread, or the `PARCThreadPool` is invalid.
- *
- * Example:
- * @code
- * {
- *     if (parcThreadPool_Lock(object)) {
- *
- *     }
- * }
- * @endcode
- */
-parcObject_ImplementLock(parcThreadPool, PARCThreadPool);
-
-/**
- * Try to obtain the advisory lock on the given PARCThreadPool instance.
- *
- * Once the lock is obtained, the caller must release the lock as soon as possible.
- *
- * @param [in] object A pointer to a valid PARCThreadPool instance.
- *
- * @return true The PARCThreadPool is locked.
- * @return false The PARCThreadPool is unlocked.
- *
- * Example:
- * @code
- * {
- *     parcThreadPool_TryLock(object);
- * }
- * @endcode
- */
-parcObject_ImplementTryLock(parcThreadPool, PARCThreadPool);
-
-/**
- * Try to unlock the advisory lock on the given `PARCThreadPool` instance.
- *
- * @param [in] object A pointer to a valid `PARCThreadPool` instance.
- *
- * @return true The `PARCThreadPool` was locked and now is unlocked.
- * @return false The `PARCThreadPool` was not locked and remains unlocked.
- *
- * Example:
- * @code
- * {
- *     parcThreadPool_Unlock(object);
- * }
- * @endcode
- */
-parcObject_ImplementUnlock(parcThreadPool, PARCThreadPool);
-
-/**
- * Determine if the advisory lock on the given `PARCThreadPool` instance is locked.
- *
- * @param [in] object A pointer to a valid `PARCThreadPool` instance.
- *
- * @return true The `PARCThreadPool` is locked.
- * @return false The `PARCThreadPool` is unlocked.
- * Example:
- * @code
- * {
- *     if (parcThreadPool_IsLocked(object)) {
- *         ...
- *     }
- * }
- * @endcode
- */
-parcObject_ImplementIsLocked(parcThreadPool, PARCThreadPool);
-
-/**
- * Sets the policy governing whether core threads may time out and terminate if no tasks arrive within the keep-alive time, being replaced if needed when new tasks arrive.
- */
-void parcThreadPool_SetAllowCoreThreadTimeOut(PARCThreadPool *pool, bool value);
-
-/**
- * Returns true if this pool allows core threads to time out and terminate if no tasks arrive within the keepAlive time, being replaced if needed when new tasks arrive.
- */
-bool parcThreadPool_GetAllowsCoreThreadTimeOut(const PARCThreadPool *pool);
-
-/**
- * Blocks until all tasks have completed execution after a shutdown request, or the timeout occurs, whichever happens first.
- */
-bool parcThreadPool_AwaitTermination(PARCThreadPool *pool, PARCTimeout *timeout);
-
-/**
- * Executes the given task sometime in the future.
- */
-bool parcThreadPool_Execute(PARCThreadPool *pool, PARCFutureTask *task);
-
-/**
- * Returns the approximate number of threads that are actively executing tasks.
- */
-int parcThreadPool_GetActiveCount(const PARCThreadPool *pool);
-
-/**
- * Returns the approximate total number of tasks that have completed execution.
- */
-uint64_t parcThreadPool_GetCompletedTaskCount(const PARCThreadPool *pool);
-
-/**
- * Returns the core number of threads.
- */
-int parcThreadPool_GetCorePoolSize(const PARCThreadPool *pool);
-
-/**
- * Returns the thread keep-alive time, which is the amount of time that threads in excess of the core pool size may remain idle before being terminated.
- */
-PARCTimeout *parcThreadPool_GetKeepAliveTime(const PARCThreadPool *pool);
-
-/**
- * Returns the largest number of threads that have ever simultaneously been in the pool.
- */
-int parcThreadPool_GetLargestPoolSize(const PARCThreadPool *pool);
-
-/**
- * Returns the maximum allowed number of threads.
- */
-int parcThreadPool_GetMaximumPoolSize(const PARCThreadPool *pool);
-
-/**
- * Returns the current number of threads in the pool.
- */
-int parcThreadPool_GetPoolSize(const PARCThreadPool *pool);
-
-/**
- * Returns the task queue used by this executor.
- */
-PARCLinkedList *parcThreadPool_GetQueue(const PARCThreadPool *pool);
-
-/**
- * Returns the approximate total number of tasks that have ever been scheduled for execution.
- */
-long parcThreadPool_GetTaskCount(const PARCThreadPool *pool);
-
-/**
- * Returns true if this executor has been shut down.
- */
-bool parcThreadPool_IsShutdown(const PARCThreadPool *pool);
-
-/**
- * Returns true if all tasks have completed following shut down.
- */
-bool parcThreadPool_IsTerminated(const PARCThreadPool *pool);
-
-/**
- * Returns true if this executor is in the process of terminating after shutdown() or shutdownNow() but has not completely terminated.
- */
-bool parcThreadPool_IsTerminating(const PARCThreadPool *pool);
-
-/**
- * Starts all core threads, causing them to idly wait for work.
- */
-int parcThreadPool_PrestartAllCoreThreads(PARCThreadPool *pool);
-
-/**
- * Starts a core thread, causing it to idly wait for work.
- */
-bool parcThreadPool_PrestartCoreThread(PARCThreadPool *pool);
-
-/**
- * Tries to remove from the work queue all Future tasks that have been cancelled.
- */
-void parcThreadPool_Purge(PARCThreadPool *pool);
-
-/**
- * Removes this task from the executor's internal queue if it is present, thus causing it not to be run if it has not already started.
- */
-bool parcThreadPool_Remove(PARCThreadPool *pool, PARCFutureTask *task);
-
-/**
- * Sets the core number of threads.
- */
-void parcThreadPool_SetCorePoolSize(PARCThreadPool *pool, int corePoolSize);
-
-/**
- * Sets the time limit for which threads may remain idle before being terminated.
- */
-void parcThreadPool_SetKeepAliveTime(PARCThreadPool *pool, PARCTimeout *timeout);
-
-/**
- * Sets the maximum allowed number of threads.
- */
-void parcThreadPool_SetMaximumPoolSize(PARCThreadPool *pool, int maximumPoolSize);
-
-/**
- * Initiates an orderly shutdown in which previously submitted tasks are executed, but no new tasks will be accepted.
- */
-void parcThreadPool_Shutdown(PARCThreadPool *pool);
-
-/**
- * Attempts to stop all actively executing tasks, halts the processing of waiting tasks, and returns a list of the tasks that were awaiting execution.
- */
-PARCLinkedList *parcThreadPool_ShutdownNow(PARCThreadPool *pool);
-#endif
diff --git a/libparc/parc/concurrent/parc_Timeout.c b/libparc/parc/concurrent/parc_Timeout.c
deleted file mode 100755
index 4ea03977..00000000
--- a/libparc/parc/concurrent/parc_Timeout.c
+++ /dev/null
@@ -1,25 +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/concurrent/parc_Timeout.h>
-
-
-bool
-parcTimeout_Equals(PARCTimeout x, PARCTimeout y)
-{
-    return x == y;
-}
diff --git a/libparc/parc/concurrent/parc_Timeout.h b/libparc/parc/concurrent/parc_Timeout.h
deleted file mode 100644
index 9edc24a0..00000000
--- a/libparc/parc/concurrent/parc_Timeout.h
+++ /dev/null
@@ -1,141 +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.
- */
-
-/**
- * @ingroup threading
- *
- */
-#ifndef parc_Timeout_h
-#define parc_Timeout_h
-#include <stdio.h>
-#include <stdint.h>
-#include <stdbool.h>
-
-typedef uint64_t PARCTimeout;
-
-/**
- * @def PARCTimeout_Never
- * This represents a timeout that will never happen.
- */
-#define PARCTimeout_Never NULL
-
-/*
- * @def PARCTimeout_Immediate
- * This represents a timeout that immediately happens.
- * Equivalent to parcTimeout_NanoSeconds(0)
- */
-#define PARCTimeout_Immediate (&(PARCTimeout) { 0 })
-
-/*
- * @def PARCTimeout_NanoSeconds
- * This represents a timeout that will occur in the specified number of nanoseconds.
- */
-#define parcTimeout_NanoSeconds(_nsec_) (&(PARCTimeout) { _nsec_ })
-
-/*
- * @def PARCTimeout_MicroSeconds
- * This represents a timeout that will occur in the specified number of microseconds.
- */
-#define parcTimeout_MicroSeconds(_usec_) parcTimeout_NanoSeconds(_usec_ * 1000)
-
-/*
- * @def PARCTimeout_MilliSeconds
- * This represents a timeout that will occur in the specified number of microseconds.
- */
-#define parcTimeout_MilliSeconds(_msec_) parcTimeout_MicroSeconds(_msec_ * 1000)
-
-/**
- * Determine if two `PARCTimeout` instances are equal.
- *
- * The following equivalence relations on non-null `PARCTimeout` instances are maintained: *
- *   * It is reflexive: for any non-null reference value x, `parcTimeout_Equals(x, x)` must return true.
- *
- *   * It is symmetric: for any non-null reference values x and y, `parcTimeout_Equals(x, y)` must return true if and only if
- *        `parcTimeout_Equals(y x)` returns true.
- *
- *   * It is transitive: for any non-null reference values x, y, and z, if
- *        `parcTimeout_Equals(x, y)` returns true and
- *        `parcTimeout_Equals(y, z)` returns true,
- *        then `parcTimeout_Equals(x, z)` must return true.
- *
- *   * It is consistent: for any non-null reference values x and y, multiple invocations of `parcTimeout_Equals(x, y)`
- *         consistently return true or consistently return false.
- *
- *   * For any non-null reference value x, `parcTimeout_Equals(x, NULL)` must return false.
- *
- * @param [in] x A valid PARCTimeout instance.
- * @param [in] y A valid PARCTimeout instance.
- *
- * @return true The instances x and y are equal.
- *
- * Example:
- * @code
- * {
- *     PARCTimeout *a = parcTimeout_Create();
- *     PARCTimeout *b = parcTimeout_Create();
- *
- *     if (parcTimeout_Equals(a, b)) {
- *         printf("Instances are equal.\n");
- *     }
- *
- *     parcTimeout_Release(&a);
- *     parcTimeout_Release(&b);
- * }
- * @endcode
- * @see parcTimeout_HashCode
- */
-bool parcTimeout_Equals(PARCTimeout x, PARCTimeout y);
-
-/**
- * Predicate function returning true if the given timeout represents an infinite delay.
- *
- * @param [in] timeout A pointer to a valid PARCTimeout value.
- *
- * @return true  The given timeout represents an infinite delay.
- */
-static inline bool
-parcTimeout_IsNever(const PARCTimeout *timeout)
-{
-    return (timeout == PARCTimeout_Never);
-}
-
-/**
- * Predicate function returning true if the given timeout represents an immediate, no-delay timeout.
- *
- * @param [in] timeout A pointer to a valid PARCTimeout value.
- *
- * @return true  The given timeout represents an immediate, no-delay timeout.
- */
-static inline bool
-parcTimeout_IsImmediate(const PARCTimeout *timeout)
-{
-    return parcTimeout_IsNever(timeout) ? false : (*timeout == 0);
-}
-
-/**
- * Return the number of nano-seconds in the given PARCTimeout instance.
- *
- * If the PARCTimeout is never (`parcTimeout_IsNever` returns `true`), the returned value is UINT64_MAX.
- *
- * @param [in] timeout A pointer to a valid PARCTimeout value.
- *
- * @return The number of nano-seconds in the given PARCTimeout instance, UINT64_MAX.
- */
-static inline uint64_t
-parcTimeout_InNanoSeconds(const PARCTimeout *timeout)
-{
-    return parcTimeout_IsNever(timeout) ? UINT64_MAX : *timeout;
-}
-#endif /* parc_Timeout_h */
diff --git a/libparc/parc/concurrent/parc_Timer.c b/libparc/parc/concurrent/parc_Timer.c
deleted file mode 100755
index b1ecb5d2..00000000
--- a/libparc/parc/concurrent/parc_Timer.c
+++ /dev/null
@@ -1,173 +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 <config.h>
-
-#include <parc/algol/parc_Object.h>
-#include <parc/algol/parc_DisplayIndented.h>
-#include <parc/algol/parc_Memory.h>
-
-#include "parc_Timer.h"
-
-struct PARCTimer {
-    int delay;
-};
-
-static void
-_parcTimer_Finalize(PARCTimer **instancePtr)
-{
-    parcAssertNotNull(instancePtr, "Parameter must be a non-null pointer to a PARCTimer pointer.");
-
-
-    /* cleanup the instance fields here */
-}
-
-parcObject_ImplementAcquire(parcTimer, PARCTimer);
-
-parcObject_ImplementRelease(parcTimer, PARCTimer);
-
-parcObject_ExtendPARCObject(PARCTimer, _parcTimer_Finalize, parcTimer_Copy, parcTimer_ToString, parcTimer_Equals, parcTimer_Compare, parcTimer_HashCode, parcTimer_ToJSON);
-
-
-void
-parcTimer_AssertValid(const PARCTimer *instance)
-{
-    parcAssertTrue(parcTimer_IsValid(instance),
-               "PARCTimer is not valid.");
-}
-
-PARCTimer *
-parcTimer_Create(void)
-{
-    PARCTimer *result = parcObject_CreateInstance(PARCTimer);
-
-    if (result != NULL) {
-    }
-
-    return result;
-}
-
-int
-parcTimer_Compare(const PARCTimer *instance, const PARCTimer *other)
-{
-    int result = 0;
-
-    return result;
-}
-
-PARCTimer *
-parcTimer_Copy(const PARCTimer *original)
-{
-    PARCTimer *result = parcTimer_Create();
-
-    return result;
-}
-
-void
-parcTimer_Display(const PARCTimer *instance, int indentation)
-{
-    parcDisplayIndented_PrintLine(indentation, "PARCTimer@%p {", instance);
-    /* Call Display() functions for the fields here. */
-    parcDisplayIndented_PrintLine(indentation, "}");
-}
-
-bool
-parcTimer_Equals(const PARCTimer *x, const PARCTimer *y)
-{
-    bool result = false;
-
-    if (x == y) {
-        result = true;
-    } else if (x == NULL || y == NULL) {
-        result = false;
-    } else {
-        return true;
-    }
-
-    return result;
-}
-
-PARCHashCode
-parcTimer_HashCode(const PARCTimer *instance)
-{
-    PARCHashCode result = 0;
-
-    return result;
-}
-
-bool
-parcTimer_IsValid(const PARCTimer *instance)
-{
-    bool result = false;
-
-    if (instance != NULL) {
-        result = true;
-    }
-
-    return result;
-}
-
-PARCJSON *
-parcTimer_ToJSON(const PARCTimer *instance)
-{
-    PARCJSON *result = parcJSON_Create();
-
-    if (result != NULL) {
-    }
-
-    return result;
-}
-
-char *
-parcTimer_ToString(const PARCTimer *instance)
-{
-    char *result = parcMemory_Format("PARCTimer@%p\n", instance);
-
-    return result;
-}
-
-void
-parcTimer_Cancel(PARCTimer *timer)
-{
-}
-
-int
-parcTimer_Purge(PARCTimer *timer)
-{
-    return 0;
-}
-
-void
-parcTimer_ScheduleAtTime(PARCTimer *timer, PARCFutureTask *task, time_t absoluteTime)
-{
-}
-
-void
-parcTimer_ScheduleAtTimeAndRepeat(PARCTimer *timer, PARCFutureTask *task, time_t firstTime, long period)
-{
-}
-
-void
-parcTimer_ScheduleAfterDelay(PARCTimer *timer, PARCFutureTask *task, long delay)
-{
-}
-
-void
-parcTimer_ScheduleAfterDelayAndRepeat(PARCTimer *timer, PARCFutureTask *task, long delay, long period)
-{
-}
-
diff --git a/libparc/parc/concurrent/parc_Timer.h b/libparc/parc/concurrent/parc_Timer.h
deleted file mode 100755
index 416bfba4..00000000
--- a/libparc/parc/concurrent/parc_Timer.h
+++ /dev/null
@@ -1,431 +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 parc_Timer.h
- * @ingroup threading
- * @brief A facility for threads to schedule tasks for future execution in a background thread.
- *
- * Tasks may be scheduled for one-time execution, or for repeated execution at regular intervals.
- *
- * Corresponding to each Timer object is a single background thread that is used to execute all of the timer's tasks,
- * sequentially. Timer tasks should complete quickly.
- * If a timer task takes excessive time to complete, it "hogs" the timer's task execution thread.
- * This can, in turn, delay the execution of subsequent tasks,
- * which may "bunch up" and execute in rapid succession when (and if) the offending task finally completes.
- *
- * After the last live reference to a Timer object goes away and all outstanding tasks have completed execution,
- * the timer's task execution thread terminates gracefully (and becomes subject to garbage collection).
- * However, this can take arbitrarily long to occur.
- * By default, the task execution thread does not run as a daemon thread,
- * so it is capable of keeping an application from terminating.
- * If a caller wants to terminate a timer's task execution thread rapidly, the caller should invoke the timer's cancel method.
- *
- * If the timer's task execution thread terminates unexpectedly,
- * for example, because its stop method is invoked,
- * any further attempt to schedule a task on the timer will result in an IllegalStateException,
- * as if the timer's cancel method had been invoked.
- *
- * This class is thread-safe: multiple threads can share a single Timer object without the need for external synchronization.
- *
- * This class does not offer real-time guarantees: it schedules tasks using the Object.wait(long) method.
- *
- */
-#ifndef PARCLibrary_parc_Timer
-#define PARCLibrary_parc_Timer
-#include <stdbool.h>
-
-#include <parc/algol/parc_JSON.h>
-#include <parc/algol/parc_HashCode.h>
-#include <parc/concurrent/parc_FutureTask.h>
-
-struct PARCTimer;
-typedef struct PARCTimer PARCTimer;
-
-/**
- * Increase the number of references to a `PARCTimer` instance.
- *
- * Note that new `PARCTimer` is not created,
- * only that the given `PARCTimer` reference count is incremented.
- * Discard the reference by invoking `parcTimer_Release`.
- *
- * @param [in] instance A pointer to a valid PARCTimer instance.
- *
- * @return The same value as @p instance.
- *
- * Example:
- * @code
- * {
- *     PARCTimer *a = parcTimer_Create();
- *
- *     PARCTimer *b = parcTimer_Acquire();
- *
- *     parcTimer_Release(&a);
- *     parcTimer_Release(&b);
- * }
- * @endcode
- */
-PARCTimer *parcTimer_Acquire(const PARCTimer *instance);
-
-#ifdef PARCLibrary_DISABLE_VALIDATION
-#  define parcTimer_OptionalAssertValid(_instance_)
-#else
-#  define parcTimer_OptionalAssertValid(_instance_) parcTimer_AssertValid(_instance_)
-#endif
-
-/**
- * Assert that the given `PARCTimer` instance is valid.
- *
- * @param [in] instance A pointer to a valid PARCTimer instance.
- *
- * Example:
- * @code
- * {
- *     PARCTimer *a = parcTimer_Create();
- *
- *     parcTimer_AssertValid(a);
- *
- *     printf("Instance is valid.\n");
- *
- *     parcTimer_Release(&b);
- * }
- * @endcode
- */
-void parcTimer_AssertValid(const PARCTimer *instance);
-
-/**
- * Create an instance of PARCTimer
- *
- * <#Paragraphs Of Explanation#>
- *
- * @return non-NULL A pointer to a valid PARCTimer instance.
- * @return NULL An error occurred.
- *
- * Example:
- * @code
- * {
- *     PARCTimer *a = parcTimer_Create();
- *
- *     parcTimer_Release(&a);
- * }
- * @endcode
- */
-PARCTimer *parcTimer_Create(void);
-
-/**
- * Compares @p instance with @p other for order.
- *
- * Returns a negative integer, zero, or a positive integer as @p instance
- * is less than, equal to, or greater than @p other.
- *
- * @param [in] instance A pointer to a valid PARCTimer instance.
- * @param [in] other A pointer to a valid PARCTimer instance.
- *
- * @return <0 Instance is less than @p other.
- * @return 0 Instance a and instance b compare the same.
- * @return >0 Instance a is greater than instance b.
- *
- * Example:
- * @code
- * {
- *     PARCTimer *a = parcTimer_Create();
- *     PARCTimer *b = parcTimer_Create();
- *
- *     if (parcTimer_Compare(a, b) == 0) {
- *         printf("Instances are equal.\n");
- *     }
- *
- *     parcTimer_Release(&a);
- *     parcTimer_Release(&b);
- * }
- * @endcode
- *
- * @see parcTimer_Equals
- */
-int parcTimer_Compare(const PARCTimer *instance, const PARCTimer *other);
-
-/**
- * Create an independent copy the given `PARCBuffer`
- *
- * A new buffer is created as a complete copy of the original.
- *
- * @param [in] original A pointer to a valid PARCTimer instance.
- *
- * @return NULL Memory could not be allocated.
- * @return non-NULL A pointer to a new `PARCTimer` instance.
- *
- * Example:
- * @code
- * {
- *     PARCTimer *a = parcTimer_Create();
- *
- *     PARCTimer *copy = parcTimer_Copy(&b);
- *
- *     parcTimer_Release(&b);
- *     parcTimer_Release(&copy);
- * }
- * @endcode
- */
-PARCTimer *parcTimer_Copy(const PARCTimer *original);
-
-/**
- * Print a human readable representation of the given `PARCTimer`.
- *
- * @param [in] instance A pointer to a valid PARCTimer instance.
- * @param [in] indentation The indentation level to use for printing.
- *
- * Example:
- * @code
- * {
- *     PARCTimer *a = parcTimer_Create();
- *
- *     parcTimer_Display(a, 0);
- *
- *     parcTimer_Release(&a);
- * }
- * @endcode
- */
-void parcTimer_Display(const PARCTimer *instance, int indentation);
-
-/**
- * Determine if two `PARCTimer` instances are equal.
- *
- * The following equivalence relations on non-null `PARCTimer` instances are maintained: *
- *   * It is reflexive: for any non-null reference value x, `parcTimer_Equals(x, x)` must return true.
- *
- *   * It is symmetric: for any non-null reference values x and y, `parcTimer_Equals(x, y)` must return true if and only if
- *        `parcTimer_Equals(y x)` returns true.
- *
- *   * It is transitive: for any non-null reference values x, y, and z, if
- *        `parcTimer_Equals(x, y)` returns true and
- *        `parcTimer_Equals(y, z)` returns true,
- *        then `parcTimer_Equals(x, z)` must return true.
- *
- *   * It is consistent: for any non-null reference values x and y, multiple invocations of `parcTimer_Equals(x, y)`
- *         consistently return true or consistently return false.
- *
- *   * For any non-null reference value x, `parcTimer_Equals(x, NULL)` must return false.
- *
- * @param [in] x A pointer to a valid PARCTimer instance.
- * @param [in] y A pointer to a valid PARCTimer instance.
- *
- * @return true The instances x and y are equal.
- *
- * Example:
- * @code
- * {
- *     PARCTimer *a = parcTimer_Create();
- *     PARCTimer *b = parcTimer_Create();
- *
- *     if (parcTimer_Equals(a, b)) {
- *         printf("Instances are equal.\n");
- *     }
- *
- *     parcTimer_Release(&a);
- *     parcTimer_Release(&b);
- * }
- * @endcode
- * @see parcTimer_HashCode
- */
-bool parcTimer_Equals(const PARCTimer *x, const PARCTimer *y);
-
-/**
- * Returns a hash code value for the given instance.
- *
- * The general contract of `HashCode` is:
- *
- * Whenever it is invoked on the same instance more than once during an execution of an application,
- * the `HashCode` function must consistently return the same value,
- * provided no information used in a corresponding comparisons on the instance is modified.
- *
- * This value need not remain consistent from one execution of an application to another execution of the same application.
- * If two instances are equal according to the {@link parcTimer_Equals} method,
- * then calling the {@link parcTimer_HashCode} method on each of the two instances must produce the same integer result.
- *
- * It is not required that if two instances are unequal according to the
- * {@link parcTimer_Equals} function,
- * then calling the `parcTimer_HashCode`
- * method on each of the two objects must produce distinct integer results.
- *
- * @param [in] instance A pointer to a valid PARCTimer instance.
- *
- * @return The hashcode for the given instance.
- *
- * Example:
- * @code
- * {
- *     PARCTimer *a = parcTimer_Create();
- *
- *     PARCHashCode hashValue = parcTimer_HashCode(buffer);
- *     parcTimer_Release(&a);
- * }
- * @endcode
- */
-PARCHashCode parcTimer_HashCode(const PARCTimer *instance);
-
-/**
- * Determine if an instance of `PARCTimer` is valid.
- *
- * Valid means the internal state of the type is consistent with its required current or future behaviour.
- * This may include the validation of internal instances of types.
- *
- * @param [in] instance A pointer to a valid PARCTimer instance.
- *
- * @return true The instance is valid.
- * @return false The instance is not valid.
- *
- * Example:
- * @code
- * {
- *     PARCTimer *a = parcTimer_Create();
- *
- *     if (parcTimer_IsValid(a)) {
- *         printf("Instance is valid.\n");
- *     }
- *
- *     parcTimer_Release(&a);
- * }
- * @endcode
- *
- */
-bool parcTimer_IsValid(const PARCTimer *instance);
-
-/**
- * Release a previously acquired reference to the given `PARCTimer` instance,
- * decrementing the reference count for the instance.
- *
- * The pointer to the instance is set to NULL as a side-effect of this function.
- *
- * If the invocation causes the last reference to the instance to be released,
- * the instance is deallocated and the instance's implementation will perform
- * additional cleanup and release other privately held references.
- *
- * @param [in,out] instancePtr A pointer to a pointer to the instance to release.
- *
- * Example:
- * @code
- * {
- *     PARCTimer *a = parcTimer_Create();
- *
- *     parcTimer_Release(&a);
- * }
- * @endcode
- */
-void parcTimer_Release(PARCTimer **instancePtr);
-
-/**
- * Create a `PARCJSON` instance (representation) of the given object.
- *
- * @param [in] instance A pointer to a valid PARCTimer instance.
- *
- * @return NULL Memory could not be allocated to contain the `PARCJSON` instance.
- * @return non-NULL An allocated C string that must be deallocated via parcMemory_Deallocate().
- *
- * Example:
- * @code
- * {
- *     PARCTimer *a = parcTimer_Create();
- *
- *     PARCJSON *json = parcTimer_ToJSON(a);
- *
- *     printf("JSON representation: %s\n", parcJSON_ToString(json));
- *     parcJSON_Release(&json);
- *
- *     parcTimer_Release(&a);
- * }
- * @endcode
- */
-PARCJSON *parcTimer_ToJSON(const PARCTimer *instance);
-
-/**
- * Produce a null-terminated string representation of the specified `PARCTimer`.
- *
- * The result must be freed by the caller via {@link parcMemory_Deallocate}.
- *
- * @param [in] instance A pointer to a valid PARCTimer instance.
- *
- * @return NULL Cannot allocate memory.
- * @return non-NULL A pointer to an allocated, null-terminated C string that must be deallocated via {@link parcMemory_Deallocate}.
- *
- * Example:
- * @code
- * {
- *     PARCTimer *a = parcTimer_Create();
- *
- *     char *string = parcTimer_ToString(a);
- *
- *     parcTimer_Release(&a);
- *
- *     parcMemory_Deallocate(&string);
- * }
- * @endcode
- *
- * @see parcTimer_Display
- */
-char *parcTimer_ToString(const PARCTimer *timer);
-
-/**
- * Terminates this timer, discarding any currently scheduled tasks.
- *
- * Does not interfere with a currently executing task (if it exists).
- * Once a timer has been terminated, its execution thread terminates gracefully,
- * and no more tasks may be scheduled on it.
- *
- * Note that calling this method from within the run method of a timer task that was invoked
- * by this timer absolutely guarantees that the ongoing task execution is the last task execution
- * that will ever be performed by this timer.
- *
- * This method may be called repeatedly; the second and subsequent calls have no effect.
- */
-void parcTimer_Cancel(PARCTimer *timer);
-
-/**
- * Removes all cancelled tasks from this timer's task queue.
- *
- * Calling this method has no effect on the behavior of the timer,
- * but eliminates the references to the cancelled tasks from the queue.
- * If there are no external references to these tasks, they become eligible for garbage collection.
- *
- * Most programs will have no need to call this method.
- * It is designed for use by the rare application that cancels a large number of tasks.
- * Calling this method trades time for space: the runtime of the method may be proportional to
- * n + c log n, where n is the number of tasks in the queue and c is the number of cancelled tasks.
- *
- * It is permissible to call this method from within a task scheduled on this timer.
- *
- * @returns the number of tasks removed from the queue.
- */
-int parcTimer_Purge(PARCTimer *timer);
-
-/**
- * Schedules the specified task for execution at the specified time.
- */
-void parcTimer_ScheduleAtTime(PARCTimer *timer, PARCFutureTask *task, time_t absoluteTime);
-
-/**
- * Schedules the specified task for repeated fixed-delay execution, beginning at the specified time.
- */
-void parcTimer_ScheduleAtTimeAndRepeat(PARCTimer *timer, PARCFutureTask *task, time_t firstTime, long period);
-
-/**
- * Schedules the specified task for execution after the specified delay.
- */
-void parcTimer_ScheduleAfterDelay(PARCTimer *timer, PARCFutureTask *task, long delay);
-
-/**
- * Schedules the specified task for repeated fixed-delay execution, beginning after the specified delay.
- */
-void parcTimer_ScheduleAfterDelayAndRepeat(PARCTimer *timer, PARCFutureTask *task, long delay, long period);
-#endif
diff --git a/libparc/parc/concurrent/test/.gitignore b/libparc/parc/concurrent/test/.gitignore
deleted file mode 100644
index 2c9fe4f5..00000000
--- a/libparc/parc/concurrent/test/.gitignore
+++ /dev/null
@@ -1,10 +0,0 @@
-test_parc_Notifier
-test_parc_RingBuffer_1x1
-test_parc_RingBuffer_NxM
-test_parc_AtomicUint64
-test_parc_Barrier
-test_parc_AtomicUint16
-test_parc_AtomicUint32
-test_parc_AtomicUint8
-test_parc_Synchronizer
-test_parc_Lock
diff --git a/libparc/parc/concurrent/test/CMakeLists.txt b/libparc/parc/concurrent/test/CMakeLists.txt
deleted file mode 100644
index 092d0202..00000000
--- a/libparc/parc/concurrent/test/CMakeLists.txt
+++ /dev/null
@@ -1,25 +0,0 @@
-set(TestsExpectedToPass
-	test_parc_AtomicUint16
-	test_parc_AtomicUint32
-	test_parc_AtomicUint64
-	test_parc_AtomicUint8
-	test_parc_FutureTask
-	test_parc_Lock
-	test_parc_Notifier
-	test_parc_RingBuffer_1x1
-	test_parc_RingBuffer_NxM
-	test_parc_ScheduledTask
-	test_parc_ScheduledThreadPool
-	test_parc_Synchronizer
-	test_parc_Thread
-	test_parc_ThreadPool
-	test_parc_Timer
-  )
-
-# Enable gcov output for the tests
-add_definitions(--coverage)
-set(CMAKE_EXE_LINKER_FLAGS ${CMAKE_EXE_LINKER_FLAGS} " --coverage")
-
-foreach(test ${TestsExpectedToPass})
-   AddTest(${test})
-endforeach()
diff --git a/libparc/parc/concurrent/test/test_parc_AtomicUint16.c b/libparc/parc/concurrent/test/test_parc_AtomicUint16.c
deleted file mode 100644
index ed97cc95..00000000
--- a/libparc/parc/concurrent/test/test_parc_AtomicUint16.c
+++ /dev/null
@@ -1,361 +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_AtomicUint16.c"
-
-#include <LongBow/testing.h>
-#include <LongBow/debugging.h>
-
-#include <inttypes.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/testing/parc_MemoryTesting.h>
-#include <parc/testing/parc_ObjectTesting.h>
-
-LONGBOW_TEST_RUNNER(parc_AtomicUint16)
-{
-    // 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(Macros);
-    LONGBOW_RUN_TEST_FIXTURE(Performance);
-}
-
-// The Test Runner calls this function once before any Test Fixtures are run.
-LONGBOW_TEST_RUNNER_SETUP(parc_AtomicUint16)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-// The Test Runner calls this function once after all the Test Fixtures are run.
-LONGBOW_TEST_RUNNER_TEARDOWN(parc_AtomicUint16)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE(CreateAcquireRelease)
-{
-    LONGBOW_RUN_TEST_CASE(CreateAcquireRelease, CreateRelease);
-}
-
-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)
-{
-    PARCAtomicUint16 *instance = parcAtomicUint16_Create(7);
-    assertNotNull(instance, "Expeced non-null result from parcAtomicUint16_Create();");
-
-    parcObjectTesting_AssertAcquireReleaseContract(parcAtomicUint16_Acquire, instance);
-
-    parcAtomicUint16_Release(&instance);
-    assertNull(instance, "Expected null result from parcAtomicUint16_Release();");
-}
-
-LONGBOW_TEST_FIXTURE(Global)
-{
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint16_Compare);
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint16_Copy);
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint16_Equals);
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint16_HashCode);
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint16_IsValid);
-
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint16_SubtractImpl);
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint16_AddImpl);
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint16_CompareAndSwapImpl);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Global)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Global)
-{
-    if (!parcMemoryTesting_ExpectedOutstanding(0, "%s leaked memory.", longBowTestCase_GetFullName(testCase))) {
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint16_Compare)
-{
-    PARCAtomicUint16 *instance = parcAtomicUint16_Create(7);
-    PARCAtomicUint16 *high = parcAtomicUint16_Create(8);
-    PARCAtomicUint16 *low = parcAtomicUint16_Create(6);
-    PARCAtomicUint16 *equal = parcAtomicUint16_Create(7);
-
-    int actual = parcAtomicUint16_Compare(instance, high);
-    assertTrue(actual < 0, "Expected < 0");
-    actual = parcAtomicUint16_Compare(instance, low);
-    assertTrue(actual > 0, "Expected > 0");
-    actual = parcAtomicUint16_Compare(instance, equal);
-    assertTrue(actual == 0, "Expected == 0");
-
-    parcAtomicUint16_Release(&instance);
-    parcAtomicUint16_Release(&high);
-    parcAtomicUint16_Release(&low);
-    parcAtomicUint16_Release(&equal);
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint16_Copy)
-{
-    PARCAtomicUint16 *instance = parcAtomicUint16_Create(7);
-    PARCAtomicUint16 *copy = parcAtomicUint16_Copy(instance);
-
-    assertTrue(parcAtomicUint16_Equals(instance, copy), "Expected the copy to be equal to the original");
-
-    parcAtomicUint16_Release(&instance);
-    parcAtomicUint16_Release(&copy);
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint16_Equals)
-{
-    PARCAtomicUint16 *x = parcAtomicUint16_Create(7);
-    PARCAtomicUint16 *y = parcAtomicUint16_Create(7);
-    PARCAtomicUint16 *z = parcAtomicUint16_Create(7);
-    PARCAtomicUint16 *u1 = parcAtomicUint16_Create(6);
-
-    parcObjectTesting_AssertEquals(x, y, z, u1, NULL);
-
-    parcAtomicUint16_Release(&x);
-    parcAtomicUint16_Release(&y);
-    parcAtomicUint16_Release(&z);
-    parcAtomicUint16_Release(&u1);
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint16_HashCode)
-{
-    PARCAtomicUint16 *x = parcAtomicUint16_Create(7);
-    parcAtomicUint16_HashCode(x);
-    parcAtomicUint16_Release(&x);
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint16_IsValid)
-{
-    PARCAtomicUint16 *instance = parcAtomicUint16_Create(7);
-    assertTrue(parcAtomicUint16_IsValid(instance), "Expected parcAtomicUint16_Create to result in a valid instance.");
-
-    parcAtomicUint16_Release(&instance);
-    assertFalse(parcAtomicUint16_IsValid(instance), "Expected parcAtomicUint16_Release to result in an invalid instance.");
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint16_SubtractImpl)
-{
-    PARCAtomicUint16 *instance = parcAtomicUint16_Create(7);
-
-    parcAtomicUint16_SubtractImpl(instance, 1);
-
-    uint16_t actual = parcAtomicUint16_GetValue(instance);
-
-    assertTrue(actual == 6, "Expected 6, actual %" PRIu16, actual);
-    parcAtomicUint16_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint16_AddImpl)
-{
-    PARCAtomicUint16 *instance = parcAtomicUint16_Create(7);
-
-    parcAtomicUint16_AddImpl(instance, 1);
-
-    uint16_t actual = parcAtomicUint16_GetValue(instance);
-
-    assertTrue(actual == 8, "Expected 8, actual %" PRIu16, actual);
-    parcAtomicUint16_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint16_CompareAndSwapImpl)
-{
-    PARCAtomicUint16 *instance = parcAtomicUint16_Create(7);
-
-    bool actual = parcAtomicUint16_CompareAndSwapImpl(instance, 7, 8);
-
-    assertTrue(actual, "Expected parcAtomicUint16_CompareAndSwapImpl to return true");
-    parcAtomicUint16_Release(&instance);
-}
-
-LONGBOW_TEST_FIXTURE(Macros)
-{
-    LONGBOW_RUN_TEST_CASE(Macros, parcAtomicUint16_Subtract);
-    LONGBOW_RUN_TEST_CASE(Macros, parcAtomicUint16_Add);
-    LONGBOW_RUN_TEST_CASE(Macros, parcAtomicUint16_CompareAndSwap);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Macros)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Macros)
-{
-    if (!parcMemoryTesting_ExpectedOutstanding(0, "%s leaked memory.", longBowTestCase_GetFullName(testCase))) {
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_CASE(Macros, parcAtomicUint16_Subtract)
-{
-    PARCAtomicUint16 *instance = parcAtomicUint16_Create(7);
-
-    parcAtomicUint16_Subtract(instance, 1);
-
-    uint16_t actual = parcAtomicUint16_GetValue(instance);
-
-    assertTrue(actual == 6, "Expected 6, actual %" PRIu16, actual);
-    parcAtomicUint16_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Macros, parcAtomicUint16_Add)
-{
-    PARCAtomicUint16 *instance = parcAtomicUint16_Create(7);
-
-    parcAtomicUint16_Add(instance, 1);
-
-    uint16_t actual = parcAtomicUint16_GetValue(instance);
-
-    assertTrue(actual == 8, "Expected 8, actual %" PRIu16, actual);
-    parcAtomicUint16_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Macros, parcAtomicUint16_CompareAndSwap)
-{
-    PARCAtomicUint16 *instance = parcAtomicUint16_Create(7);
-
-    bool actual = parcAtomicUint16_CompareAndSwap(instance, 7, 8);
-
-    assertTrue(actual, "Expected parcAtomicUint16_CompareAndSwap to return true");
-    parcAtomicUint16_Release(&instance);
-}
-
-
-LONGBOW_TEST_FIXTURE_OPTIONS(Performance, .enabled = false)
-{
-    LONGBOW_RUN_TEST_CASE(Performance, parcAtomicUint16_Subtract_MACRO);
-    LONGBOW_RUN_TEST_CASE(Performance, parcAtomicUint16_Add_MACRO);
-    LONGBOW_RUN_TEST_CASE(Performance, parcAtomicUint16_CompareAndSwap_MACRO);
-    LONGBOW_RUN_TEST_CASE(Performance, parcAtomicUint16_SubtractImpl);
-    LONGBOW_RUN_TEST_CASE(Performance, parcAtomicUint16_AddImpl);
-    LONGBOW_RUN_TEST_CASE(Performance, parcAtomicUint16_CompareAndSwapImpl);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Performance)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Performance)
-{
-    if (!parcMemoryTesting_ExpectedOutstanding(0, "%s leaked memory.", longBowTestCase_GetFullName(testCase))) {
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_CASE(Performance, parcAtomicUint16_Subtract_MACRO)
-{
-    PARCAtomicUint16 *instance = parcAtomicUint16_Create(65535);
-
-    while (parcAtomicUint16_Subtract(instance, 1) > 0) {
-        ;
-    }
-
-    parcAtomicUint16_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Performance, parcAtomicUint16_Add_MACRO)
-{
-    PARCAtomicUint16 *instance = parcAtomicUint16_Create(1);
-
-    while (parcAtomicUint16_Add(instance, 1) < 65535) {
-        ;
-    }
-
-    parcAtomicUint16_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Performance, parcAtomicUint16_CompareAndSwap_MACRO)
-{
-    PARCAtomicUint16 *instance = parcAtomicUint16_Create(0);
-
-    for (uint16_t i = 0; i < 65535; i++) {
-        bool actual = parcAtomicUint16_CompareAndSwap(instance, i, i + 1);
-        assertTrue(actual, "Expected parcAtomicUint16_CompareAndSwap to return true");
-    }
-
-    parcAtomicUint16_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Performance, parcAtomicUint16_SubtractImpl)
-{
-    PARCAtomicUint16 *instance = parcAtomicUint16_Create(65535);
-
-    while (parcAtomicUint16_SubtractImpl(instance, 1) > 0) {
-        ;
-    }
-
-    parcAtomicUint16_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Performance, parcAtomicUint16_AddImpl)
-{
-    PARCAtomicUint16 *instance = parcAtomicUint16_Create(1);
-
-    while (parcAtomicUint16_AddImpl(instance, 1) < 65535) {
-        ;
-    }
-
-    parcAtomicUint16_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Performance, parcAtomicUint16_CompareAndSwapImpl)
-{
-    PARCAtomicUint16 *instance = parcAtomicUint16_Create(0);
-
-    for (uint16_t i = 0; i < 65535; i++) {
-        bool actual = parcAtomicUint16_CompareAndSwapImpl(instance, i, i + 1);
-        assertTrue(actual, "Expected parcAtomicUint16_CompareAndSwapImpl to return true");
-    }
-
-    parcAtomicUint16_Release(&instance);
-}
-
-int
-main(int argc, char *argv[argc])
-{
-    LongBowRunner *testRunner = LONGBOW_TEST_RUNNER_CREATE(parc_AtomicUint16);
-    int exitStatus = longBowMain(argc, argv, testRunner, NULL);
-    longBowTestRunner_Destroy(&testRunner);
-    exit(exitStatus);
-}
diff --git a/libparc/parc/concurrent/test/test_parc_AtomicUint32.c b/libparc/parc/concurrent/test/test_parc_AtomicUint32.c
deleted file mode 100644
index 1649cf1c..00000000
--- a/libparc/parc/concurrent/test/test_parc_AtomicUint32.c
+++ /dev/null
@@ -1,361 +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_AtomicUint64.c"
-
-#include <LongBow/testing.h>
-#include <LongBow/debugging.h>
-
-#include <inttypes.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/testing/parc_MemoryTesting.h>
-#include <parc/testing/parc_ObjectTesting.h>
-
-LONGBOW_TEST_RUNNER(parc_AtomicUint64)
-{
-    // 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(Macros);
-    LONGBOW_RUN_TEST_FIXTURE(Performance);
-}
-
-// The Test Runner calls this function once before any Test Fixtures are run.
-LONGBOW_TEST_RUNNER_SETUP(parc_AtomicUint64)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-// The Test Runner calls this function once after all the Test Fixtures are run.
-LONGBOW_TEST_RUNNER_TEARDOWN(parc_AtomicUint64)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE(CreateAcquireRelease)
-{
-    LONGBOW_RUN_TEST_CASE(CreateAcquireRelease, CreateRelease);
-}
-
-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)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(7);
-    assertNotNull(instance, "Expeced non-null result from parcAtomicUint64_Create();");
-
-    parcObjectTesting_AssertAcquireReleaseContract(parcAtomicUint64_Acquire, instance);
-
-    parcAtomicUint64_Release(&instance);
-    assertNull(instance, "Expected null result from parcAtomicUint64_Release();");
-}
-
-LONGBOW_TEST_FIXTURE(Global)
-{
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint64_Compare);
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint64_Copy);
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint64_Equals);
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint64_HashCode);
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint64_IsValid);
-
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint64_SubtractImpl);
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint64_AddImpl);
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint64_CompareAndSwapImpl);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Global)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Global)
-{
-    if (!parcMemoryTesting_ExpectedOutstanding(0, "%s leaked memory.", longBowTestCase_GetFullName(testCase))) {
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint64_Compare)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(7);
-    PARCAtomicUint64 *high = parcAtomicUint64_Create(8);
-    PARCAtomicUint64 *low = parcAtomicUint64_Create(6);
-    PARCAtomicUint64 *equal = parcAtomicUint64_Create(7);
-
-    int actual = parcAtomicUint64_Compare(instance, high);
-    assertTrue(actual < 0, "Expected < 0");
-    actual = parcAtomicUint64_Compare(instance, low);
-    assertTrue(actual > 0, "Expected > 0");
-    actual = parcAtomicUint64_Compare(instance, equal);
-    assertTrue(actual == 0, "Expected == 0");
-
-    parcAtomicUint64_Release(&instance);
-    parcAtomicUint64_Release(&high);
-    parcAtomicUint64_Release(&low);
-    parcAtomicUint64_Release(&equal);
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint64_Copy)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(7);
-    PARCAtomicUint64 *copy = parcAtomicUint64_Copy(instance);
-
-    assertTrue(parcAtomicUint64_Equals(instance, copy), "Expected the copy to be equal to the original");
-
-    parcAtomicUint64_Release(&instance);
-    parcAtomicUint64_Release(&copy);
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint64_Equals)
-{
-    PARCAtomicUint64 *x = parcAtomicUint64_Create(7);
-    PARCAtomicUint64 *y = parcAtomicUint64_Create(7);
-    PARCAtomicUint64 *z = parcAtomicUint64_Create(7);
-    PARCAtomicUint64 *u1 = parcAtomicUint64_Create(6);
-
-    parcObjectTesting_AssertEquals(x, y, z, u1, NULL);
-
-    parcAtomicUint64_Release(&x);
-    parcAtomicUint64_Release(&y);
-    parcAtomicUint64_Release(&z);
-    parcAtomicUint64_Release(&u1);
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint64_HashCode)
-{
-    PARCAtomicUint64 *x = parcAtomicUint64_Create(7);
-    parcAtomicUint64_HashCode(x);
-    parcAtomicUint64_Release(&x);
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint64_IsValid)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(7);
-    assertTrue(parcAtomicUint64_IsValid(instance), "Expected parcAtomicUint64_Create to result in a valid instance.");
-
-    parcAtomicUint64_Release(&instance);
-    assertFalse(parcAtomicUint64_IsValid(instance), "Expected parcAtomicUint64_Release to result in an invalid instance.");
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint64_SubtractImpl)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(7);
-
-    parcAtomicUint64_SubtractImpl(instance, 1);
-
-    uint64_t actual = parcAtomicUint64_GetValue(instance);
-
-    assertTrue(actual == 6, "Expected 6, actual %" PRIu64, actual);
-    parcAtomicUint64_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint64_AddImpl)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(7);
-
-    parcAtomicUint64_AddImpl(instance, 1);
-
-    uint64_t actual = parcAtomicUint64_GetValue(instance);
-
-    assertTrue(actual == 8, "Expected 8, actual %" PRIu64, actual);
-    parcAtomicUint64_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint64_CompareAndSwapImpl)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(7);
-
-    bool actual = parcAtomicUint64_CompareAndSwapImpl(instance, 7, 8);
-
-    assertTrue(actual, "Expected parcAtomicUint64_CompareAndSwapImpl to return true");
-    parcAtomicUint64_Release(&instance);
-}
-
-LONGBOW_TEST_FIXTURE(Macros)
-{
-    LONGBOW_RUN_TEST_CASE(Macros, parcAtomicUint64_Subtract);
-    LONGBOW_RUN_TEST_CASE(Macros, parcAtomicUint64_Add);
-    LONGBOW_RUN_TEST_CASE(Macros, parcAtomicUint64_CompareAndSwap);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Macros)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Macros)
-{
-    if (!parcMemoryTesting_ExpectedOutstanding(0, "%s leaked memory.", longBowTestCase_GetFullName(testCase))) {
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_CASE(Macros, parcAtomicUint64_Subtract)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(7);
-
-    parcAtomicUint64_Subtract(instance, 1);
-
-    uint64_t actual = parcAtomicUint64_GetValue(instance);
-
-    assertTrue(actual == 6, "Expected 6, actual %" PRIu64, actual);
-    parcAtomicUint64_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Macros, parcAtomicUint64_Add)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(7);
-
-    parcAtomicUint64_Add(instance, 1);
-
-    uint64_t actual = parcAtomicUint64_GetValue(instance);
-
-    assertTrue(actual == 8, "Expected 8, actual %" PRIu64, actual);
-    parcAtomicUint64_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Macros, parcAtomicUint64_CompareAndSwap)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(7);
-
-    bool actual = parcAtomicUint64_CompareAndSwap(instance, 7, 8);
-
-    assertTrue(actual, "Expected parcAtomicUint64_CompareAndSwap to return true");
-    parcAtomicUint64_Release(&instance);
-}
-
-
-LONGBOW_TEST_FIXTURE_OPTIONS(Performance, .enabled = false)
-{
-    LONGBOW_RUN_TEST_CASE(Performance, parcAtomicUint64_Subtract_MACRO);
-    LONGBOW_RUN_TEST_CASE(Performance, parcAtomicUint64_Add_MACRO);
-    LONGBOW_RUN_TEST_CASE(Performance, parcAtomicUint64_CompareAndSwap_MACRO);
-    LONGBOW_RUN_TEST_CASE(Performance, parcAtomicUint64_SubtractImpl);
-    LONGBOW_RUN_TEST_CASE(Performance, parcAtomicUint64_AddImpl);
-    LONGBOW_RUN_TEST_CASE(Performance, parcAtomicUint64_CompareAndSwapImpl);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Performance)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Performance)
-{
-    if (!parcMemoryTesting_ExpectedOutstanding(0, "%s leaked memory.", longBowTestCase_GetFullName(testCase))) {
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_CASE(Performance, parcAtomicUint64_Subtract_MACRO)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(100000000);
-
-    while (parcAtomicUint64_Subtract(instance, 1) > 0) {
-        ;
-    }
-
-    parcAtomicUint64_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Performance, parcAtomicUint64_Add_MACRO)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(1);
-
-    while (parcAtomicUint64_Add(instance, 1) < 100000000) {
-        ;
-    }
-
-    parcAtomicUint64_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Performance, parcAtomicUint64_CompareAndSwap_MACRO)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(0);
-
-    for (uint64_t i = 0; i < 100000000; i++) {
-        bool actual = parcAtomicUint64_CompareAndSwap(instance, i, i + 1);
-        assertTrue(actual, "Expected parcAtomicUint64_CompareAndSwap to return true");
-    }
-
-    parcAtomicUint64_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Performance, parcAtomicUint64_SubtractImpl)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(100000000);
-
-    while (parcAtomicUint64_SubtractImpl(instance, 1) > 0) {
-        ;
-    }
-
-    parcAtomicUint64_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Performance, parcAtomicUint64_AddImpl)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(1);
-
-    while (parcAtomicUint64_AddImpl(instance, 1) < 100000000) {
-        ;
-    }
-
-    parcAtomicUint64_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Performance, parcAtomicUint64_CompareAndSwapImpl)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(0);
-
-    for (uint64_t i = 0; i < 100000000; i++) {
-        bool actual = parcAtomicUint64_CompareAndSwapImpl(instance, i, i + 1);
-        assertTrue(actual, "Expected parcAtomicUint64_CompareAndSwapImpl to return true");
-    }
-
-    parcAtomicUint64_Release(&instance);
-}
-
-int
-main(int argc, char *argv[argc])
-{
-    LongBowRunner *testRunner = LONGBOW_TEST_RUNNER_CREATE(parc_AtomicUint64);
-    int exitStatus = longBowMain(argc, argv, testRunner, NULL);
-    longBowTestRunner_Destroy(&testRunner);
-    exit(exitStatus);
-}
diff --git a/libparc/parc/concurrent/test/test_parc_AtomicUint64.c b/libparc/parc/concurrent/test/test_parc_AtomicUint64.c
deleted file mode 100644
index 1649cf1c..00000000
--- a/libparc/parc/concurrent/test/test_parc_AtomicUint64.c
+++ /dev/null
@@ -1,361 +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_AtomicUint64.c"
-
-#include <LongBow/testing.h>
-#include <LongBow/debugging.h>
-
-#include <inttypes.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/testing/parc_MemoryTesting.h>
-#include <parc/testing/parc_ObjectTesting.h>
-
-LONGBOW_TEST_RUNNER(parc_AtomicUint64)
-{
-    // 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(Macros);
-    LONGBOW_RUN_TEST_FIXTURE(Performance);
-}
-
-// The Test Runner calls this function once before any Test Fixtures are run.
-LONGBOW_TEST_RUNNER_SETUP(parc_AtomicUint64)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-// The Test Runner calls this function once after all the Test Fixtures are run.
-LONGBOW_TEST_RUNNER_TEARDOWN(parc_AtomicUint64)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE(CreateAcquireRelease)
-{
-    LONGBOW_RUN_TEST_CASE(CreateAcquireRelease, CreateRelease);
-}
-
-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)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(7);
-    assertNotNull(instance, "Expeced non-null result from parcAtomicUint64_Create();");
-
-    parcObjectTesting_AssertAcquireReleaseContract(parcAtomicUint64_Acquire, instance);
-
-    parcAtomicUint64_Release(&instance);
-    assertNull(instance, "Expected null result from parcAtomicUint64_Release();");
-}
-
-LONGBOW_TEST_FIXTURE(Global)
-{
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint64_Compare);
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint64_Copy);
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint64_Equals);
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint64_HashCode);
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint64_IsValid);
-
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint64_SubtractImpl);
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint64_AddImpl);
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint64_CompareAndSwapImpl);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Global)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Global)
-{
-    if (!parcMemoryTesting_ExpectedOutstanding(0, "%s leaked memory.", longBowTestCase_GetFullName(testCase))) {
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint64_Compare)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(7);
-    PARCAtomicUint64 *high = parcAtomicUint64_Create(8);
-    PARCAtomicUint64 *low = parcAtomicUint64_Create(6);
-    PARCAtomicUint64 *equal = parcAtomicUint64_Create(7);
-
-    int actual = parcAtomicUint64_Compare(instance, high);
-    assertTrue(actual < 0, "Expected < 0");
-    actual = parcAtomicUint64_Compare(instance, low);
-    assertTrue(actual > 0, "Expected > 0");
-    actual = parcAtomicUint64_Compare(instance, equal);
-    assertTrue(actual == 0, "Expected == 0");
-
-    parcAtomicUint64_Release(&instance);
-    parcAtomicUint64_Release(&high);
-    parcAtomicUint64_Release(&low);
-    parcAtomicUint64_Release(&equal);
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint64_Copy)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(7);
-    PARCAtomicUint64 *copy = parcAtomicUint64_Copy(instance);
-
-    assertTrue(parcAtomicUint64_Equals(instance, copy), "Expected the copy to be equal to the original");
-
-    parcAtomicUint64_Release(&instance);
-    parcAtomicUint64_Release(&copy);
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint64_Equals)
-{
-    PARCAtomicUint64 *x = parcAtomicUint64_Create(7);
-    PARCAtomicUint64 *y = parcAtomicUint64_Create(7);
-    PARCAtomicUint64 *z = parcAtomicUint64_Create(7);
-    PARCAtomicUint64 *u1 = parcAtomicUint64_Create(6);
-
-    parcObjectTesting_AssertEquals(x, y, z, u1, NULL);
-
-    parcAtomicUint64_Release(&x);
-    parcAtomicUint64_Release(&y);
-    parcAtomicUint64_Release(&z);
-    parcAtomicUint64_Release(&u1);
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint64_HashCode)
-{
-    PARCAtomicUint64 *x = parcAtomicUint64_Create(7);
-    parcAtomicUint64_HashCode(x);
-    parcAtomicUint64_Release(&x);
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint64_IsValid)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(7);
-    assertTrue(parcAtomicUint64_IsValid(instance), "Expected parcAtomicUint64_Create to result in a valid instance.");
-
-    parcAtomicUint64_Release(&instance);
-    assertFalse(parcAtomicUint64_IsValid(instance), "Expected parcAtomicUint64_Release to result in an invalid instance.");
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint64_SubtractImpl)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(7);
-
-    parcAtomicUint64_SubtractImpl(instance, 1);
-
-    uint64_t actual = parcAtomicUint64_GetValue(instance);
-
-    assertTrue(actual == 6, "Expected 6, actual %" PRIu64, actual);
-    parcAtomicUint64_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint64_AddImpl)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(7);
-
-    parcAtomicUint64_AddImpl(instance, 1);
-
-    uint64_t actual = parcAtomicUint64_GetValue(instance);
-
-    assertTrue(actual == 8, "Expected 8, actual %" PRIu64, actual);
-    parcAtomicUint64_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint64_CompareAndSwapImpl)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(7);
-
-    bool actual = parcAtomicUint64_CompareAndSwapImpl(instance, 7, 8);
-
-    assertTrue(actual, "Expected parcAtomicUint64_CompareAndSwapImpl to return true");
-    parcAtomicUint64_Release(&instance);
-}
-
-LONGBOW_TEST_FIXTURE(Macros)
-{
-    LONGBOW_RUN_TEST_CASE(Macros, parcAtomicUint64_Subtract);
-    LONGBOW_RUN_TEST_CASE(Macros, parcAtomicUint64_Add);
-    LONGBOW_RUN_TEST_CASE(Macros, parcAtomicUint64_CompareAndSwap);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Macros)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Macros)
-{
-    if (!parcMemoryTesting_ExpectedOutstanding(0, "%s leaked memory.", longBowTestCase_GetFullName(testCase))) {
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_CASE(Macros, parcAtomicUint64_Subtract)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(7);
-
-    parcAtomicUint64_Subtract(instance, 1);
-
-    uint64_t actual = parcAtomicUint64_GetValue(instance);
-
-    assertTrue(actual == 6, "Expected 6, actual %" PRIu64, actual);
-    parcAtomicUint64_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Macros, parcAtomicUint64_Add)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(7);
-
-    parcAtomicUint64_Add(instance, 1);
-
-    uint64_t actual = parcAtomicUint64_GetValue(instance);
-
-    assertTrue(actual == 8, "Expected 8, actual %" PRIu64, actual);
-    parcAtomicUint64_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Macros, parcAtomicUint64_CompareAndSwap)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(7);
-
-    bool actual = parcAtomicUint64_CompareAndSwap(instance, 7, 8);
-
-    assertTrue(actual, "Expected parcAtomicUint64_CompareAndSwap to return true");
-    parcAtomicUint64_Release(&instance);
-}
-
-
-LONGBOW_TEST_FIXTURE_OPTIONS(Performance, .enabled = false)
-{
-    LONGBOW_RUN_TEST_CASE(Performance, parcAtomicUint64_Subtract_MACRO);
-    LONGBOW_RUN_TEST_CASE(Performance, parcAtomicUint64_Add_MACRO);
-    LONGBOW_RUN_TEST_CASE(Performance, parcAtomicUint64_CompareAndSwap_MACRO);
-    LONGBOW_RUN_TEST_CASE(Performance, parcAtomicUint64_SubtractImpl);
-    LONGBOW_RUN_TEST_CASE(Performance, parcAtomicUint64_AddImpl);
-    LONGBOW_RUN_TEST_CASE(Performance, parcAtomicUint64_CompareAndSwapImpl);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Performance)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Performance)
-{
-    if (!parcMemoryTesting_ExpectedOutstanding(0, "%s leaked memory.", longBowTestCase_GetFullName(testCase))) {
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_CASE(Performance, parcAtomicUint64_Subtract_MACRO)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(100000000);
-
-    while (parcAtomicUint64_Subtract(instance, 1) > 0) {
-        ;
-    }
-
-    parcAtomicUint64_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Performance, parcAtomicUint64_Add_MACRO)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(1);
-
-    while (parcAtomicUint64_Add(instance, 1) < 100000000) {
-        ;
-    }
-
-    parcAtomicUint64_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Performance, parcAtomicUint64_CompareAndSwap_MACRO)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(0);
-
-    for (uint64_t i = 0; i < 100000000; i++) {
-        bool actual = parcAtomicUint64_CompareAndSwap(instance, i, i + 1);
-        assertTrue(actual, "Expected parcAtomicUint64_CompareAndSwap to return true");
-    }
-
-    parcAtomicUint64_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Performance, parcAtomicUint64_SubtractImpl)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(100000000);
-
-    while (parcAtomicUint64_SubtractImpl(instance, 1) > 0) {
-        ;
-    }
-
-    parcAtomicUint64_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Performance, parcAtomicUint64_AddImpl)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(1);
-
-    while (parcAtomicUint64_AddImpl(instance, 1) < 100000000) {
-        ;
-    }
-
-    parcAtomicUint64_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Performance, parcAtomicUint64_CompareAndSwapImpl)
-{
-    PARCAtomicUint64 *instance = parcAtomicUint64_Create(0);
-
-    for (uint64_t i = 0; i < 100000000; i++) {
-        bool actual = parcAtomicUint64_CompareAndSwapImpl(instance, i, i + 1);
-        assertTrue(actual, "Expected parcAtomicUint64_CompareAndSwapImpl to return true");
-    }
-
-    parcAtomicUint64_Release(&instance);
-}
-
-int
-main(int argc, char *argv[argc])
-{
-    LongBowRunner *testRunner = LONGBOW_TEST_RUNNER_CREATE(parc_AtomicUint64);
-    int exitStatus = longBowMain(argc, argv, testRunner, NULL);
-    longBowTestRunner_Destroy(&testRunner);
-    exit(exitStatus);
-}
diff --git a/libparc/parc/concurrent/test/test_parc_AtomicUint8.c b/libparc/parc/concurrent/test/test_parc_AtomicUint8.c
deleted file mode 100644
index 5b89d052..00000000
--- a/libparc/parc/concurrent/test/test_parc_AtomicUint8.c
+++ /dev/null
@@ -1,361 +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_AtomicUint8.c"
-
-#include <LongBow/testing.h>
-#include <LongBow/debugging.h>
-
-#include <inttypes.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/testing/parc_MemoryTesting.h>
-#include <parc/testing/parc_ObjectTesting.h>
-
-LONGBOW_TEST_RUNNER(parc_AtomicUint8)
-{
-    // 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(Macros);
-    LONGBOW_RUN_TEST_FIXTURE(Performance);
-}
-
-// The Test Runner calls this function once before any Test Fixtures are run.
-LONGBOW_TEST_RUNNER_SETUP(parc_AtomicUint8)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-// The Test Runner calls this function once after all the Test Fixtures are run.
-LONGBOW_TEST_RUNNER_TEARDOWN(parc_AtomicUint8)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE(CreateAcquireRelease)
-{
-    LONGBOW_RUN_TEST_CASE(CreateAcquireRelease, CreateRelease);
-}
-
-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)
-{
-    PARCAtomicUint8 *instance = parcAtomicUint8_Create(7);
-    assertNotNull(instance, "Expeced non-null result from parcAtomicUint8_Create();");
-
-    parcObjectTesting_AssertAcquireReleaseContract(parcAtomicUint8_Acquire, instance);
-
-    parcAtomicUint8_Release(&instance);
-    assertNull(instance, "Expected null result from parcAtomicUint8_Release();");
-}
-
-LONGBOW_TEST_FIXTURE(Global)
-{
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint8_Compare);
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint8_Copy);
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint8_Equals);
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint8_HashCode);
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint8_IsValid);
-
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint8_SubtractImpl);
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint8_AddImpl);
-    LONGBOW_RUN_TEST_CASE(Global, parcAtomicUint8_CompareAndSwapImpl);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Global)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Global)
-{
-    if (!parcMemoryTesting_ExpectedOutstanding(0, "%s leaked memory.", longBowTestCase_GetFullName(testCase))) {
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint8_Compare)
-{
-    PARCAtomicUint8 *instance = parcAtomicUint8_Create(7);
-    PARCAtomicUint8 *high = parcAtomicUint8_Create(8);
-    PARCAtomicUint8 *low = parcAtomicUint8_Create(6);
-    PARCAtomicUint8 *equal = parcAtomicUint8_Create(7);
-
-    int actual = parcAtomicUint8_Compare(instance, high);
-    assertTrue(actual < 0, "Expected < 0");
-    actual = parcAtomicUint8_Compare(instance, low);
-    assertTrue(actual > 0, "Expected > 0");
-    actual = parcAtomicUint8_Compare(instance, equal);
-    assertTrue(actual == 0, "Expected == 0");
-
-    parcAtomicUint8_Release(&instance);
-    parcAtomicUint8_Release(&high);
-    parcAtomicUint8_Release(&low);
-    parcAtomicUint8_Release(&equal);
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint8_Copy)
-{
-    PARCAtomicUint8 *instance = parcAtomicUint8_Create(7);
-    PARCAtomicUint8 *copy = parcAtomicUint8_Copy(instance);
-
-    assertTrue(parcAtomicUint8_Equals(instance, copy), "Expected the copy to be equal to the original");
-
-    parcAtomicUint8_Release(&instance);
-    parcAtomicUint8_Release(&copy);
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint8_Equals)
-{
-    PARCAtomicUint8 *x = parcAtomicUint8_Create(7);
-    PARCAtomicUint8 *y = parcAtomicUint8_Create(7);
-    PARCAtomicUint8 *z = parcAtomicUint8_Create(7);
-    PARCAtomicUint8 *u1 = parcAtomicUint8_Create(6);
-
-    parcObjectTesting_AssertEquals(x, y, z, u1, NULL);
-
-    parcAtomicUint8_Release(&x);
-    parcAtomicUint8_Release(&y);
-    parcAtomicUint8_Release(&z);
-    parcAtomicUint8_Release(&u1);
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint8_HashCode)
-{
-    PARCAtomicUint8 *x = parcAtomicUint8_Create(7);
-    parcAtomicUint8_HashCode(x);
-    parcAtomicUint8_Release(&x);
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint8_IsValid)
-{
-    PARCAtomicUint8 *instance = parcAtomicUint8_Create(7);
-    assertTrue(parcAtomicUint8_IsValid(instance), "Expected parcAtomicUint8_Create to result in a valid instance.");
-
-    parcAtomicUint8_Release(&instance);
-    assertFalse(parcAtomicUint8_IsValid(instance), "Expected parcAtomicUint8_Release to result in an invalid instance.");
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint8_SubtractImpl)
-{
-    PARCAtomicUint8 *instance = parcAtomicUint8_Create(7);
-
-    parcAtomicUint8_SubtractImpl(instance, 1);
-
-    uint8_t actual = parcAtomicUint8_GetValue(instance);
-
-    assertTrue(actual == 6, "Expected 6, actual %" PRIu8, actual);
-    parcAtomicUint8_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint8_AddImpl)
-{
-    PARCAtomicUint8 *instance = parcAtomicUint8_Create(7);
-
-    parcAtomicUint8_AddImpl(instance, 1);
-
-    uint8_t actual = parcAtomicUint8_GetValue(instance);
-
-    assertTrue(actual == 8, "Expected 8, actual %" PRIu8, actual);
-    parcAtomicUint8_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Global, parcAtomicUint8_CompareAndSwapImpl)
-{
-    PARCAtomicUint8 *instance = parcAtomicUint8_Create(7);
-
-    bool actual = parcAtomicUint8_CompareAndSwapImpl(instance, 7, 8);
-
-    assertTrue(actual, "Expected parcAtomicUint8_CompareAndSwapImpl to return true");
-    parcAtomicUint8_Release(&instance);
-}
-
-LONGBOW_TEST_FIXTURE(Macros)
-{
-    LONGBOW_RUN_TEST_CASE(Macros, parcAtomicUint8_Subtract);
-    LONGBOW_RUN_TEST_CASE(Macros, parcAtomicUint8_Add);
-    LONGBOW_RUN_TEST_CASE(Macros, parcAtomicUint8_CompareAndSwap);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Macros)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Macros)
-{
-    if (!parcMemoryTesting_ExpectedOutstanding(0, "%s leaked memory.", longBowTestCase_GetFullName(testCase))) {
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_CASE(Macros, parcAtomicUint8_Subtract)
-{
-    PARCAtomicUint8 *instance = parcAtomicUint8_Create(7);
-
-    parcAtomicUint8_Subtract(instance, 1);
-
-    uint8_t actual = parcAtomicUint8_GetValue(instance);
-
-    assertTrue(actual == 6, "Expected 6, actual %" PRIu8, actual);
-    parcAtomicUint8_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Macros, parcAtomicUint8_Add)
-{
-    PARCAtomicUint8 *instance = parcAtomicUint8_Create(7);
-
-    parcAtomicUint8_Add(instance, 1);
-
-    uint8_t actual = parcAtomicUint8_GetValue(instance);
-
-    assertTrue(actual == 8, "Expected 8, actual %" PRIu8, actual);
-    parcAtomicUint8_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Macros, parcAtomicUint8_CompareAndSwap)
-{
-    PARCAtomicUint8 *instance = parcAtomicUint8_Create(7);
-
-    bool actual = parcAtomicUint8_CompareAndSwap(instance, 7, 8);
-
-    assertTrue(actual, "Expected parcAtomicUint8_CompareAndSwap to return true");
-    parcAtomicUint8_Release(&instance);
-}
-
-
-LONGBOW_TEST_FIXTURE_OPTIONS(Performance, .enabled = false)
-{
-    LONGBOW_RUN_TEST_CASE(Performance, parcAtomicUint8_Subtract_MACRO);
-    LONGBOW_RUN_TEST_CASE(Performance, parcAtomicUint8_Add_MACRO);
-    LONGBOW_RUN_TEST_CASE(Performance, parcAtomicUint8_CompareAndSwap_MACRO);
-    LONGBOW_RUN_TEST_CASE(Performance, parcAtomicUint8_SubtractImpl);
-    LONGBOW_RUN_TEST_CASE(Performance, parcAtomicUint8_AddImpl);
-    LONGBOW_RUN_TEST_CASE(Performance, parcAtomicUint8_CompareAndSwapImpl);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Performance)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Performance)
-{
-    if (!parcMemoryTesting_ExpectedOutstanding(0, "%s leaked memory.", longBowTestCase_GetFullName(testCase))) {
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_CASE(Performance, parcAtomicUint8_Subtract_MACRO)
-{
-    PARCAtomicUint8 *instance = parcAtomicUint8_Create(255);
-
-    while (parcAtomicUint8_Subtract(instance, 1) > 0) {
-        ;
-    }
-
-    parcAtomicUint8_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Performance, parcAtomicUint8_Add_MACRO)
-{
-    PARCAtomicUint8 *instance = parcAtomicUint8_Create(1);
-
-    while (parcAtomicUint8_Add(instance, 1) < 255) {
-        ;
-    }
-
-    parcAtomicUint8_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Performance, parcAtomicUint8_CompareAndSwap_MACRO)
-{
-    PARCAtomicUint8 *instance = parcAtomicUint8_Create(0);
-
-    for (uint8_t i = 0; i < 255; i++) {
-        bool actual = parcAtomicUint8_CompareAndSwap(instance, i, i + 1);
-        assertTrue(actual, "Expected parcAtomicUint8_CompareAndSwap to return true");
-    }
-
-    parcAtomicUint8_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Performance, parcAtomicUint8_SubtractImpl)
-{
-    PARCAtomicUint8 *instance = parcAtomicUint8_Create(255);
-
-    while (parcAtomicUint8_SubtractImpl(instance, 1) > 0) {
-        ;
-    }
-
-    parcAtomicUint8_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Performance, parcAtomicUint8_AddImpl)
-{
-    PARCAtomicUint8 *instance = parcAtomicUint8_Create(1);
-
-    while (parcAtomicUint8_AddImpl(instance, 1) < 255) {
-        ;
-    }
-
-    parcAtomicUint8_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Performance, parcAtomicUint8_CompareAndSwapImpl)
-{
-    PARCAtomicUint8 *instance = parcAtomicUint8_Create(0);
-
-    for (uint8_t i = 0; i < 255; i++) {
-        bool actual = parcAtomicUint8_CompareAndSwapImpl(instance, i, i + 1);
-        assertTrue(actual, "Expected parcAtomicUint8_CompareAndSwapImpl to return true");
-    }
-
-    parcAtomicUint8_Release(&instance);
-}
-
-int
-main(int argc, char *argv[argc])
-{
-    LongBowRunner *testRunner = LONGBOW_TEST_RUNNER_CREATE(parc_AtomicUint8);
-    int exitStatus = longBowMain(argc, argv, testRunner, NULL);
-    longBowTestRunner_Destroy(&testRunner);
-    exit(exitStatus);
-}
diff --git a/libparc/parc/concurrent/test/test_parc_FutureTask.c b/libparc/parc/concurrent/test/test_parc_FutureTask.c
deleted file mode 100644
index c30d2cae..00000000
--- a/libparc/parc/concurrent/test/test_parc_FutureTask.c
+++ /dev/null
@@ -1,317 +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_FutureTask.c"
-
-#include <LongBow/testing.h>
-#include <LongBow/debugging.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_SafeMemory.h>
-#include <parc/algol/parc_DisplayIndented.h>
-
-#include <parc/testing/parc_MemoryTesting.h>
-#include <parc/testing/parc_ObjectTesting.h>
-
-LONGBOW_TEST_RUNNER(parc_FutureTask)
-{
-    // 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(Object);
-    LONGBOW_RUN_TEST_FIXTURE(Specialization);
-}
-
-// The Test Runner calls this function once before any Test Fixtures are run.
-LONGBOW_TEST_RUNNER_SETUP(parc_FutureTask)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-// The Test Runner calls this function once after all the Test Fixtures are run.
-LONGBOW_TEST_RUNNER_TEARDOWN(parc_FutureTask)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE(CreateAcquireRelease)
-{
-    LONGBOW_RUN_TEST_CASE(CreateAcquireRelease, CreateRelease);
-    LONGBOW_RUN_TEST_CASE(CreateAcquireRelease, CreateRelease_PARCObject);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(CreateAcquireRelease)
-{
-    longBowTestCase_SetInt(testCase, "initialAllocations", parcMemory_Outstanding());
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(CreateAcquireRelease)
-{
-    int initialAllocations = longBowTestCase_GetInt(testCase, "initialAllocations");
-
-    if (!parcMemoryTesting_ExpectedOutstanding(initialAllocations, "%s leaked memory.", longBowTestCase_GetFullName(testCase))) {
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-static void *
-_function(PARCFutureTask *task, void *parameter)
-{
-    return parameter;
-}
-
-LONGBOW_TEST_CASE(CreateAcquireRelease, CreateRelease)
-{
-    PARCFutureTask *instance = parcFutureTask_Create(_function, _function);
-    assertNotNull(instance, "Expected non-null result from parcFutureTask_Create(_function, _function);");
-
-    parcObjectTesting_AssertAcquireReleaseContract(parcFutureTask_Acquire, instance);
-
-    parcFutureTask_Release(&instance);
-    assertNull(instance, "Expected null result from parcFutureTask_Release();");
-}
-
-LONGBOW_TEST_CASE(CreateAcquireRelease, CreateRelease_PARCObject)
-{
-    PARCBuffer *object = parcBuffer_Allocate(10);
-
-    PARCFutureTask *instance = parcFutureTask_Create(_function, object);
-    parcBuffer_Release(&object);
-
-    assertNotNull(instance, "Expected non-null result from parcFutureTask_Create(_function, object);");
-
-    parcObjectTesting_AssertAcquireReleaseContract(parcFutureTask_Acquire, instance);
-
-    parcFutureTask_Release(&instance);
-    assertNull(instance, "Expected null result from parcFutureTask_Release();");
-}
-
-LONGBOW_TEST_FIXTURE(Object)
-{
-    LONGBOW_RUN_TEST_CASE(Object, parcFutureTask_Compare);
-    LONGBOW_RUN_TEST_CASE(Object, parcFutureTask_Copy);
-    LONGBOW_RUN_TEST_CASE(Object, parcFutureTask_Display);
-    LONGBOW_RUN_TEST_CASE(Object, parcFutureTask_Equals);
-    LONGBOW_RUN_TEST_CASE(Object, parcFutureTask_HashCode);
-    LONGBOW_RUN_TEST_CASE(Object, parcFutureTask_IsValid);
-    LONGBOW_RUN_TEST_CASE(Object, parcFutureTask_ToJSON);
-    LONGBOW_RUN_TEST_CASE(Object, parcFutureTask_ToString);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Object)
-{
-    longBowTestCase_SetInt(testCase, "initialAllocations", parcMemory_Outstanding());
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Object)
-{
-    int initialAllocations = longBowTestCase_GetInt(testCase, "initialAllocations");
-
-    if (!parcMemoryTesting_ExpectedOutstanding(initialAllocations, "%s leaked memory.", longBowTestCase_GetFullName(testCase))) {
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_CASE(Object, parcFutureTask_Compare)
-{
-    testUnimplemented("");
-}
-
-LONGBOW_TEST_CASE(Object, parcFutureTask_Copy)
-{
-    PARCFutureTask *instance = parcFutureTask_Create(_function, _function);
-    PARCFutureTask *copy = parcFutureTask_Copy(instance);
-    assertTrue(parcFutureTask_Equals(instance, copy), "Expected the copy to be equal to the original");
-
-    parcFutureTask_Release(&instance);
-    parcFutureTask_Release(&copy);
-}
-
-LONGBOW_TEST_CASE(Object, parcFutureTask_Display)
-{
-    PARCFutureTask *instance = parcFutureTask_Create(_function, _function);
-    parcFutureTask_Display(instance, 0);
-    parcFutureTask_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Object, parcFutureTask_Equals)
-{
-    PARCFutureTask *x = parcFutureTask_Create(_function, _function);
-    PARCFutureTask *y = parcFutureTask_Create(_function, _function);
-    PARCFutureTask *z = parcFutureTask_Create(_function, _function);
-    PARCFutureTask *u1 = parcFutureTask_Create(_function, NULL);
-
-    parcObjectTesting_AssertEquals(x, y, z, u1, NULL);
-
-    parcFutureTask_Release(&x);
-    parcFutureTask_Release(&y);
-    parcFutureTask_Release(&z);
-    parcFutureTask_Release(&u1);
-}
-
-LONGBOW_TEST_CASE(Object, parcFutureTask_HashCode)
-{
-    PARCFutureTask *x = parcFutureTask_Create(_function, _function);
-    PARCFutureTask *y = parcFutureTask_Create(_function, _function);
-
-    parcObjectTesting_AssertHashCode(x, y);
-
-    parcFutureTask_Release(&x);
-    parcFutureTask_Release(&y);
-}
-
-LONGBOW_TEST_CASE(Object, parcFutureTask_IsValid)
-{
-    PARCFutureTask *instance = parcFutureTask_Create(_function, _function);
-    assertTrue(parcFutureTask_IsValid(instance), "Expected parcFutureTask_Create to result in a valid instance.");
-
-    parcFutureTask_Release(&instance);
-    assertFalse(parcFutureTask_IsValid(instance), "Expected parcFutureTask_Release to result in an invalid instance.");
-}
-
-LONGBOW_TEST_CASE(Object, parcFutureTask_ToJSON)
-{
-    PARCFutureTask *instance = parcFutureTask_Create(_function, _function);
-
-    PARCJSON *json = parcFutureTask_ToJSON(instance);
-
-    parcJSON_Release(&json);
-
-    parcFutureTask_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Object, parcFutureTask_ToString)
-{
-    PARCFutureTask *instance = parcFutureTask_Create(_function, _function);
-
-    char *string = parcFutureTask_ToString(instance);
-
-    assertNotNull(string, "Expected non-NULL result from parcFutureTask_ToString");
-
-    parcMemory_Deallocate((void **) &string);
-    parcFutureTask_Release(&instance);
-}
-
-LONGBOW_TEST_FIXTURE(Specialization)
-{
-    LONGBOW_RUN_TEST_CASE(Specialization, parcFutureTask_Cancel);
-    LONGBOW_RUN_TEST_CASE(Specialization, parcFutureTask_Get);
-    LONGBOW_RUN_TEST_CASE(Specialization, parcFutureTask_IsCancelled);
-    LONGBOW_RUN_TEST_CASE(Specialization, parcFutureTask_IsDone);
-    LONGBOW_RUN_TEST_CASE(Specialization, parcFutureTask_Run);
-    LONGBOW_RUN_TEST_CASE(Specialization, parcFutureTask_RunAndReset);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Specialization)
-{
-    longBowTestCase_SetInt(testCase, "initialAllocations", parcMemory_Outstanding());
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Specialization)
-{
-    int initialAllocations = longBowTestCase_GetInt(testCase, "initialAllocations");
-
-    if (!parcMemoryTesting_ExpectedOutstanding(initialAllocations, "%s leaked memory.", longBowTestCase_GetFullName(testCase))) {
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_CASE(Specialization, parcFutureTask_Cancel)
-{
-    PARCFutureTask *task = parcFutureTask_Create(_function, _function);
-
-    bool parcFutureTask_Cancel(PARCFutureTask *task, bool mayInterruptIfRunning);
-
-    parcFutureTask_Release(&task);
-}
-
-LONGBOW_TEST_CASE(Specialization, parcFutureTask_Get)
-{
-    PARCFutureTask *task = parcFutureTask_Create(_function, _function);
-
-    PARCFutureTaskResult result = parcFutureTask_Get(task, PARCTimeout_Immediate);
-
-    assertTrue(parcExecution_Is(result.execution, PARCExecution_Timeout), "Expected Timeout, actual %s",
-               parcExecution_GetMessage(result.execution));
-    parcFutureTask_Release(&task);
-}
-
-LONGBOW_TEST_CASE(Specialization, parcFutureTask_IsCancelled)
-{
-    PARCFutureTask *task = parcFutureTask_Create(_function, _function);
-
-    bool actual = parcFutureTask_IsCancelled(task);
-    assertFalse(actual, "Expected true.");
-
-    parcFutureTask_Release(&task);
-}
-
-LONGBOW_TEST_CASE(Specialization, parcFutureTask_IsDone)
-{
-    PARCFutureTask *task = parcFutureTask_Create(_function, _function);
-
-    bool actual = parcFutureTask_IsDone(task);
-
-    assertFalse(actual, "Expected false.");
-
-    parcFutureTask_Release(&task);
-}
-
-LONGBOW_TEST_CASE(Specialization, parcFutureTask_Run)
-{
-    PARCFutureTask *task = parcFutureTask_Create(_function, _function);
-
-    parcFutureTask_Run(task);
-
-    PARCFutureTaskResult actual = parcFutureTask_Get(task, PARCTimeout_Immediate);
-
-    assertTrue(parcFutureTask_IsDone(task), "Expected parcFutureTask_IsDone to be true.");
-    assertTrue(parcExecution_Is(actual.execution, PARCExecution_OK),
-               "Expected OK, actual %s", parcExecution_GetMessage(actual.execution));
-    assertTrue(actual.value == _function, "Expected actual to point to _function");
-    parcFutureTask_Release(&task);
-}
-
-LONGBOW_TEST_CASE(Specialization, parcFutureTask_RunAndReset)
-{
-    PARCFutureTask *task = parcFutureTask_Create(_function, _function);
-
-    bool actual = parcFutureTask_RunAndReset(task);
-
-    assertTrue(actual, "Expectd parcFutureTask_RunAndReset to return true.");
-    assertFalse(parcFutureTask_IsDone(task), "Expected parcFutureTask_IsDone to be false");
-    parcFutureTask_Release(&task);
-}
-
-int
-main(int argc, char *argv[argc])
-{
-    LongBowRunner *testRunner = LONGBOW_TEST_RUNNER_CREATE(parc_FutureTask);
-    int exitStatus = longBowMain(argc, argv, testRunner, NULL);
-    longBowTestRunner_Destroy(&testRunner);
-    exit(exitStatus);
-}
diff --git a/libparc/parc/concurrent/test/test_parc_Lock.c b/libparc/parc/concurrent/test/test_parc_Lock.c
deleted file mode 100644
index 731df04a..00000000
--- a/libparc/parc/concurrent/test/test_parc_Lock.c
+++ /dev/null
@@ -1,352 +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_Lock.c"
-
-#include <stdio.h>
-
-#include <LongBow/testing.h>
-#include <LongBow/debugging.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_SafeMemory.h>
-#include <parc/algol/parc_DisplayIndented.h>
-
-#include <parc/testing/parc_MemoryTesting.h>
-#include <parc/testing/parc_ObjectTesting.h>
-
-LONGBOW_TEST_RUNNER(parc_Lock)
-{
-    // 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(Locking);
-    LONGBOW_RUN_TEST_FIXTURE(WaitNotify);
-}
-
-// The Test Runner calls this function once before any Test Fixtures are run.
-LONGBOW_TEST_RUNNER_SETUP(parc_Lock)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-// The Test Runner calls this function once after all the Test Fixtures are run.
-LONGBOW_TEST_RUNNER_TEARDOWN(parc_Lock)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE(CreateAcquireRelease)
-{
-    LONGBOW_RUN_TEST_CASE(CreateAcquireRelease, CreateRelease);
-}
-
-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)
-{
-    PARCLock *instance = parcLock_Create();
-    assertNotNull(instance, "Expected non-null result from parcLock_Create().");
-
-    parcObjectTesting_AssertAcquire(instance);
-
-    parcObjectTesting_AssertAcquireReleaseContract(parcLock_Acquire, instance);
-
-    parcLock_Release(&instance);
-    assertNull(instance, "Expected null result from parcLock_Release().");
-}
-
-LONGBOW_TEST_FIXTURE(Global)
-{
-    LONGBOW_RUN_TEST_CASE(Global, parcLock_Display);
-    LONGBOW_RUN_TEST_CASE(Global, parcLock_IsValid);
-    LONGBOW_RUN_TEST_CASE(Global, parcLock_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, parcLock_Display)
-{
-    PARCLock *lock = parcLock_Create();
-    parcLock_Display(lock, 0);
-    parcLock_Release(&lock);
-}
-
-LONGBOW_TEST_CASE(Global, parcLock_IsValid)
-{
-    PARCLock *instance = parcLock_Create();
-    assertTrue(parcLock_IsValid(instance), "Expected parcLock_Create to result in a valid instance.");
-
-    parcLock_Release(&instance);
-    assertFalse(parcLock_IsValid(instance), "Expected parcLock_Release to result in an invalid instance.");
-}
-
-LONGBOW_TEST_CASE(Global, parcLock_ToString)
-{
-    PARCLock *instance = parcLock_Create();
-
-    char *string = parcLock_ToString(instance);
-
-    assertNotNull(string, "Expected non-NULL result from parcLock_ToString");
-
-    parcMemory_Deallocate((void **) &string);
-    parcLock_Release(&instance);
-}
-
-LONGBOW_TEST_FIXTURE(Locking)
-{
-    LONGBOW_RUN_TEST_CASE(Locking, parcLock_TryLock_Unlock);
-    LONGBOW_RUN_TEST_CASE(Locking, parcLock_TryLock_AlreadyLocked);
-    LONGBOW_RUN_TEST_CASE(Locking, parcLock_Lock_Unlock);
-    LONGBOW_RUN_TEST_CASE(Locking, parcLock_Lock_AlreadyLocked);
-    LONGBOW_RUN_TEST_CASE(Locking, parcLock_Lock_AlreadyLocked);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Locking)
-{
-    parcMemory_SetInterface(&PARCSafeMemoryAsPARCMemory);
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Locking)
-{
-    uint32_t outstandingAllocations = parcSafeMemory_ReportAllocation(STDOUT_FILENO);
-    if (outstandingAllocations != 0) {
-        printf("%s leaks memory by %d allocations\n", longBowTestRunner_GetName(testRunner), outstandingAllocations);
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_CASE(Locking, parcLock_TryLock_Unlock)
-{
-    PARCLock *lock = parcLock_Create();
-
-    bool actual = parcLock_TryLock(lock);
-
-    assertTrue(actual, "Expected parcObject_TryLock to succeed.");
-
-    actual = parcLock_IsLocked(lock);
-    assertTrue(actual, "Expected parcObject_IsLocked to be true.");
-
-    actual = parcLock_Unlock(lock);
-    assertTrue(actual, "Expected parcObject_Unlock to succeed.");
-
-    actual = parcLock_IsLocked(lock);
-    assertTrue(actual, "Expected parcObject_IsLocked to be false.");
-
-    parcLock_Release((PARCLock **) &lock);
-}
-
-LONGBOW_TEST_CASE(Locking, parcLock_Lock_Unlock)
-{
-    PARCLock *lock = parcLock_Create();
-
-    bool actual = parcLock_Lock(lock);
-
-    assertTrue(actual, "Expected parcObject_Lock to succeed.");
-
-    actual = parcLock_IsLocked(lock);
-    assertTrue(actual, "Expected parcObject_IsLocked to be true.");
-
-    actual = parcLock_Unlock(lock);
-    assertTrue(actual, "Expected parcObject_Unlock to succeed.");
-
-    actual = parcLock_IsLocked(lock);
-    assertTrue(actual, "Expected parcObject_IsLocked to be false.");
-
-    parcLock_Release((PARCLock **) &lock);
-}
-
-LONGBOW_TEST_CASE(Locking, parcLock_TryLock_AlreadyLocked)
-{
-    PARCLock *lock = parcLock_Create();
-
-    bool actual = parcLock_TryLock(lock);
-
-    assertTrue(actual, "Expected parcObject_TryLock to succeed.");
-
-    actual = parcLock_TryLock(lock);
-
-    assertFalse(actual, "Expected parcObject_TryLock to fail when already locked.");
-
-    actual = parcLock_Unlock(lock);
-    assertTrue(actual, "Expected parcObject_Unlock to succeed.");
-
-    parcLock_Release((PARCLock **) &lock);
-}
-
-LONGBOW_TEST_CASE(Locking, parcLock_Lock_AlreadyLocked)
-{
-    PARCLock *lock = parcLock_Create();
-
-    bool actual = parcLock_Lock(lock);
-
-    assertTrue(actual, "Expected parcObject_Lock to succeed.");
-
-    actual = parcLock_Lock(lock);
-
-    assertFalse(actual, "Expected parcObject_Lock to fail when already locked by the same thread.");
-
-    actual = parcLock_Unlock(lock);
-    assertTrue(actual, "Expected parcObject_Unlock to succeed.");
-
-    parcLock_Release((PARCLock **) &lock);
-}
-
-LONGBOW_TEST_FIXTURE(WaitNotify)
-{
-    LONGBOW_RUN_TEST_CASE(WaitNotify, parcLock_WaitNotify);
-    LONGBOW_RUN_TEST_CASE(WaitNotify, parcLock_WaitNotify2);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(WaitNotify)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(WaitNotify)
-{
-    uint32_t outstandingAllocations = parcSafeMemory_ReportAllocation(STDOUT_FILENO);
-    if (outstandingAllocations != 0) {
-        printf("%s leaks memory by %d allocations\n", longBowTestRunner_GetName(testRunner), outstandingAllocations);
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-static int _sharedValue;
-
-static void *
-waiter(void *data)
-{
-    PARCLock *lock = data;
-
-    while (parcLock_TryLock(lock) == false) {
-        ;
-    }
-    parcLock_Wait(lock);
-
-    _sharedValue++;
-    parcLock_Unlock(lock);
-
-    return data;
-}
-
-LONGBOW_TEST_CASE(WaitNotify, parcLock_WaitNotify)
-{
-    PARCLock *lock = parcLock_Create();
-
-    _sharedValue = 0;
-
-    pthread_t thread_A;
-    pthread_t thread_B;
-    pthread_t thread_C;
-    pthread_create(&thread_A, NULL, waiter, lock);
-    pthread_create(&thread_B, NULL, waiter, lock);
-    pthread_create(&thread_C, NULL, waiter, lock);
-
-    while (_sharedValue != 3) {
-        while (parcLock_TryLock(lock) == false) {
-            ;
-        }
-        parcLock_Notify(lock);
-        parcLock_Unlock(lock);
-    }
-
-    pthread_join(thread_A, NULL);
-
-    parcLock_Release((PARCLock **) &lock);
-}
-
-static void *
-decrement(void *data)
-{
-    PARCLock *lock = data;
-
-    while (parcLock_TryLock(lock) == false) {
-        assertTrue(write(1, ".", 1) == 1, "Write failed.");
-    }
-    while (_sharedValue < 12) {
-        parcLock_Wait(lock);
-        _sharedValue--;
-    }
-    parcLock_Unlock(lock);
-
-    return data;
-}
-
-LONGBOW_TEST_CASE(WaitNotify, parcLock_WaitNotify2)
-{
-    PARCLock *lock = parcLock_Create();
-
-    _sharedValue = 0;
-
-    pthread_t thread_A;
-    pthread_create(&thread_A, NULL, decrement, lock);
-
-    _sharedValue = 2;
-    while (parcLock_TryLock(lock) == false) {
-        assertTrue(write(1, ".", 1) == 1, "Write failed.");
-    }
-    while (_sharedValue <= 12) {
-        printf("%d\n", _sharedValue);
-        parcLock_Notify(lock);
-        _sharedValue += 2;
-    }
-    parcLock_Unlock(lock);
-
-    parcLock_Notify(lock);
-    pthread_join(thread_A, NULL);
-
-    parcLock_Release((PARCLock **) &lock);
-}
-
-int
-main(int argc, char *argv[argc])
-{
-    LongBowRunner *testRunner = LONGBOW_TEST_RUNNER_CREATE(parc_Lock);
-    int exitStatus = longBowMain(argc, argv, testRunner, NULL);
-    longBowTestRunner_Destroy(&testRunner);
-    exit(exitStatus);
-}
diff --git a/libparc/parc/concurrent/test/test_parc_Notifier.c b/libparc/parc/concurrent/test/test_parc_Notifier.c
deleted file mode 100755
index 97ce6615..00000000
--- a/libparc/parc/concurrent/test/test_parc_Notifier.c
+++ /dev/null
@@ -1,267 +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 the file(s) containing the functions to be tested.
-// This permits internal static functions to be visible to this Test Framework.
-#include "../parc_Notifier.c"
-
-#include <sys/time.h>
-#include <pthread.h>
-#include <poll.h>
-
-#include <parc/algol/parc_SafeMemory.h>
-#include <LongBow/unit-test.h>
-
-LONGBOW_TEST_RUNNER(parc_Notifier)
-{
-    // 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);
-}
-
-// The Test Runner calls this function once before any Test Fixtures are run.
-LONGBOW_TEST_RUNNER_SETUP(parc_Notifier)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-// The Test Runner calls this function once after all the Test Fixtures are run.
-LONGBOW_TEST_RUNNER_TEARDOWN(parc_Notifier)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE(Global)
-{
-    LONGBOW_RUN_TEST_CASE(Global, parcNotifier_Acquire);
-    LONGBOW_RUN_TEST_CASE(Global, parcNotifier_Create_Release);
-    LONGBOW_RUN_TEST_CASE(Global, parcNotifier_PauseEvent_NotPaused);
-    LONGBOW_RUN_TEST_CASE(Global, parcNotifier_PauseEvent_AlreadyPaused);
-    LONGBOW_RUN_TEST_CASE(Global, parcNotifier_StartEvents);
-
-    LONGBOW_RUN_TEST_CASE(Global, parcNotifier_Notify_First);
-    LONGBOW_RUN_TEST_CASE(Global, parcNotifier_Notify_Twice);
-
-    LONGBOW_RUN_TEST_CASE(Global, parcNotifier_ThreadedTest);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Global)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Global)
-{
-    if (parcSafeMemory_ReportAllocation(STDOUT_FILENO) != 0) {
-        printf("('%s' leaks memory by %d (allocs - frees)) ", longBowTestCase_GetName(testCase), parcMemory_Outstanding());
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-// ------
-typedef struct test_data {
-    volatile int barrier;
-    PARCNotifier *notifier;
-
-    unsigned notificationsToSend;
-    unsigned notificationsSent;
-
-    unsigned notificationsToRecieve;
-    unsigned notificationsReceived;
-
-    pthread_t producerThread;
-    pthread_t consumerThread;
-} TestData;
-
-
-void *
-consumer(void *p)
-{
-    TestData *data = (TestData *) p;
-    --data->barrier;
-    while (data->barrier) {
-        ;
-    }
-
-    struct pollfd pfd;
-    pfd.fd = parcNotifier_Socket(data->notifier);
-    pfd.events = POLLIN;
-
-    while (data->notificationsReceived < data->notificationsToRecieve) {
-        if (poll(&pfd, 1, -1)) {
-            data->notificationsReceived++;
-            parcNotifier_PauseEvents(data->notifier);
-            usleep(rand() % 1024 + 1024);
-            printf("skipped = %d\n", data->notifier->skippedNotify);
-            parcNotifier_StartEvents(data->notifier);
-        }
-    }
-
-    --data->barrier;
-
-    printf("Consumer exiting: received %d\n", data->notificationsReceived);
-    pthread_exit((void *) NULL);
-}
-
-void *
-producer(void *p)
-{
-    TestData *data = (TestData *) p;
-    --data->barrier;
-    while (data->barrier) {
-        ;
-    }
-
-    while (data->barrier == 0) {
-        if (parcNotifier_Notify(data->notifier)) {
-        }
-        data->notificationsSent++;
-        usleep(rand() % 1024 + 512);
-    }
-
-    printf("Producer exiting: sent %d\n", data->notificationsSent);
-    pthread_exit((void *) NULL);
-}
-
-LONGBOW_TEST_CASE(Global, parcNotifier_Acquire)
-{
-    testUnimplemented("");
-}
-
-LONGBOW_TEST_CASE(Global, parcNotifier_Create_Release)
-{
-    testUnimplemented("");
-}
-
-LONGBOW_TEST_CASE(Global, parcNotifier_PauseEvent_NotPaused)
-{
-    PARCNotifier *notifier = parcNotifier_Create();
-
-    parcNotifier_PauseEvents(notifier);
-    assertTrue(notifier->paused == 1, "Not paused, got %d expected %d", notifier->paused, 1);
-    assertTrue(notifier->skippedNotify == 0, "Wrong skipped, got %d expected %d", notifier->skippedNotify, 0);
-
-    parcNotifier_Release(&notifier);
-}
-
-LONGBOW_TEST_CASE(Global, parcNotifier_PauseEvent_AlreadyPaused)
-{
-    PARCNotifier *notifier = parcNotifier_Create();
-
-    parcNotifier_PauseEvents(notifier);
-
-    // now pause again
-    parcNotifier_PauseEvents(notifier);
-
-    assertTrue(notifier->paused == 1, "Not paused, got %d expected %d", notifier->paused, 1);
-    assertTrue(notifier->skippedNotify == 0, "Wrong skipped, got %d expected %d", notifier->skippedNotify, 0);
-
-    parcNotifier_Release(&notifier);
-}
-
-
-LONGBOW_TEST_CASE(Global, parcNotifier_ThreadedTest)
-{
-    TestData *data = parcMemory_AllocateAndClear(sizeof(TestData));
-    assertNotNull(data, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(TestData));
-
-    data->notifier = parcNotifier_Create();
-    data->notificationsToSend = 10;
-    data->notificationsToRecieve = data->notificationsToSend;
-    data->notificationsSent = 0;
-    data->notificationsReceived = 0;
-    data->barrier = 2;
-
-    pthread_create(&data->consumerThread, NULL, consumer, data);
-    pthread_create(&data->producerThread, NULL, producer, data);
-
-    // wait for them to exit
-    pthread_join(data->producerThread, NULL);
-    pthread_join(data->consumerThread, NULL);
-
-    assertTrue(data->notificationsReceived >= data->notificationsToRecieve,
-               "Did not write all items got %u expected %u\n",
-               data->notificationsReceived,
-               data->notificationsToRecieve);
-
-    parcNotifier_Release(&data->notifier);
-    parcMemory_Deallocate((void **) &data);
-}
-
-LONGBOW_TEST_CASE(Global, parcNotifier_StartEvents)
-{
-    testUnimplemented("unimplemented");
-}
-
-LONGBOW_TEST_CASE(Global, parcNotifier_Notify_First)
-{
-    PARCNotifier *notifier = parcNotifier_Create();
-
-    bool success = parcNotifier_Notify(notifier);
-    assertTrue(success, "Did not succeed on first notify");
-    assertTrue(notifier->paused == 1, "Not paused, got %d expected %d", notifier->paused, 1);
-    assertTrue(notifier->skippedNotify == 0, "Wrong skipped, got %d expected %d", notifier->skippedNotify, 0);
-
-    parcNotifier_Release(&notifier);
-}
-
-
-LONGBOW_TEST_CASE(Global, parcNotifier_Notify_Twice)
-{
-    PARCNotifier *notifier = parcNotifier_Create();
-
-    parcNotifier_Notify(notifier);
-
-    bool success = parcNotifier_Notify(notifier);
-    assertFalse(success, "Should have failed on second notify");
-    assertTrue(notifier->paused == 1, "Not paused, got %d expected %d", notifier->paused, 1);
-    assertTrue(notifier->skippedNotify == 1, "Wrong skipped, got %d expected %d", notifier->skippedNotify, 1);
-
-    parcNotifier_Release(&notifier);
-}
-
-// ===============================================================
-
-LONGBOW_TEST_FIXTURE(Local)
-{
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Local)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Local)
-{
-    if (parcSafeMemory_ReportAllocation(STDOUT_FILENO) != 0) {
-        printf("('%s' leaks memory by %d (allocs - frees)) ", longBowTestCase_GetName(testCase), parcMemory_Outstanding());
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-int
-main(int argc, char *argv[])
-{
-    LongBowRunner *testRunner = LONGBOW_TEST_RUNNER_CREATE(parc_Notifier);
-    int exitStatus = LONGBOW_TEST_MAIN(argc, argv, testRunner);
-    longBowTestRunner_Destroy(&testRunner);
-    exit(exitStatus);
-}
diff --git a/libparc/parc/concurrent/test/test_parc_RingBuffer_1x1.c b/libparc/parc/concurrent/test/test_parc_RingBuffer_1x1.c
deleted file mode 100755
index a977dfbc..00000000
--- a/libparc/parc/concurrent/test/test_parc_RingBuffer_1x1.c
+++ /dev/null
@@ -1,325 +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 the file(s) containing the functions to be tested.
-// This permits internal static functions to be visible to this Test Framework.
-#include "../parc_RingBuffer_1x1.c"
-
-#include <sys/time.h>
-
-#include <parc/algol/parc_SafeMemory.h>
-#include <LongBow/unit-test.h>
-
-LONGBOW_TEST_RUNNER(parc_RingBuffer_1x1)
-{
-    // 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(Local);
-}
-
-// The Test Runner calls this function once before any Test Fixtures are run.
-LONGBOW_TEST_RUNNER_SETUP(parc_RingBuffer_1x1)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-// The Test Runner calls this function once after all the Test Fixtures are run.
-LONGBOW_TEST_RUNNER_TEARDOWN(parc_RingBuffer_1x1)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE(Global)
-{
-    LONGBOW_RUN_TEST_CASE(Global, parcRingBuffer1x1_Acquire);
-    LONGBOW_RUN_TEST_CASE(Global, parcRingBuffer1x1_Create_Release);
-    LONGBOW_RUN_TEST_CASE(Global, parcRingBuffer1x1_Create_NonPower2);
-    LONGBOW_RUN_TEST_CASE(Global, parcRingBuffer1x1_Get_Put);
-    LONGBOW_RUN_TEST_CASE(Global, parcRingBuffer1x1_Remaining_Empty);
-    LONGBOW_RUN_TEST_CASE(Global, parcRingBuffer1x1_Remaining_Half);
-    LONGBOW_RUN_TEST_CASE(Global, parcRingBuffer1x1_Remaining_Full);
-    LONGBOW_RUN_TEST_CASE(Global, parcRingBuffer1x1_Put_ToCapacity);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Global)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Global)
-{
-    if (parcSafeMemory_ReportAllocation(STDOUT_FILENO) != 0) {
-        printf("('%s' leaks memory by %d (allocs - frees)) ", longBowTestCase_GetName(testCase), parcMemory_Outstanding());
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-// ------
-typedef struct test_ringbuffer {
-    unsigned itemsToWrite;
-    volatile unsigned itemsWritten;
-    volatile unsigned itemsRead;
-    volatile bool blocked;
-
-    PARCRingBuffer1x1 *producerBuffer;
-    PARCRingBuffer1x1 *consumerBuffer;
-
-    pthread_t producerThread;
-    pthread_t consumerThread;
-} TestRingBuffer;
-
-
-void *
-consumer(void *p)
-{
-    TestRingBuffer *trb = (TestRingBuffer *) p;
-
-    while (trb->blocked) {
-        // nothing to do.
-    }
-
-    while (trb->itemsRead < trb->itemsToWrite) {
-        uint32_t *data;
-        bool success = parcRingBuffer1x1_Get(trb->consumerBuffer, (void **) &data);
-        if (success) {
-            assertTrue(*data == trb->itemsRead, "Got out of order item %u expected %u\n", *data, trb->itemsRead);
-            parcMemory_Deallocate((void **) &data);
-            trb->itemsRead++;
-        }
-    }
-
-    pthread_exit((void *) NULL);
-}
-
-void *
-producer(void *p)
-{
-    TestRingBuffer *trb = (TestRingBuffer *) p;
-
-    while (trb->blocked) {
-        // nothing to do
-    }
-
-    while (trb->itemsWritten < trb->itemsToWrite) {
-        uint32_t *data = parcMemory_Allocate(sizeof(uint32_t));
-        assertNotNull(data, "parcMemory_Allocate(%zu) returned NULL", sizeof(uint32_t));
-        *data = trb->itemsWritten;
-
-        bool success = false;
-        do {
-            success = parcRingBuffer1x1_Put(trb->producerBuffer, data);
-        } while (!success);
-        trb->itemsWritten++;
-    }
-
-    pthread_exit((void *) NULL);
-}
-
-LONGBOW_TEST_CASE(Global, parcRingBuffer1x1_Acquire)
-{
-    testUnimplemented("");
-}
-
-LONGBOW_TEST_CASE_EXPECTS(Global, parcRingBuffer1x1_Create_NonPower2, .event = &LongBowAssertEvent)
-{
-    // this will assert because the number of elements is not a power of 2
-    parcRingBuffer1x1_Create(3, NULL);
-}
-
-LONGBOW_TEST_CASE(Global, parcRingBuffer1x1_Create_Release)
-{
-    PARCRingBuffer1x1 *ring = parcRingBuffer1x1_Create(1024, NULL);
-    parcRingBuffer1x1_Release(&ring);
-    assertTrue(parcMemory_Outstanding() == 0, "Non-zero memory balance: %u", parcMemory_Outstanding());
-
-    printf("ring buffer entry size: %zu\n", sizeof(PARCRingBuffer1x1));
-}
-
-LONGBOW_TEST_CASE(Global, parcRingBuffer1x1_Get_Put)
-{
-    TestRingBuffer *trb = parcMemory_AllocateAndClear(sizeof(TestRingBuffer));
-    assertNotNull(trb, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(TestRingBuffer));
-    trb->producerBuffer = parcRingBuffer1x1_Create(128, NULL);
-    trb->consumerBuffer = parcRingBuffer1x1_Acquire(trb->producerBuffer);
-
-    trb->itemsToWrite = 100000;
-    trb->blocked = true;
-
-    pthread_create(&trb->consumerThread, NULL, consumer, trb);
-    pthread_create(&trb->producerThread, NULL, producer, trb);
-
-    struct timeval t0, t1;
-
-    gettimeofday(&t0, NULL);
-    trb->blocked = false;
-
-    // wait for them to exit
-    pthread_join(trb->producerThread, NULL);
-    pthread_join(trb->consumerThread, NULL);
-    gettimeofday(&t1, NULL);
-
-    timersub(&t1, &t0, &t1);
-
-    assertTrue(trb->itemsWritten == trb->itemsToWrite,
-               "Did not write all items got %u expected %u\n",
-               trb->itemsWritten,
-               trb->itemsToWrite);
-
-    assertTrue(trb->itemsRead == trb->itemsToWrite,
-               "Did not read all items got %u expected %u\n",
-               trb->itemsRead,
-               trb->itemsToWrite);
-
-    double sec = t1.tv_sec + t1.tv_usec * 1E-6;
-
-    printf("Passed %u items in %.6f seconds, %.2f items/sec\n",
-           trb->itemsWritten,
-           sec,
-           trb->itemsWritten / sec);
-
-    parcRingBuffer1x1_Release(&trb->consumerBuffer);
-    parcRingBuffer1x1_Release(&trb->producerBuffer);
-    parcMemory_Deallocate((void **) &trb);
-}
-
-LONGBOW_TEST_CASE(Global, parcRingBuffer1x1_Remaining_Empty)
-{
-    uint32_t capacity = 128;
-    PARCRingBuffer1x1 *ring = parcRingBuffer1x1_Create(capacity, NULL);
-    uint32_t remaining = parcRingBuffer1x1_Remaining(ring);
-    parcRingBuffer1x1_Release(&ring);
-
-    // -1 because the ring buffer is always -1
-    assertTrue(remaining == capacity - 1, "Got wrong remaining, got %u expecting %u\n", remaining, capacity);
-}
-
-LONGBOW_TEST_CASE(Global, parcRingBuffer1x1_Remaining_Half)
-{
-    uint32_t capacity = 128;
-    PARCRingBuffer1x1 *ring = parcRingBuffer1x1_Create(capacity, NULL);
-    for (int i = 0; i < capacity / 2; i++) {
-        parcRingBuffer1x1_Put(ring, &i);
-    }
-
-    uint32_t remaining = parcRingBuffer1x1_Remaining(ring);
-    parcRingBuffer1x1_Release(&ring);
-
-    // -1 because the ring buffer is always -1
-    assertTrue(remaining == capacity / 2 - 1, "Got wrong remaining, got %u expecting %u\n", remaining, capacity / 2 - 1);
-}
-
-LONGBOW_TEST_CASE(Global, parcRingBuffer1x1_Remaining_Full)
-{
-    uint32_t capacity = 128;
-    PARCRingBuffer1x1 *ring = parcRingBuffer1x1_Create(capacity, NULL);
-    for (int i = 0; i < capacity - 1; i++) {
-        parcRingBuffer1x1_Put(ring, &i);
-    }
-
-    uint32_t remaining = parcRingBuffer1x1_Remaining(ring);
-    parcRingBuffer1x1_Release(&ring);
-
-    assertTrue(remaining == 0, "Got wrong remaining, got %u expecting %u\n", remaining, 0);
-}
-
-LONGBOW_TEST_CASE(Global, parcRingBuffer1x1_Put_ToCapacity)
-{
-    uint32_t capacity = 128;
-    PARCRingBuffer1x1 *ring = parcRingBuffer1x1_Create(capacity, NULL);
-    for (int i = 0; i < capacity - 1; i++) {
-        parcRingBuffer1x1_Put(ring, &i);
-    }
-
-    // this next put should fail
-    bool success = parcRingBuffer1x1_Put(ring, &capacity);
-
-    parcRingBuffer1x1_Release(&ring);
-
-    assertFalse(success, "Should have failed on final put because data structure is full\n");
-}
-
-LONGBOW_TEST_FIXTURE(Local)
-{
-    LONGBOW_RUN_TEST_CASE(Local, _create);
-    LONGBOW_RUN_TEST_CASE(Local, _destroy);
-    LONGBOW_RUN_TEST_CASE(Local, _isPowerOfTwo);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Local)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Local)
-{
-    if (parcSafeMemory_ReportAllocation(STDOUT_FILENO) != 0) {
-        printf("('%s' leaks memory by %d (allocs - frees)) ", longBowTestCase_GetName(testCase), parcMemory_Outstanding());
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_CASE(Local, _create)
-{
-    testUnimplemented("");
-}
-
-static void
-_testDestoryer(void **ptr)
-{
-    parcBuffer_Release((PARCBuffer **) ptr);
-}
-
-LONGBOW_TEST_CASE(Local, _destroy)
-{
-    // put something in the ring and don't remove it.  Make sure the destroyer catches it.
-
-    uint32_t capacity = 128;
-    PARCRingBuffer1x1 *ring = parcRingBuffer1x1_Create(capacity, _testDestoryer);
-
-    PARCBuffer *buffer = parcBuffer_Allocate(5);
-    parcRingBuffer1x1_Put(ring, buffer);
-
-    parcRingBuffer1x1_Release(&ring);
-    assertTrue(parcMemory_Outstanding() == 0, "Memory imbalance, expected 0 got %u", parcMemory_Outstanding());
-}
-
-LONGBOW_TEST_CASE(Local, _isPowerOfTwo)
-{
-    struct test_struct {
-        uint32_t value;
-        bool isPow2;
-    } test_vector[] = { { 0, false }, { 1, true }, { 2, true }, { 15, false }, { 16, true }, { 32, true }, { UINT32_MAX, true } };
-
-    for (int i = 0; test_vector[i].value != UINT32_MAX; i++) {
-        bool test = _isPowerOfTwo(test_vector[i].value);
-        assertTrue(test == test_vector[i].isPow2, "Got wrong result for value %u, got %d expected %d\n", test_vector[i].value, test, test_vector[i].isPow2);
-    }
-}
-
-int
-main(int argc, char *argv[])
-{
-    LongBowRunner *testRunner = LONGBOW_TEST_RUNNER_CREATE(parc_RingBuffer_1x1);
-    int exitStatus = LONGBOW_TEST_MAIN(argc, argv, testRunner);
-    longBowTestRunner_Destroy(&testRunner);
-    exit(exitStatus);
-}
diff --git a/libparc/parc/concurrent/test/test_parc_RingBuffer_NxM.c b/libparc/parc/concurrent/test/test_parc_RingBuffer_NxM.c
deleted file mode 100755
index 974da053..00000000
--- a/libparc/parc/concurrent/test/test_parc_RingBuffer_NxM.c
+++ /dev/null
@@ -1,106 +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 the file(s) containing the functions to be tested.
-// This permits internal static functions to be visible to this Test Framework.
-#include "../parc_RingBuffer_NxM.c"
-
-#include <parc/algol/parc_SafeMemory.h>
-#include <LongBow/unit-test.h>
-
-LONGBOW_TEST_RUNNER(parc_RingBuffer_NxM)
-{
-    // 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(Local);
-}
-
-// The Test Runner calls this function once before any Test Fixtures are run.
-LONGBOW_TEST_RUNNER_SETUP(parc_RingBuffer_NxM)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-// The Test Runner calls this function once after all the Test Fixtures are run.
-LONGBOW_TEST_RUNNER_TEARDOWN(parc_RingBuffer_NxM)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE(Global)
-{
-}
-
-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("Tests leak memory by %d allocations\n", outstandingAllocations);
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE(Local)
-{
-    LONGBOW_RUN_TEST_CASE(Local, _destroy);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Local)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Local)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-static void
-_testDestoryer(void **ptr)
-{
-    parcBuffer_Release((PARCBuffer **) ptr);
-}
-
-LONGBOW_TEST_CASE(Local, _destroy)
-{
-    // put something in the ring and don't remove it.  Make sure the destroyer catches it.
-
-    uint32_t capacity = 128;
-    PARCRingBufferNxM *ring = parcRingBufferNxM_Create(capacity, _testDestoryer);
-
-    PARCBuffer *buffer = parcBuffer_Allocate(5);
-    parcRingBufferNxM_Put(ring, buffer);
-
-    parcRingBufferNxM_Release(&ring);
-    assertTrue(parcMemory_Outstanding() == 0, "Memory imbalance, expected 0 got %u", parcMemory_Outstanding());
-}
-
-int
-main(int argc, char *argv[])
-{
-    LongBowRunner *testRunner = LONGBOW_TEST_RUNNER_CREATE(parc_RingBuffer_NxM);
-    int exitStatus = LONGBOW_TEST_MAIN(argc, argv, testRunner);
-    longBowTestRunner_Destroy(&testRunner);
-    exit(exitStatus);
-}
diff --git a/libparc/parc/concurrent/test/test_parc_ScheduledTask.c b/libparc/parc/concurrent/test/test_parc_ScheduledTask.c
deleted file mode 100644
index 3655be93..00000000
--- a/libparc/parc/concurrent/test/test_parc_ScheduledTask.c
+++ /dev/null
@@ -1,244 +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_ScheduledTask.c"
-
-#include <LongBow/testing.h>
-#include <LongBow/debugging.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_SafeMemory.h>
-#include <parc/algol/parc_DisplayIndented.h>
-
-#include <parc/testing/parc_MemoryTesting.h>
-#include <parc/testing/parc_ObjectTesting.h>
-
-LONGBOW_TEST_RUNNER(parc_ScheduledTask)
-{
-    // 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(Object);
-    LONGBOW_RUN_TEST_FIXTURE(Specialization);
-}
-
-// The Test Runner calls this function once before any Test Fixtures are run.
-LONGBOW_TEST_RUNNER_SETUP(parc_ScheduledTask)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-// The Test Runner calls this function once after all the Test Fixtures are run.
-LONGBOW_TEST_RUNNER_TEARDOWN(parc_ScheduledTask)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE(CreateAcquireRelease)
-{
-    LONGBOW_RUN_TEST_CASE(CreateAcquireRelease, CreateRelease);
-}
-
-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;
-}
-
-void *
-_function(PARCFutureTask *task, void *parameter)
-{
-    return parameter;
-}
-
-LONGBOW_TEST_CASE(CreateAcquireRelease, CreateRelease)
-{
-    PARCFutureTask *task = parcFutureTask_Create(_function, _function);
-
-    PARCScheduledTask *instance = parcScheduledTask_Create(task, 0);
-    assertNotNull(instance, "Expected non-null result from parcScheduledTask_Create();");
-
-    parcObjectTesting_AssertAcquireReleaseContract(parcScheduledTask_Acquire, instance);
-
-    parcScheduledTask_Release(&instance);
-    assertNull(instance, "Expected null result from parcScheduledTask_Release();");
-    parcFutureTask_Release(&task);
-}
-
-LONGBOW_TEST_FIXTURE(Object)
-{
-    LONGBOW_RUN_TEST_CASE(Object, parcScheduledTask_Compare);
-    LONGBOW_RUN_TEST_CASE(Object, parcScheduledTask_Copy);
-    LONGBOW_RUN_TEST_CASE(Object, parcScheduledTask_Display);
-    LONGBOW_RUN_TEST_CASE(Object, parcScheduledTask_Equals);
-    LONGBOW_RUN_TEST_CASE(Object, parcScheduledTask_HashCode);
-    LONGBOW_RUN_TEST_CASE(Object, parcScheduledTask_IsValid);
-    LONGBOW_RUN_TEST_CASE(Object, parcScheduledTask_ToJSON);
-    LONGBOW_RUN_TEST_CASE(Object, parcScheduledTask_ToString);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Object)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Object)
-{
-    if (!parcMemoryTesting_ExpectedOutstanding(0, "%s mismanaged memory.", longBowTestCase_GetFullName(testCase))) {
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_CASE(Object, parcScheduledTask_Compare)
-{
-    testUnimplemented("");
-}
-
-LONGBOW_TEST_CASE(Object, parcScheduledTask_Copy)
-{
-    PARCFutureTask *task = parcFutureTask_Create(_function, _function);
-
-    PARCScheduledTask *instance = parcScheduledTask_Create(task, 0);
-    PARCScheduledTask *copy = parcScheduledTask_Copy(instance);
-    assertTrue(parcScheduledTask_Equals(instance, copy), "Expected the copy to be equal to the original");
-
-    parcScheduledTask_Release(&instance);
-    parcScheduledTask_Release(&copy);
-    parcFutureTask_Release(&task);
-}
-
-LONGBOW_TEST_CASE(Object, parcScheduledTask_Display)
-{
-    PARCFutureTask *task = parcFutureTask_Create(_function, _function);
-
-    PARCScheduledTask *instance = parcScheduledTask_Create(task, 0);
-    parcScheduledTask_Display(instance, 0);
-    parcScheduledTask_Release(&instance);
-    parcFutureTask_Release(&task);
-}
-
-LONGBOW_TEST_CASE(Object, parcScheduledTask_Equals)
-{
-    PARCFutureTask *task = parcFutureTask_Create(_function, _function);
-
-    PARCScheduledTask *x = parcScheduledTask_Create(task, 0);
-    PARCScheduledTask *y = parcScheduledTask_Create(task, 0);
-    PARCScheduledTask *z = parcScheduledTask_Create(task, 0);
-
-    parcObjectTesting_AssertEquals(x, y, z, NULL);
-
-    parcScheduledTask_Release(&x);
-    parcScheduledTask_Release(&y);
-    parcScheduledTask_Release(&z);
-    parcFutureTask_Release(&task);
-}
-
-LONGBOW_TEST_CASE(Object, parcScheduledTask_HashCode)
-{
-    PARCFutureTask *task = parcFutureTask_Create(_function, _function);
-
-    PARCScheduledTask *x = parcScheduledTask_Create(task, 0);
-    PARCScheduledTask *y = parcScheduledTask_Create(task, 0);
-
-    parcObjectTesting_AssertHashCode(x, y);
-
-    parcScheduledTask_Release(&x);
-    parcScheduledTask_Release(&y);
-    parcFutureTask_Release(&task);
-}
-
-LONGBOW_TEST_CASE(Object, parcScheduledTask_IsValid)
-{
-    PARCFutureTask *task = parcFutureTask_Create(_function, _function);
-
-    PARCScheduledTask *instance = parcScheduledTask_Create(task, 0);
-    assertTrue(parcScheduledTask_IsValid(instance), "Expected parcScheduledTask_Create to result in a valid instance.");
-
-    parcScheduledTask_Release(&instance);
-    assertFalse(parcScheduledTask_IsValid(instance), "Expected parcScheduledTask_Release to result in an invalid instance.");
-
-    parcFutureTask_Release(&task);
-}
-
-LONGBOW_TEST_CASE(Object, parcScheduledTask_ToJSON)
-{
-    PARCFutureTask *task = parcFutureTask_Create(_function, _function);
-
-    PARCScheduledTask *instance = parcScheduledTask_Create(task, 0);
-
-    PARCJSON *json = parcScheduledTask_ToJSON(instance);
-
-    parcJSON_Release(&json);
-
-    parcScheduledTask_Release(&instance);
-    parcFutureTask_Release(&task);
-}
-
-LONGBOW_TEST_CASE(Object, parcScheduledTask_ToString)
-{
-    PARCFutureTask *task = parcFutureTask_Create(_function, _function);
-
-    PARCScheduledTask *instance = parcScheduledTask_Create(task, 0);
-
-    char *string = parcScheduledTask_ToString(instance);
-
-    assertNotNull(string, "Expected non-NULL result from parcScheduledTask_ToString");
-
-    parcMemory_Deallocate((void **) &string);
-    parcScheduledTask_Release(&instance);
-    parcFutureTask_Release(&task);
-}
-
-LONGBOW_TEST_FIXTURE(Specialization)
-{
-}
-
-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;
-}
-
-int
-main(int argc, char *argv[argc])
-{
-    LongBowRunner *testRunner = LONGBOW_TEST_RUNNER_CREATE(parc_ScheduledTask);
-    int exitStatus = longBowMain(argc, argv, testRunner, NULL);
-    longBowTestRunner_Destroy(&testRunner);
-    exit(exitStatus);
-}
-
-
diff --git a/libparc/parc/concurrent/test/test_parc_ScheduledThreadPool.c b/libparc/parc/concurrent/test/test_parc_ScheduledThreadPool.c
deleted file mode 100644
index e2e2473c..00000000
--- a/libparc/parc/concurrent/test/test_parc_ScheduledThreadPool.c
+++ /dev/null
@@ -1,301 +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_ScheduledThreadPool.c"
-
-#include <LongBow/testing.h>
-#include <LongBow/debugging.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_SafeMemory.h>
-#include <parc/algol/parc_DisplayIndented.h>
-
-#include <parc/testing/parc_MemoryTesting.h>
-#include <parc/testing/parc_ObjectTesting.h>
-
-LONGBOW_TEST_RUNNER(parc_ScheduledThreadPool)
-{
-    // 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(Object);
-    LONGBOW_RUN_TEST_FIXTURE(Specialization);
-}
-
-// The Test Runner calls this function once before any Test Fixtures are run.
-LONGBOW_TEST_RUNNER_SETUP(parc_ScheduledThreadPool)
-{
-    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_ScheduledThreadPool)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE(CreateAcquireRelease)
-{
-    LONGBOW_RUN_TEST_CASE(CreateAcquireRelease, CreateRelease);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(CreateAcquireRelease)
-{
-    longBowTestCase_SetInt(testCase, "initalAllocations", parcMemory_Outstanding());
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(CreateAcquireRelease)
-{
-    int initialAllocations = longBowTestCase_GetInt(testCase, "initalAllocations");
-    if (!parcMemoryTesting_ExpectedOutstanding(initialAllocations, "%s leaked memory.", longBowTestCase_GetFullName(testCase))) {
-        parcSafeMemory_ReportAllocation(1);
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_CASE(CreateAcquireRelease, CreateRelease)
-{
-    PARCScheduledThreadPool *instance = parcScheduledThreadPool_Create(3);
-    assertNotNull(instance, "Expected non-null result from parcScheduledThreadPool_Create();");
-
-    parcObjectTesting_AssertAcquireReleaseContract(parcScheduledThreadPool_Acquire, instance);
-    parcScheduledThreadPool_ShutdownNow(instance);
-
-    assertTrue(parcObject_GetReferenceCount(instance) == 1, "Expected 1 reference count. Actual %lu", parcObject_GetReferenceCount(instance));
-
-    parcScheduledThreadPool_Release(&instance);
-    assertNull(instance, "Expected null result from parcScheduledThreadPool_Release();");
-}
-
-LONGBOW_TEST_FIXTURE(Object)
-{
-    LONGBOW_RUN_TEST_CASE(Object, parcScheduledThreadPool_Compare);
-    LONGBOW_RUN_TEST_CASE(Object, parcScheduledThreadPool_Copy);
-    LONGBOW_RUN_TEST_CASE(Object, parcScheduledThreadPool_Display);
-    LONGBOW_RUN_TEST_CASE(Object, parcScheduledThreadPool_Equals);
-    LONGBOW_RUN_TEST_CASE(Object, parcScheduledThreadPool_HashCode);
-    LONGBOW_RUN_TEST_CASE(Object, parcScheduledThreadPool_IsValid);
-    LONGBOW_RUN_TEST_CASE(Object, parcScheduledThreadPool_ToJSON);
-    LONGBOW_RUN_TEST_CASE(Object, parcScheduledThreadPool_ToString);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Object)
-{
-    longBowTestCase_SetInt(testCase, "initalAllocations", parcMemory_Outstanding());
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Object)
-{
-    int initialAllocations = longBowTestCase_GetInt(testCase, "initalAllocations");
-    if (!parcMemoryTesting_ExpectedOutstanding(initialAllocations, "%s leaked memory.", longBowTestCase_GetFullName(testCase))) {
-        parcSafeMemory_ReportAllocation(1);
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_CASE(Object, parcScheduledThreadPool_Compare)
-{
-    testUnimplemented("");
-}
-
-LONGBOW_TEST_CASE(Object, parcScheduledThreadPool_Copy)
-{
-    PARCScheduledThreadPool *instance = parcScheduledThreadPool_Create(3);
-    PARCScheduledThreadPool *copy = parcScheduledThreadPool_Copy(instance);
-    assertTrue(parcScheduledThreadPool_Equals(instance, copy), "Expected the copy to be equal to the original");
-
-    parcScheduledThreadPool_ShutdownNow(instance);
-    parcScheduledThreadPool_ShutdownNow(copy);
-
-    parcScheduledThreadPool_Release(&instance);
-    parcScheduledThreadPool_Release(&copy);
-}
-
-LONGBOW_TEST_CASE(Object, parcScheduledThreadPool_Display)
-{
-    PARCScheduledThreadPool *instance = parcScheduledThreadPool_Create(2);
-    parcScheduledThreadPool_Display(instance, 0);
-    parcScheduledThreadPool_ShutdownNow(instance);
-    parcScheduledThreadPool_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Object, parcScheduledThreadPool_Equals)
-{
-    PARCScheduledThreadPool *x = parcScheduledThreadPool_Create(2);
-    PARCScheduledThreadPool *y = parcScheduledThreadPool_Create(2);
-    PARCScheduledThreadPool *z = parcScheduledThreadPool_Create(2);
-    PARCScheduledThreadPool *u1 = parcScheduledThreadPool_Create(3);
-
-    parcObjectTesting_AssertEquals(x, y, z, u1, NULL);
-
-    parcScheduledThreadPool_ShutdownNow(x);
-    parcScheduledThreadPool_ShutdownNow(y);
-    parcScheduledThreadPool_ShutdownNow(z);
-    parcScheduledThreadPool_ShutdownNow(u1);
-
-    parcScheduledThreadPool_Release(&x);
-    parcScheduledThreadPool_Release(&y);
-    parcScheduledThreadPool_Release(&z);
-    parcScheduledThreadPool_Release(&u1);
-}
-
-LONGBOW_TEST_CASE(Object, parcScheduledThreadPool_HashCode)
-{
-    PARCScheduledThreadPool *x = parcScheduledThreadPool_Create(2);
-    PARCScheduledThreadPool *y = parcScheduledThreadPool_Create(2);
-
-    parcObjectTesting_AssertHashCode(x, y);
-
-    parcScheduledThreadPool_ShutdownNow(x);
-    parcScheduledThreadPool_ShutdownNow(y);
-
-    parcScheduledThreadPool_Release(&x);
-    parcScheduledThreadPool_Release(&y);
-}
-
-LONGBOW_TEST_CASE(Object, parcScheduledThreadPool_IsValid)
-{
-    PARCScheduledThreadPool *instance = parcScheduledThreadPool_Create(2);
-    assertTrue(parcScheduledThreadPool_IsValid(instance), "Expected parcScheduledThreadPool_Create to result in a valid instance.");
-
-    parcScheduledThreadPool_ShutdownNow(instance);
-
-    parcScheduledThreadPool_Release(&instance);
-    assertFalse(parcScheduledThreadPool_IsValid(instance), "Expected parcScheduledThreadPool_Release to result in an invalid instance.");
-}
-
-LONGBOW_TEST_CASE(Object, parcScheduledThreadPool_ToJSON)
-{
-    PARCScheduledThreadPool *instance = parcScheduledThreadPool_Create(2);
-
-    PARCJSON *json = parcScheduledThreadPool_ToJSON(instance);
-
-    parcJSON_Release(&json);
-
-    parcScheduledThreadPool_ShutdownNow(instance);
-    parcScheduledThreadPool_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Object, parcScheduledThreadPool_ToString)
-{
-    PARCScheduledThreadPool *instance = parcScheduledThreadPool_Create(2);
-
-    char *string = parcScheduledThreadPool_ToString(instance);
-
-    assertNotNull(string, "Expected non-NULL result from parcScheduledThreadPool_ToString");
-
-    parcMemory_Deallocate((void **) &string);
-    parcScheduledThreadPool_ShutdownNow(instance);
-    parcScheduledThreadPool_Release(&instance);
-}
-
-LONGBOW_TEST_FIXTURE(Specialization)
-{
-    LONGBOW_RUN_TEST_CASE(Specialization, OneJob);
-    LONGBOW_RUN_TEST_CASE(Specialization, Idle);
-    LONGBOW_RUN_TEST_CASE(Specialization, parcScheduledThreadPool_Schedule);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Specialization)
-{
-    longBowTestCase_SetInt(testCase, "initalAllocations", parcMemory_Outstanding());
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Specialization)
-{
-    int initialAllocations = longBowTestCase_GetInt(testCase, "initalAllocations");
-    if (!parcMemoryTesting_ExpectedOutstanding(initialAllocations, "%s leaked memory.", longBowTestCase_GetFullName(testCase))) {
-        parcSafeMemory_ReportAllocation(1);
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_CASE(Specialization, Idle)
-{
-    PARCScheduledThreadPool *pool = parcScheduledThreadPool_Create(3);
-
-    sleep(2);
-
-    parcScheduledThreadPool_ShutdownNow(pool);
-
-    parcScheduledThreadPool_Release(&pool);
-}
-
-static void *
-_function(PARCFutureTask *task, void *parameter)
-{
-    printf("Hello World\n");
-    return parameter;
-}
-
-LONGBOW_TEST_CASE(Specialization, OneJob)
-{
-    PARCScheduledThreadPool *pool = parcScheduledThreadPool_Create(3);
-
-    PARCFutureTask *task = parcFutureTask_Create(_function, _function);
-
-    parcScheduledThreadPool_Schedule(pool, task, parcTimeout_MilliSeconds(2000));
-    printf("references %lu\n", parcObject_GetReferenceCount(task));
-    parcFutureTask_Release(&task);
-
-    sleep(5);
-
-    parcScheduledThreadPool_ShutdownNow(pool);
-
-    parcScheduledThreadPool_Release(&pool);
-}
-
-LONGBOW_TEST_CASE(Specialization, parcScheduledThreadPool_Schedule)
-{
-    PARCScheduledThreadPool *pool = parcScheduledThreadPool_Create(3);
-
-    PARCFutureTask *task = parcFutureTask_Create(_function, _function);
-
-    parcScheduledThreadPool_Schedule(pool, task, parcTimeout_MilliSeconds(2000));
-
-    parcFutureTask_Release(&task);
-
-    parcScheduledThreadPool_Shutdown(pool);
-//    parcScheduledThreadPool_AwaitTermination(pool, PARCTimeout_Never);
-
-//    uint64_t count = parcScheduledThreadPool_GetCompletedTaskCount(pool);
-//    assertTrue(count == 5, "Expected 5, actual %lld", count);
-
-    parcScheduledThreadPool_ShutdownNow(pool);
-
-    parcScheduledThreadPool_Release(&pool);
-}
-
-int
-main(int argc, char *argv[argc])
-{
-    LongBowRunner *testRunner = LONGBOW_TEST_RUNNER_CREATE(parc_ScheduledThreadPool);
-    int exitStatus = longBowMain(argc, argv, testRunner, NULL);
-    longBowTestRunner_Destroy(&testRunner);
-    exit(exitStatus);
-}
diff --git a/libparc/parc/concurrent/test/test_parc_Synchronizer.c b/libparc/parc/concurrent/test/test_parc_Synchronizer.c
deleted file mode 100755
index 34d9c711..00000000
--- a/libparc/parc/concurrent/test/test_parc_Synchronizer.c
+++ /dev/null
@@ -1,179 +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_Synchronizer.c"
-
-#include <LongBow/testing.h>
-#include <LongBow/debugging.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_SafeMemory.h>
-#include <parc/testing/parc_MemoryTesting.h>
-#include <parc/testing/parc_ObjectTesting.h>
-
-LONGBOW_TEST_RUNNER(parc_Synchronizer)
-{
-    // 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);
-}
-
-// The Test Runner calls this function once before any Test Fixtures are run.
-LONGBOW_TEST_RUNNER_SETUP(parc_Synchronizer)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-// The Test Runner calls this function once after all the Test Fixtures are run.
-LONGBOW_TEST_RUNNER_TEARDOWN(parc_Synchronizer)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE(CreateAcquireRelease)
-{
-    LONGBOW_RUN_TEST_CASE(CreateAcquireRelease, CreateRelease);
-}
-
-
-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)
-{
-    PARCSynchronizer *instance = parcSynchronizer_Create();
-    assertNotNull(instance, "Expeced non-null result from parcSynchronizer_Create();");
-
-    parcObjectTesting_AssertAcquireReleaseContract(parcSynchronizer_Acquire, instance);
-
-    parcSynchronizer_Release(&instance);
-    assertNull(instance, "Expeced null result from parcSynchronizer_Release();");
-}
-
-LONGBOW_TEST_FIXTURE(Global)
-{
-    LONGBOW_RUN_TEST_CASE(Global, parcSynchronizer_Display);
-    LONGBOW_RUN_TEST_CASE(Global, parcSynchronizer_IsValid);
-
-    LONGBOW_RUN_TEST_CASE(Global, parcSynchronizer_TryLock);
-    LONGBOW_RUN_TEST_CASE(Global, parcSynchronizer_LockUnlock);
-    LONGBOW_RUN_TEST_CASE(Global, parcSynchronizer_TryLock_Fail);
-    LONGBOW_RUN_TEST_CASE(Global, parcSynchronizer_IsLocked);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Global)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Global)
-{
-    if (!parcMemoryTesting_ExpectedOutstanding(0, "%s leaked memory.", longBowTestCase_GetFullName(testCase))) {
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_CASE(Global, parcSynchronizer_Display)
-{
-    PARCSynchronizer *instance = parcSynchronizer_Create();
-    assertTrue(parcSynchronizer_IsValid(instance), "Expected parcSynchronizer_Create to result in a valid instance.");
-
-    parcSynchronizer_Display(instance, 0);
-    parcSynchronizer_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Global, parcSynchronizer_IsValid)
-{
-    PARCSynchronizer *instance = parcSynchronizer_Create();
-    assertTrue(parcSynchronizer_IsValid(instance), "Expected parcSynchronizer_Create to result in a valid instance.");
-
-    parcSynchronizer_Release(&instance);
-    assertFalse(parcSynchronizer_IsValid(instance), "Expected parcSynchronizer_Create to result in an invalid instance.");
-}
-
-LONGBOW_TEST_CASE(Global, parcSynchronizer_TryLock)
-{
-    PARCSynchronizer *instance = parcSynchronizer_Create();
-
-    bool actual = parcSynchronizer_TryLock(instance);
-    assertTrue(actual, "Expected parcSynchronizer_TryLock to be successful.");
-
-    parcSynchronizer_Unlock(instance);
-    parcSynchronizer_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Global, parcSynchronizer_TryLock_Fail)
-{
-    PARCSynchronizer *instance = parcSynchronizer_Create();
-
-    parcSynchronizer_Lock(instance);
-    bool actual = parcSynchronizer_TryLock(instance);
-    assertFalse(actual, "Expected parcSynchronizer_TryLock to be unsuccessful.");
-
-    parcSynchronizer_Unlock(instance);
-    parcSynchronizer_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Global, parcSynchronizer_LockUnlock)
-{
-    PARCSynchronizer *instance = parcSynchronizer_Create();
-
-    parcSynchronizer_Lock(instance);
-    parcSynchronizer_Unlock(instance);
-
-    parcSynchronizer_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Global, parcSynchronizer_IsLocked)
-{
-    PARCSynchronizer *instance = parcSynchronizer_Create();
-    assertFalse(parcSynchronizer_IsLocked(instance), "Expected the synchronizer to be unlocked.");
-
-    parcSynchronizer_Lock(instance);
-    assertTrue(parcSynchronizer_IsLocked(instance), "Expected the synchronizer to be unlocked.");
-
-    parcSynchronizer_Unlock(instance);
-    assertFalse(parcSynchronizer_IsLocked(instance), "Expected the synchronizer to be unlocked.");
-
-    parcSynchronizer_Release(&instance);
-}
-
-int
-main(int argc, char *argv[argc])
-{
-    LongBowRunner *testRunner = LONGBOW_TEST_RUNNER_CREATE(parc_Synchronizer);
-    int exitStatus = longBowMain(argc, argv, testRunner, NULL);
-    longBowTestRunner_Destroy(&testRunner);
-    exit(exitStatus);
-}
-
-
diff --git a/libparc/parc/concurrent/test/test_parc_Thread.c b/libparc/parc/concurrent/test/test_parc_Thread.c
deleted file mode 100644
index 679f58d0..00000000
--- a/libparc/parc/concurrent/test/test_parc_Thread.c
+++ /dev/null
@@ -1,279 +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_ThreadPool.c"
-
-#include <stdio.h>
-
-#include <LongBow/testing.h>
-#include <LongBow/debugging.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_SafeMemory.h>
-#include <parc/algol/parc_DisplayIndented.h>
-
-#include <parc/testing/parc_MemoryTesting.h>
-#include <parc/testing/parc_ObjectTesting.h>
-
-LONGBOW_TEST_RUNNER(parc_Thread)
-{
-    // 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(Object);
-    LONGBOW_RUN_TEST_FIXTURE(Specialization);
-}
-
-// The Test Runner calls this function once before any Test Fixtures are run.
-LONGBOW_TEST_RUNNER_SETUP(parc_Thread)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-// The Test Runner calls this function once after all the Test Fixtures are run.
-LONGBOW_TEST_RUNNER_TEARDOWN(parc_Thread)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE(CreateAcquireRelease)
-{
-    LONGBOW_RUN_TEST_CASE(CreateAcquireRelease, CreateRelease);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(CreateAcquireRelease)
-{
-    longBowTestCase_SetInt(testCase, "initialAllocations", parcMemory_Outstanding());
-
-    PARCBuffer *buffer = parcBuffer_Allocate(10);
-    longBowTestCase_Set(testCase, "object", buffer);
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(CreateAcquireRelease)
-{
-    PARCBuffer *buffer = longBowTestCase_Get(testCase, "object");
-    parcBuffer_Release(&buffer);
-
-#if INTPTR_MAX == INT32_MAX
-    uint32_t initialAllocations = (uint32_t) longBowTestCase_Get(testCase, "initialAllocations");
-#else
-    uint64_t initialAllocations = (uint64_t) longBowTestCase_Get(testCase, "initialAllocations");
-#endif
-
-    if (!parcMemoryTesting_ExpectedOutstanding(initialAllocations, "%s leaked memory.", longBowTestCase_GetFullName(testCase))) {
-        parcSafeMemory_ReportAllocation(1);
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-static void *
-_function(PARCThread *thread, void *parameter)
-{
-    return NULL;
-}
-
-LONGBOW_TEST_CASE(CreateAcquireRelease, CreateRelease)
-{
-    PARCBuffer *buffer = longBowTestCase_Get(testCase, "object");
-    PARCThread *thread = parcThread_Create(_function, buffer);
-
-    assertNotNull(thread, "Expected non-null result from parcThread_Create();");
-
-    parcObjectTesting_AssertAcquireReleaseContract(parcThread_Acquire, thread);
-
-    parcThread_Release(&thread);
-    assertNull(thread, "Expected null result from parcThread_Release();");
-}
-
-LONGBOW_TEST_FIXTURE(Object)
-{
-    LONGBOW_RUN_TEST_CASE(Object, parcThread_Compare);
-    LONGBOW_RUN_TEST_CASE(Object, parcThread_Copy);
-    LONGBOW_RUN_TEST_CASE(Object, parcThread_Display);
-    LONGBOW_RUN_TEST_CASE(Object, parcThread_Equals);
-    LONGBOW_RUN_TEST_CASE(Object, parcThread_HashCode);
-    LONGBOW_RUN_TEST_CASE(Object, parcThread_IsValid);
-    LONGBOW_RUN_TEST_CASE(Object, parcThread_ToJSON);
-    LONGBOW_RUN_TEST_CASE(Object, parcThread_ToString);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Object)
-{
-    longBowTestCase_SetInt(testCase, "initialAllocations", parcMemory_Outstanding());
-    PARCBuffer *buffer = parcBuffer_Allocate(10);
-    longBowTestCase_Set(testCase, "object", buffer);
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Object)
-{
-    PARCBuffer *buffer = longBowTestCase_Get(testCase, "object");
-    parcBuffer_Release(&buffer);
-
-#if INTPTR_MAX == INT32_MAX
-    uint32_t initialAllocations = (uint32_t) longBowTestCase_Get(testCase, "initialAllocations");
-#else
-    uint64_t initialAllocations = (uint64_t) longBowTestCase_Get(testCase, "initialAllocations");
-#endif
-
-    if (!parcMemoryTesting_ExpectedOutstanding(initialAllocations, "%s leaked memory.", longBowTestCase_GetFullName(testCase))) {
-        parcSafeMemory_ReportAllocation(1);
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_CASE(Object, parcThread_Compare)
-{
-//    testUnimplemented("");
-}
-
-LONGBOW_TEST_CASE(Object, parcThread_Copy)
-{
-    PARCBuffer *buffer = longBowTestCase_Get(testCase, "object");
-    PARCThread *instance = parcThread_Create(_function, buffer);
-    PARCThread *copy = parcThread_Copy(instance);
-
-    assertTrue(parcThread_Equals(instance, copy), "Expected the copy to be equal to the original");
-
-    parcThread_Release(&instance);
-    parcThread_Release(&copy);
-}
-
-LONGBOW_TEST_CASE(Object, parcThread_Display)
-{
-    PARCBuffer *buffer = longBowTestCase_Get(testCase, "object");
-    PARCThread *instance = parcThread_Create(_function, buffer);
-    parcThread_Display(instance, 0);
-
-
-    parcThread_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Object, parcThread_Equals)
-{
-    PARCBuffer *buffer = longBowTestCase_Get(testCase, "object");
-    PARCThread *x = parcThread_Create(_function, buffer);
-    PARCThread *y = parcThread_Create(_function, buffer);
-    PARCThread *z = parcThread_Create(_function, buffer);
-
-    parcObjectTesting_AssertEquals(x, y, z, NULL);
-
-    parcThread_Release(&x);
-    parcThread_Release(&y);
-    parcThread_Release(&z);
-}
-
-LONGBOW_TEST_CASE(Object, parcThread_HashCode)
-{
-    PARCBuffer *buffer = longBowTestCase_Get(testCase, "object");
-    PARCThread *x = parcThread_Create(_function, buffer);
-    PARCThread *y = parcThread_Create(_function, buffer);
-
-    parcObjectTesting_AssertHashCode(x, y);
-
-    parcThread_Release(&x);
-    parcThread_Release(&y);
-}
-
-LONGBOW_TEST_CASE(Object, parcThread_IsValid)
-{
-    PARCBuffer *buffer = longBowTestCase_Get(testCase, "object");
-    PARCThread *instance = parcThread_Create(_function, buffer);
-    assertTrue(parcThread_IsValid(instance), "Expected parcThread_Create to result in a valid instance.");
-
-
-    parcThread_Release(&instance);
-    assertFalse(parcThread_IsValid(instance), "Expected parcThread_Release to result in an invalid instance.");
-}
-
-LONGBOW_TEST_CASE(Object, parcThread_ToJSON)
-{
-    PARCBuffer *buffer = longBowTestCase_Get(testCase, "object");
-    PARCThread *instance = parcThread_Create(_function, buffer);
-
-    PARCJSON *json = parcThread_ToJSON(instance);
-
-    parcJSON_Release(&json);
-
-
-    parcThread_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Object, parcThread_ToString)
-{
-    PARCBuffer *buffer = longBowTestCase_Get(testCase, "object");
-    PARCThread *instance = parcThread_Create(_function, buffer);
-
-    char *string = parcThread_ToString(instance);
-
-    assertNotNull(string, "Expected non-NULL result from parcThread_ToString");
-
-    parcMemory_Deallocate((void **) &string);
-
-    parcThread_Release(&instance);
-}
-
-LONGBOW_TEST_FIXTURE(Specialization)
-{
-    parcMemory_SetInterface(&PARCSafeMemoryAsPARCMemory);
-    LONGBOW_RUN_TEST_CASE(Object, parcThread_Execute);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Specialization)
-{
-    longBowTestCase_SetInt(testCase, "initialAllocations", parcMemory_Outstanding());
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Specialization)
-{
-#if INTPTR_MAX == INT32_MAX
-    uint32_t initialAllocations = (uint32_t) longBowTestCase_Get(testCase, "initialAllocations");
-#else
-    uint64_t initialAllocations = (uint64_t) longBowTestCase_Get(testCase, "initialAllocations");
-#endif
-
-    if (!parcMemoryTesting_ExpectedOutstanding(initialAllocations, "%s leaked memory.", longBowTestCase_GetFullName(testCase))) {
-        parcSafeMemory_ReportAllocation(1);
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_CASE(Object, parcThread_Execute)
-{
-}
-
-int
-main(int argc, char *argv[argc])
-{
-    LongBowRunner *testRunner = LONGBOW_TEST_RUNNER_CREATE(parc_Thread);
-    int exitStatus = longBowMain(argc, argv, testRunner, NULL);
-    longBowTestRunner_Destroy(&testRunner);
-    exit(exitStatus);
-}
-
-
diff --git a/libparc/parc/concurrent/test/test_parc_ThreadPool.c b/libparc/parc/concurrent/test/test_parc_ThreadPool.c
deleted file mode 100644
index 5ec60fa5..00000000
--- a/libparc/parc/concurrent/test/test_parc_ThreadPool.c
+++ /dev/null
@@ -1,273 +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_ThreadPool.c"
-
-#include <stdio.h>
-
-#include <LongBow/testing.h>
-#include <LongBow/debugging.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_SafeMemory.h>
-#include <parc/algol/parc_DisplayIndented.h>
-
-#include <parc/testing/parc_MemoryTesting.h>
-#include <parc/testing/parc_ObjectTesting.h>
-
-LONGBOW_TEST_RUNNER(parc_ThreadPool)
-{
-    // 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(Object);
-    LONGBOW_RUN_TEST_FIXTURE(Specialization);
-}
-
-// The Test Runner calls this function once before any Test Fixtures are run.
-LONGBOW_TEST_RUNNER_SETUP(parc_ThreadPool)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-// The Test Runner calls this function once after all the Test Fixtures are run.
-LONGBOW_TEST_RUNNER_TEARDOWN(parc_ThreadPool)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE(CreateAcquireRelease)
-{
-    LONGBOW_RUN_TEST_CASE(CreateAcquireRelease, CreateRelease);
-}
-
-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)
-{
-    PARCThreadPool *pool = parcThreadPool_Create(6);
-    assertNotNull(pool, "Expected non-null result from parcThreadPool_Create();");
-
-    parcObjectTesting_AssertAcquireReleaseContract(parcThreadPool_Acquire, pool);
-
-    parcThreadPool_ShutdownNow(pool);
-
-    parcThreadPool_Release(&pool);
-    assertNull(pool, "Expected null result from parcThreadPool_Release();");
-}
-
-LONGBOW_TEST_FIXTURE(Object)
-{
-    LONGBOW_RUN_TEST_CASE(Object, parcThreadPool_Compare);
-    LONGBOW_RUN_TEST_CASE(Object, parcThreadPool_Copy);
-    LONGBOW_RUN_TEST_CASE(Object, parcThreadPool_Display);
-    LONGBOW_RUN_TEST_CASE(Object, parcThreadPool_Equals);
-    LONGBOW_RUN_TEST_CASE(Object, parcThreadPool_HashCode);
-    LONGBOW_RUN_TEST_CASE(Object, parcThreadPool_IsValid);
-    LONGBOW_RUN_TEST_CASE(Object, parcThreadPool_ToJSON);
-    LONGBOW_RUN_TEST_CASE(Object, parcThreadPool_ToString);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Object)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Object)
-{
-    if (!parcMemoryTesting_ExpectedOutstanding(0, "%s mismanaged memory.", longBowTestCase_GetFullName(testCase))) {
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_CASE(Object, parcThreadPool_Compare)
-{
-    testUnimplemented("");
-}
-
-LONGBOW_TEST_CASE(Object, parcThreadPool_Copy)
-{
-    PARCThreadPool *instance = parcThreadPool_Create(6);
-    PARCThreadPool *copy = parcThreadPool_Copy(instance);
-    assertTrue(parcThreadPool_Equals(instance, copy), "Expected the copy to be equal to the original");
-
-    parcThreadPool_ShutdownNow(instance);
-    parcThreadPool_ShutdownNow(copy);
-
-    parcThreadPool_Release(&instance);
-    parcThreadPool_Release(&copy);
-}
-
-LONGBOW_TEST_CASE(Object, parcThreadPool_Display)
-{
-    PARCThreadPool *instance = parcThreadPool_Create(6);
-    parcThreadPool_Display(instance, 0);
-
-    parcThreadPool_ShutdownNow(instance);
-
-    parcThreadPool_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Object, parcThreadPool_Equals)
-{
-    PARCThreadPool *x = parcThreadPool_Create(6);
-    PARCThreadPool *y = parcThreadPool_Create(6);
-    PARCThreadPool *z = parcThreadPool_Create(6);
-
-    parcObjectTesting_AssertEquals(x, y, z, NULL);
-
-    parcThreadPool_ShutdownNow(x);
-    parcThreadPool_ShutdownNow(y);
-    parcThreadPool_ShutdownNow(z);
-
-    parcThreadPool_Release(&x);
-    parcThreadPool_Release(&y);
-    parcThreadPool_Release(&z);
-}
-
-LONGBOW_TEST_CASE(Object, parcThreadPool_HashCode)
-{
-    PARCThreadPool *x = parcThreadPool_Create(6);
-    PARCThreadPool *y = parcThreadPool_Create(6);
-
-    parcObjectTesting_AssertHashCode(x, y);
-
-    parcThreadPool_ShutdownNow(x);
-    parcThreadPool_ShutdownNow(y);
-
-    parcThreadPool_Release(&x);
-    parcThreadPool_Release(&y);
-}
-
-LONGBOW_TEST_CASE(Object, parcThreadPool_IsValid)
-{
-    PARCThreadPool *instance = parcThreadPool_Create(6);
-    assertTrue(parcThreadPool_IsValid(instance), "Expected parcThreadPool_Create to result in a valid instance.");
-
-    parcThreadPool_ShutdownNow(instance);
-
-    parcThreadPool_Release(&instance);
-    assertFalse(parcThreadPool_IsValid(instance), "Expected parcThreadPool_Release to result in an invalid instance.");
-}
-
-LONGBOW_TEST_CASE(Object, parcThreadPool_ToJSON)
-{
-    PARCThreadPool *instance = parcThreadPool_Create(6);
-
-    PARCJSON *json = parcThreadPool_ToJSON(instance);
-
-    parcJSON_Release(&json);
-
-    parcThreadPool_ShutdownNow(instance);
-
-    parcThreadPool_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Object, parcThreadPool_ToString)
-{
-    PARCThreadPool *instance = parcThreadPool_Create(6);
-
-    char *string = parcThreadPool_ToString(instance);
-
-    assertNotNull(string, "Expected non-NULL result from parcThreadPool_ToString");
-
-    parcMemory_Deallocate((void **) &string);
-
-    parcThreadPool_ShutdownNow(instance);
-
-    parcThreadPool_Release(&instance);
-}
-
-LONGBOW_TEST_FIXTURE(Specialization)
-{
-    parcMemory_SetInterface(&PARCSafeMemoryAsPARCMemory);
-    LONGBOW_RUN_TEST_CASE(Object, parcThreadPool_Execute);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Specialization)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Specialization)
-{
-    if (!parcMemoryTesting_ExpectedOutstanding(0, "%s mismanaged memory.", longBowTestCase_GetFullName(testCase))) {
-        parcSafeMemory_ReportAllocation(1);
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-void *
-_function(PARCFutureTask *task, void *parameter)
-{
-    printf("Hello World\n");
-    return parameter;
-}
-
-LONGBOW_TEST_CASE(Object, parcThreadPool_Execute)
-{
-    dprintf(1, "-----\n");
-    PARCThreadPool *pool = parcThreadPool_Create(6);
-
-    PARCFutureTask *task = parcFutureTask_Create(_function, _function);
-    parcThreadPool_Execute(pool, task);
-    parcThreadPool_Execute(pool, task);
-    parcThreadPool_Execute(pool, task);
-    parcThreadPool_Execute(pool, task);
-    parcThreadPool_Execute(pool, task);
-    parcFutureTask_Release(&task);
-
-    parcThreadPool_Shutdown(pool);
-    bool shutdownSuccess = parcThreadPool_AwaitTermination(pool, PARCTimeout_Never);
-
-    assertTrue(shutdownSuccess, "parcThreadPool_AwaitTermination timed-out");
-
-    uint64_t count = parcThreadPool_GetCompletedTaskCount(pool);
-    assertTrue(count == 5, "Expected 5, actual %lu", count);
-
-
-    parcThreadPool_Release(&pool);
-}
-
-int
-main(int argc, char *argv[argc])
-{
-    LongBowRunner *testRunner = LONGBOW_TEST_RUNNER_CREATE(parc_ThreadPool);
-    int exitStatus = longBowMain(argc, argv, testRunner, NULL);
-    longBowTestRunner_Destroy(&testRunner);
-    exit(exitStatus);
-}
-
-
diff --git a/libparc/parc/concurrent/test/test_parc_Timer.c b/libparc/parc/concurrent/test/test_parc_Timer.c
deleted file mode 100644
index 5bc7ae6c..00000000
--- a/libparc/parc/concurrent/test/test_parc_Timer.c
+++ /dev/null
@@ -1,213 +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_Timer.c"
-
-#include <LongBow/testing.h>
-#include <LongBow/debugging.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_SafeMemory.h>
-#include <parc/algol/parc_DisplayIndented.h>
-
-#include <parc/testing/parc_MemoryTesting.h>
-#include <parc/testing/parc_ObjectTesting.h>
-
-LONGBOW_TEST_RUNNER(parc_Timer)
-{
-    // 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(Object);
-    LONGBOW_RUN_TEST_FIXTURE(Specialization);
-}
-
-// The Test Runner calls this function once before any Test Fixtures are run.
-LONGBOW_TEST_RUNNER_SETUP(parc_Timer)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-// The Test Runner calls this function once after all the Test Fixtures are run.
-LONGBOW_TEST_RUNNER_TEARDOWN(parc_Timer)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE(CreateAcquireRelease)
-{
-    LONGBOW_RUN_TEST_CASE(CreateAcquireRelease, CreateRelease);
-}
-
-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)
-{
-    PARCTimer *instance = parcTimer_Create();
-    assertNotNull(instance, "Expected non-null result from parcTimer_Create();");
-
-    parcObjectTesting_AssertAcquireReleaseContract(parcTimer_Acquire, instance);
-
-    parcTimer_Release(&instance);
-    assertNull(instance, "Expected null result from parcTimer_Release();");
-}
-
-LONGBOW_TEST_FIXTURE(Object)
-{
-    LONGBOW_RUN_TEST_CASE(Object, parcTimer_Compare);
-    LONGBOW_RUN_TEST_CASE(Object, parcTimer_Copy);
-    LONGBOW_RUN_TEST_CASE(Object, parcTimer_Display);
-    LONGBOW_RUN_TEST_CASE(Object, parcTimer_Equals);
-    LONGBOW_RUN_TEST_CASE(Object, parcTimer_HashCode);
-    LONGBOW_RUN_TEST_CASE(Object, parcTimer_IsValid);
-    LONGBOW_RUN_TEST_CASE(Object, parcTimer_ToJSON);
-    LONGBOW_RUN_TEST_CASE(Object, parcTimer_ToString);
-}
-
-LONGBOW_TEST_FIXTURE_SETUP(Object)
-{
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_FIXTURE_TEARDOWN(Object)
-{
-    if (!parcMemoryTesting_ExpectedOutstanding(0, "%s mismanaged memory.", longBowTestCase_GetFullName(testCase))) {
-        return LONGBOW_STATUS_MEMORYLEAK;
-    }
-
-    return LONGBOW_STATUS_SUCCEEDED;
-}
-
-LONGBOW_TEST_CASE(Object, parcTimer_Compare)
-{
-    testUnimplemented("");
-}
-
-LONGBOW_TEST_CASE(Object, parcTimer_Copy)
-{
-    PARCTimer *instance = parcTimer_Create();
-    PARCTimer *copy = parcTimer_Copy(instance);
-    assertTrue(parcTimer_Equals(instance, copy), "Expected the copy to be equal to the original");
-
-    parcTimer_Release(&instance);
-    parcTimer_Release(&copy);
-}
-
-LONGBOW_TEST_CASE(Object, parcTimer_Display)
-{
-    PARCTimer *instance = parcTimer_Create();
-    parcTimer_Display(instance, 0);
-    parcTimer_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Object, parcTimer_Equals)
-{
-    PARCTimer *x = parcTimer_Create();
-    PARCTimer *y = parcTimer_Create();
-    PARCTimer *z = parcTimer_Create();
-
-    parcObjectTesting_AssertEquals(x, y, z, NULL);
-
-    parcTimer_Release(&x);
-    parcTimer_Release(&y);
-    parcTimer_Release(&z);
-}
-
-LONGBOW_TEST_CASE(Object, parcTimer_HashCode)
-{
-    PARCTimer *x = parcTimer_Create();
-    PARCTimer *y = parcTimer_Create();
-
-    parcObjectTesting_AssertHashCode(x, y);
-
-    parcTimer_Release(&x);
-    parcTimer_Release(&y);
-}
-
-LONGBOW_TEST_CASE(Object, parcTimer_IsValid)
-{
-    PARCTimer *instance = parcTimer_Create();
-    assertTrue(parcTimer_IsValid(instance), "Expected parcTimer_Create to result in a valid instance.");
-
-    parcTimer_Release(&instance);
-    assertFalse(parcTimer_IsValid(instance), "Expected parcTimer_Release to result in an invalid instance.");
-}
-
-LONGBOW_TEST_CASE(Object, parcTimer_ToJSON)
-{
-    PARCTimer *instance = parcTimer_Create();
-
-    PARCJSON *json = parcTimer_ToJSON(instance);
-
-    parcJSON_Release(&json);
-
-    parcTimer_Release(&instance);
-}
-
-LONGBOW_TEST_CASE(Object, parcTimer_ToString)
-{
-    PARCTimer *instance = parcTimer_Create();
-
-    char *string = parcTimer_ToString(instance);
-
-    assertNotNull(string, "Expected non-NULL result from parcTimer_ToString");
-
-    parcMemory_Deallocate((void **) &string);
-    parcTimer_Release(&instance);
-}
-
-LONGBOW_TEST_FIXTURE(Specialization)
-{
-}
-
-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;
-}
-
-int
-main(int argc, char *argv[argc])
-{
-    LongBowRunner *testRunner = LONGBOW_TEST_RUNNER_CREATE(parc_Timer);
-    int exitStatus = longBowMain(argc, argv, testRunner, NULL);
-    longBowTestRunner_Destroy(&testRunner);
-    exit(exitStatus);
-}
-
-