Merge "Add support for ubuntu18.04 packages."

74 files changed, 573 insertions, 546 deletions

diff --git a/libparc/parc/algol/internal_parc_Event.c b/libparc/parc/algol/internal_parc_Event.c
index 74e917bf..54c193ea 100755
--- a/libparc/parc/algol/internal_parc_Event.c
+++ b/libparc/parc/algol/internal_parc_Event.c
@@ -17,7 +17,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 #include <parc/algol/parc_Memory.h>
 #include "internal_parc_Event.h"
 
@@ -67,7 +67,7 @@ internal_parc_initializeLibevent(void)
     // CC = patchlevel
     //
     uint32_t version = event_get_version_number();
-    trapIllegalValueIf(version < 0x02001000UL,
+    parcTrapIllegalValueIf(version < 0x02001000UL,
                        "Libevent version must be at least 2.0.16, got %s",
                        event_get_version());
 
@@ -79,9 +79,9 @@ internal_parc_initializeLibevent(void)
     // Create a scheduler event base, an event, then free both of them.
     //
     struct event_base *evbase = event_base_new();
-    assertNotNull(evbase, "Libevent event_base_new returned NULL");
+    parcAssertNotNull(evbase, "Libevent event_base_new returned NULL");
     struct event *event = event_new(evbase, -1, 0, NULL, NULL);
-    assertNotNull(event, "Libevent event_new returned NULL");
+    parcAssertNotNull(event, "Libevent event_new returned NULL");
     event_del(event);
     event_base_free(evbase);
     event_free(event);
@@ -103,7 +103,7 @@ internal_libevent_priority_to_PARCEventPriority(short evpriority)
         case 2: priority = PARCEventPriority_Minimum;
             break;
         default:
-            assertTrue(0, "Unknown Libevent priority 0x%x\n", evpriority);
+            parcAssertTrue(0, "Unknown Libevent priority 0x%x\n", evpriority);
             break;
     }
     return priority;
@@ -121,7 +121,7 @@ internal_PARCEventPriority_to_libevent_priority(PARCEventPriority priority)
         case PARCEventPriority_Minimum: evpriority = 2;
             break;
         default:
-            assertTrue(0, "Unknown PARCEventPriority 0x%x\n", evpriority);
+            parcAssertTrue(0, "Unknown PARCEventPriority 0x%x\n", evpriority);
             break;
     }
     return evpriority;
@@ -139,7 +139,7 @@ internal_eventloop_options_to_PARCEventSchedulerDispatchType(short evoptions)
         case EVLOOP_NONBLOCK: options = PARCEventSchedulerDispatchType_NonBlocking;
             break;
         default:
-            assertTrue(0, "Unknown Libevent dispatcher flag 0x%x\n", evoptions);
+            parcAssertTrue(0, "Unknown Libevent dispatcher flag 0x%x\n", evoptions);
             break;
     }
     return options;
@@ -157,7 +157,7 @@ internal_PARCEventSchedulerDispatchType_to_eventloop_options(PARCEventSchedulerD
         case PARCEventSchedulerDispatchType_NonBlocking: evoptions = EVLOOP_NONBLOCK;
             break;
         default:
-            assertTrue(0, "Unknown PARCEventSchedulerDispatchType option 0x%x\n", evoptions);
+            parcAssertTrue(0, "Unknown PARCEventSchedulerDispatchType option 0x%x\n", evoptions);
             break;
     }
     return evoptions;
@@ -175,7 +175,7 @@ internal_bufferevent_options_to_PARCEventQueueOption(short evflags)
         flags |= PARCEventQueueOption_DeferCallbacks;
         evflags &= ~BEV_OPT_DEFER_CALLBACKS;
     }
-    assertTrue(evflags == 0, "Unknown Libevent option flag 0x%x\n", evflags);
+    parcAssertTrue(evflags == 0, "Unknown Libevent option flag 0x%x\n", evflags);
     return flags;
 }
 
@@ -191,7 +191,7 @@ internal_PARCEventQueueOption_to_bufferevent_options(PARCEventQueueOption flags)
         evflags |= BEV_OPT_DEFER_CALLBACKS;
         flags &= ~PARCEventQueueOption_DeferCallbacks;
     }
-    assertTrue(flags == 0, "Unknown PARCEventQueueOption flag 0x%x\n", flags);
+    parcAssertTrue(flags == 0, "Unknown PARCEventQueueOption flag 0x%x\n", flags);
     return evflags;
 }
 
@@ -223,7 +223,7 @@ internal_bufferevent_type_to_PARCEventQueueEventType(short evtypes)
         types |= PARCEventQueueEventType_Connected;
         evtypes &= ~BEV_EVENT_CONNECTED;
     }
-    assertTrue(evtypes == 0, "Unknown Libevent type flag 0x%x\n", evtypes);
+    parcAssertTrue(evtypes == 0, "Unknown Libevent type flag 0x%x\n", evtypes);
     return types;
 }
 
@@ -255,7 +255,7 @@ internal_PARCEventQueueEventType_to_bufferevent_type(PARCEventQueueEventType typ
         evtypes |= BEV_EVENT_CONNECTED;
         types &= ~PARCEventQueueEventType_Connected;
     }
-    assertTrue(types == 0, "Unknown PARCEventQueueEventType 0x%x\n", types);
+    parcAssertTrue(types == 0, "Unknown PARCEventQueueEventType 0x%x\n", types);
     return evtypes;
 }
 
@@ -287,7 +287,7 @@ internal_libevent_type_to_PARCEventType(short evtypes)
         types |= PARCEventType_EdgeTriggered;
         evtypes &= ~EV_ET;
     }
-    assertTrue(evtypes == 0, "Unknown Libevent event type 0x%x\n", evtypes);
+    parcAssertTrue(evtypes == 0, "Unknown Libevent event type 0x%x\n", evtypes);
     return types;
 }
 
@@ -319,6 +319,6 @@ internal_PARCEventType_to_libevent_type(PARCEventType types)
         evtypes |= EV_ET;
         types &= ~PARCEventType_EdgeTriggered;
     }
-    assertTrue(types == 0, "Unknown Libevent event type 0x%x\n", types);
+    parcAssertTrue(types == 0, "Unknown Libevent event type 0x%x\n", types);
     return evtypes;
 }
diff --git a/libparc/parc/algol/parc_ArrayList.c b/libparc/parc/algol/parc_ArrayList.c
index e9597070..4e6f6df1 100644
--- a/libparc/parc/algol/parc_ArrayList.c
+++ b/libparc/parc/algol/parc_ArrayList.c
@@ -22,7 +22,7 @@
 #include <stdbool.h>
 #include <string.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <parc/algol/parc_ArrayList.h>
 #include <parc/algol/parc_Object.h>
@@ -85,7 +85,7 @@ _ensureCapacity(PARCArrayList *array, size_t newCapacity)
 static PARCArrayList *
 _ensureRemaining(PARCArrayList *array, size_t remnant)
 {
-    assertNotNull(array, "Parameter must be a non-null PARCArrayList pointer.");
+    parcAssertNotNull(array, "Parameter must be a non-null PARCArrayList pointer.");
 
     if (_remaining(array) < remnant) {
         size_t newCapacity = parcArrayList_Size(array) + remnant;
@@ -111,8 +111,8 @@ parcArrayList_IsValid(const PARCArrayList *instance)
 void
 parcArrayList_AssertValid(const PARCArrayList *instance)
 {
-    trapIllegalValueIf(instance == NULL, "Parameter must be a non-null PARC_ArrayList pointer.");
-    assertTrue(instance->numberOfElements == 0 ? true : instance->array != NULL, "PARC_ArrayList size is inconsistent.");
+    parcTrapIllegalValueIf(instance == NULL, "Parameter must be a non-null PARC_ArrayList pointer.");
+    parcAssertTrue(instance->numberOfElements == 0 ? true : instance->array != NULL, "PARC_ArrayList size is inconsistent.");
 }
 
 static PARCArrayList *
@@ -137,7 +137,7 @@ PARCArrayList *
 parcArrayList_Create(void (*destroyElement)(void **element))
 {
     PARCArrayList *result = parcMemory_AllocateAndClear(sizeof(PARCArrayList));
-    assertNotNull(result, "Memory allocation of PARCArrayList failed");
+    parcAssertNotNull(result, "Memory allocation of PARCArrayList failed");
 
     return _parcArrayList_Init(result, 0, 0, NULL, NULL, destroyElement);
 }
@@ -146,7 +146,7 @@ PARCArrayList *
 parcArrayList_Create_Capacity(bool (*equalsElement)(void *x, void *y), void (*destroyElement)(void **element), size_t size)
 {
     PARCArrayList *result = parcMemory_AllocateAndClear(sizeof(PARCArrayList));
-    assertNotNull(result, "Memory allocation of PARCArrayList failed");
+    parcAssertNotNull(result, "Memory allocation of PARCArrayList failed");
 
     _parcArrayList_Init(result, 0, 0, NULL, equalsElement, destroyElement);
 
@@ -163,7 +163,7 @@ parcArrayList_Add(PARCArrayList *array, const void *pointer)
     parcArrayList_OptionalAssertValid(array);
 
     if (_ensureRemaining(array, 1) == NULL) {
-        trapOutOfMemory("Cannot increase space for PARCArrayList.");
+        parcTrapOutOfMemory("Cannot increase space for PARCArrayList.");
     }
     array->array[array->numberOfElements++] = (void *) pointer;
 
@@ -221,7 +221,7 @@ parcArrayList_Equals(const PARCArrayList *a, const PARCArrayList *b)
 void *
 parcArrayList_RemoveAtIndex(PARCArrayList *array, size_t index)
 {
-    trapOutOfBoundsIf(index >= array->numberOfElements, "Index must be within the range [0, %zu)", array->numberOfElements);
+    parcTrapOutOfBoundsIf(index >= array->numberOfElements, "Index must be within the range [0, %zu)", array->numberOfElements);
 
     void *element = array->array[index];
 
@@ -237,7 +237,7 @@ parcArrayList_RemoveAtIndex(PARCArrayList *array, size_t index)
 void
 parcArrayList_Set(const PARCArrayList *array, size_t index, void *pointer)
 {
-    trapOutOfBoundsIf(index >= array->numberOfElements, "Index must be within the range [0, %zu)", array->numberOfElements);
+    parcTrapOutOfBoundsIf(index >= array->numberOfElements, "Index must be within the range [0, %zu)", array->numberOfElements);
 
     array->array[index] = pointer;
 }
@@ -245,7 +245,7 @@ parcArrayList_Set(const PARCArrayList *array, size_t index, void *pointer)
 void *
 parcArrayList_Get(const PARCArrayList *array, size_t index)
 {
-    trapOutOfBoundsIf(index >= array->numberOfElements, "Index must be within the range [0, %zu)", array->numberOfElements);
+    parcTrapOutOfBoundsIf(index >= array->numberOfElements, "Index must be within the range [0, %zu)", array->numberOfElements);
 
     return array->array[index];
 }
@@ -265,13 +265,13 @@ parcArrayList_Size(const PARCArrayList *pointerArray)
 void
 parcArrayList_Destroy(PARCArrayList **arrayPtr)
 {
-    assertNotNull(arrayPtr, "Parameter must be a non-null pointer to a PARC_ArrayList pointer.");
+    parcAssertNotNull(arrayPtr, "Parameter must be a non-null pointer to a PARC_ArrayList pointer.");
 
     PARCArrayList *array = *arrayPtr;
 
     parcArrayList_OptionalAssertValid(array);
 
-    assertTrue(array->numberOfElements == 0 ? true : array->array != NULL, "PARC_ArrayList is inconsistent.");
+    parcAssertTrue(array->numberOfElements == 0 ? true : array->array != NULL, "PARC_ArrayList is inconsistent.");
 
     if (array->destroyElement != NULL) {
         for (size_t i = 0; i < array->numberOfElements; i++) {
@@ -328,7 +328,7 @@ parcArrayList_RemoveAndDestroyAtIndex(PARCArrayList *array, size_t index)
 {
     parcArrayList_OptionalAssertValid(array);
 
-    assertTrue(index < array->numberOfElements, "Index must be ( 0 <= index < %zd). Actual=%zd", array->numberOfElements, index);
+    parcAssertTrue(index < array->numberOfElements, "Index must be ( 0 <= index < %zd). Actual=%zd", array->numberOfElements, index);
 
     if (index < array->numberOfElements) {
         // Destroy the element at the given index.
@@ -352,7 +352,7 @@ parcArrayList_InsertAtIndex(PARCArrayList *array, size_t index, const void *poin
     parcArrayList_OptionalAssertValid(array);
     size_t length = parcArrayList_Size(array);
 
-    assertTrue(index <= array->numberOfElements, "You can't insert beyond the end of the list");
+    parcAssertTrue(index <= array->numberOfElements, "You can't insert beyond the end of the list");
 
     // Create space and grow the array if needed
     _ensureRemaining(array, length + 1);
diff --git a/libparc/parc/algol/parc_Base64.c b/libparc/parc/algol/parc_Base64.c
index 38020479..cac0aa4d 100755
--- a/libparc/parc/algol/parc_Base64.c
+++ b/libparc/parc/algol/parc_Base64.c
@@ -39,7 +39,7 @@
 #include <stdio.h>
 #include <string.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <parc/algol/parc_Base64.h>
 #include <parc/algol/parc_Memory.h>
@@ -80,7 +80,7 @@ const uint8_t decodeTable[256] = {
 static void
 _encodeWithPad(PARCBufferComposer *output, const uint8_t *quantum, size_t padLength)
 {
-    assertTrue(padLength < 3, "Degenerate case -- should never pad all 3 bytes!");
+    parcAssertTrue(padLength < 3, "Degenerate case -- should never pad all 3 bytes!");
 
     unsigned index;
 
diff --git a/libparc/parc/algol/parc_BitVector.c b/libparc/parc/algol/parc_BitVector.c
index 578fd102..21a66c23 100755
--- a/libparc/parc/algol/parc_BitVector.c
+++ b/libparc/parc/algol/parc_BitVector.c
@@ -13,11 +13,9 @@
  * limitations under the License.
  */
 
-/**
- */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <parc/algol/parc_Object.h>
 #include <parc/algol/parc_BitVector.h>
@@ -61,10 +59,10 @@ PARCBitVector *
 parcBitVector_Create(void)
 {
     PARCBitVector *parcBitVector = parcObject_CreateInstance(PARCBitVector);
-    assertNotNull(parcBitVector, "parcObject_CreateInstance returned NULL");
+    parcAssertNotNull(parcBitVector, "parcObject_CreateInstance returned NULL");
 
     parcBitVector->bitArray = parcMemory_AllocateAndClear(DEFAULT_BITARRAY_SIZE);
-    assertNotNull(parcBitVector->bitArray, "parcMemory_AllocateAndClear(%d) returned NULL", DEFAULT_BITARRAY_SIZE);
+    parcAssertNotNull(parcBitVector->bitArray, "parcMemory_AllocateAndClear(%d) returned NULL", DEFAULT_BITARRAY_SIZE);
     parcBitVector->bitLength = DEFAULT_BITARRAY_SIZE * BITS_PER_BYTE;
     parcBitVector->numberOfBitsSet = 0;
     parcBitVector->firstBitSet = -1;
@@ -77,7 +75,7 @@ PARCBitVector *
 parcBitVector_Copy(const PARCBitVector *source)
 {
     PARCBitVector *parcBitVector = parcObject_CreateInstance(PARCBitVector);
-    assertNotNull(parcBitVector, "parcObject_CreateInstance returned NULL");
+    parcAssertNotNull(parcBitVector, "parcObject_CreateInstance returned NULL");
 
     size_t byteLength = source->bitLength / BITS_PER_BYTE;
     parcBitVector->bitArray = parcMemory_Allocate(byteLength);
@@ -111,8 +109,8 @@ parcBitVector_Equals(const PARCBitVector *a, const PARCBitVector *b)
 static void
 _parc_bit_vector_resize(PARCBitVector *parcBitVector, unsigned bit)
 {
-    assertNotNull(parcBitVector, "_parc_bit_vector_resize passed a NULL parcBitVector");
-    assertTrue(bit < MAX_BIT_VECTOR_INDEX, "_parc_bit_vector_resize passed a bit index that's too large");
+    parcAssertNotNull(parcBitVector, "_parc_bit_vector_resize passed a NULL parcBitVector");
+    parcAssertTrue(bit < MAX_BIT_VECTOR_INDEX, "_parc_bit_vector_resize passed a bit index that's too large");
 
     unsigned neededBits = bit + 1;
     if (neededBits > parcBitVector->bitLength) {
@@ -120,12 +118,12 @@ _parc_bit_vector_resize(PARCBitVector *parcBitVector, unsigned bit)
         int oldSize = (parcBitVector->bitLength / BITS_PER_BYTE) + ((parcBitVector->bitLength % BITS_PER_BYTE) ? 1 : 0);
 
         uint8_t *newArray = parcMemory_Reallocate(parcBitVector->bitArray, newSize);
-        assertTrue(newArray, "parcMemory_Reallocate(%d) failed", newSize);
+        parcAssertTrue(newArray, "parcMemory_Reallocate(%d) failed", newSize);
         // Reallocate does not guarantee that additional memory is zero-filled.
         memset((void *) &(newArray[oldSize]), parcBitVector->fillValue, newSize - oldSize);
 
         parcBitVector->bitArray = newArray;
-        assertNotNull(newArray, "parcMemory_Reallocate(%d) returned NULL", newSize);
+        parcAssertNotNull(newArray, "parcMemory_Reallocate(%d) returned NULL", newSize);
         parcBitVector->bitLength = newSize * BITS_PER_BYTE;
     }
 }
@@ -133,7 +131,7 @@ _parc_bit_vector_resize(PARCBitVector *parcBitVector, unsigned bit)
 int
 parcBitVector_Get(const PARCBitVector *parcBitVector, unsigned bit)
 {
-    assertTrue(bit < MAX_BIT_VECTOR_INDEX, "parcBitVector_Set passed a bit index that's too large");
+    parcAssertTrue(bit < MAX_BIT_VECTOR_INDEX, "parcBitVector_Set passed a bit index that's too large");
 
     if ((parcBitVector == NULL) || (bit >= parcBitVector->bitLength)) {
         return -1;
@@ -151,8 +149,8 @@ parcBitVector_Get(const PARCBitVector *parcBitVector, unsigned bit)
 void
 parcBitVector_Set(PARCBitVector *parcBitVector, unsigned bit)
 {
-    assertNotNull(parcBitVector, "parcBitVector_Set passed a NULL parcBitVector");
-    assertTrue(bit < MAX_BIT_VECTOR_INDEX, "parcBitVector_Set passed a bit index that's too huge");
+    parcAssertNotNull(parcBitVector, "parcBitVector_Set passed a NULL parcBitVector");
+    parcAssertTrue(bit < MAX_BIT_VECTOR_INDEX, "parcBitVector_Set passed a bit index that's too huge");
     if (bit >= parcBitVector->bitLength) {
         _parc_bit_vector_resize(parcBitVector, bit);
     }
@@ -170,12 +168,12 @@ parcBitVector_Set(PARCBitVector *parcBitVector, unsigned bit)
 void
 parcBitVector_SetVector(PARCBitVector *parcBitVector, const PARCBitVector *bitsToSet)
 {
-    assertNotNull(parcBitVector, "parcBitVector_SetVector passed a NULL parcBitVector");
-    assertNotNull(parcBitVector, "parcBitVector_SetVector passed a NULL vector of bits to set");
+    parcAssertNotNull(parcBitVector, "parcBitVector_SetVector passed a NULL parcBitVector");
+    parcAssertNotNull(parcBitVector, "parcBitVector_SetVector passed a NULL vector of bits to set");
     int settingBit = 0;
     for (int i = 0; i < bitsToSet->numberOfBitsSet; i++) {
         settingBit = parcBitVector_NextBitSet(bitsToSet, settingBit);
-        assertTrue(settingBit != -1, "Number of bits claimed set inconsistent with bits found");
+        parcAssertTrue(settingBit != -1, "Number of bits claimed set inconsistent with bits found");
         parcBitVector_Set(parcBitVector, settingBit);
         settingBit++;
     }
@@ -194,8 +192,8 @@ parcBitVector_Reset(PARCBitVector *parcBitVector)
 void
 parcBitVector_Clear(PARCBitVector *parcBitVector, unsigned bit)
 {
-    assertNotNull(parcBitVector, "parcBitVector_Clear passed a NULL parcBitVector");
-    assertTrue(bit < MAX_BIT_VECTOR_INDEX, "parcBitVector_Clear passed a bit index that's too huge");
+    parcAssertNotNull(parcBitVector, "parcBitVector_Clear passed a NULL parcBitVector");
+    parcAssertTrue(bit < MAX_BIT_VECTOR_INDEX, "parcBitVector_Clear passed a bit index that's too huge");
     if (bit > parcBitVector->bitLength) {
         _parc_bit_vector_resize(parcBitVector, bit);
     }
@@ -213,8 +211,8 @@ parcBitVector_Clear(PARCBitVector *parcBitVector, unsigned bit)
 void
 parcBitVector_ClearVector(PARCBitVector *parcBitVector, const PARCBitVector *bitsToClear)
 {
-    assertNotNull(parcBitVector, "parcBitVector_ClearVector passed a NULL parcBitVector");
-    assertNotNull(bitsToClear, "parcBitVector_ClearVector passed a NULL for vector of bitsToClear");
+    parcAssertNotNull(parcBitVector, "parcBitVector_ClearVector passed a NULL parcBitVector");
+    parcAssertNotNull(bitsToClear, "parcBitVector_ClearVector passed a NULL for vector of bitsToClear");
 
     // If we're clearing ourself, we just need a reset
     if (parcBitVector == bitsToClear) {
diff --git a/libparc/parc/algol/parc_BitVector.h b/libparc/parc/algol/parc_BitVector.h
index 7e72ac70..552fd911 100755
--- a/libparc/parc/algol/parc_BitVector.h
+++ b/libparc/parc/algol/parc_BitVector.h
@@ -57,7 +57,7 @@ PARCBitVector *parcBitVector_Create(void);
  *     PARCBitVector *parcBitVector = parcBitVector_Create();
  *     parcBitVector_Set(parcBitVector, 10);
  *     PARCBitVector *copy = parcBitVector_Copy(parcBitVector);
- *     assertTrue(parcBitVector_Equals(parcBitVector, copy), "Duplicate vector is unequal");
+ *     parcAssertTrue(parcBitVector_Equals(parcBitVector, copy), "Duplicate vector is unequal");
  * }
  * @endcode
  *
@@ -115,7 +115,7 @@ void parcBitVector_Release(PARCBitVector **parcBitVector);
  *     parcBitVector_Set(parcBitVector, 10);
  *     PARCBitVector *copy = parcBitVector_Copy(parcBitVector);
  *     parcBitVector_Set(copy, 1);
- *     assertTrue(parcBitVector_Equals(parcBitVector, copy) == false, "Vector should have been unequal");
+ *     parcAssertTrue(parcBitVector_Equals(parcBitVector, copy) == false, "Vector should have been unequal");
  * }
  * @endcode
  *
@@ -138,7 +138,7 @@ bool parcBitVector_Equals(const PARCBitVector *a, const PARCBitVector *b);
  *     parcBitVector_Set(superSet, 11);
  *     PARCBitVector *subSet = parcBitVector_Create();
  *     parcBitVector_Set(subSet, 10);
- *     assertTrue(parcBitVector_Contains(superSet, subSet), "Expect superSet to contain subSet");
+ *     parcAssertTrue(parcBitVector_Contains(superSet, subSet), "Expect superSet to contain subSet");
  * }
  * @endcode
  *
@@ -157,7 +157,7 @@ bool parcBitVector_Contains(const PARCBitVector *parcBitVector, const PARCBitVec
  * {
  *     PARCBitVector *parcBitVector = parcBitVector_Create();
  *     parcBitVector_Set(parcBitVector, 10);
- *     assertTrue(parcBitVector_Get(parcBitVector, 10) == 1, "Vector should have been set");
+ *     parcAssertTrue(parcBitVector_Get(parcBitVector, 10) == 1, "Vector should have been set");
  * }
  * @endcode
  *
@@ -175,7 +175,7 @@ int parcBitVector_Get(const PARCBitVector *parcBitVector, unsigned bit);
  * {
  *     PARCBitVector *parcBitVector = parcBitVector_Create();
  *     parcBitVector_Set(parcBitVector, 10);
- *     assertTrue(parcBitVector_Get(parcBitVector, 10) == 1, "Vector should have been set");
+ *     parcAssertTrue(parcBitVector_Get(parcBitVector, 10) == 1, "Vector should have been set");
  * }
  * @endcode
  *
@@ -196,7 +196,7 @@ void parcBitVector_Set(PARCBitVector *parcBitVector, unsigned bit);
  *     parcBitVector_Set(parcBitVector, 0);
  *
  *     parcBitVector_RightShift(parcBitVector, 1);
- *     assertTrue(parcBitVector_FirstBitSet(parcBitVector) == 1,
+ *     parcAssertTrue(parcBitVector_FirstBitSet(parcBitVector) == 1,
  *                "First vector element should have moved up");
  *
  *     parcBitVector_Release(&parcBitVector);
@@ -221,7 +221,7 @@ PARCBitVector *parcBitVector_RightShift(PARCBitVector *parcBitVector, size_t rig
  *     parcBitVector_Set(parcBitVector, 0);
  *
  *     parcBitVector_LeftShift(parcBitVector, 1);
- *     assertTrue(parcBitVector_NumberOfBitsSet(parcBitVector) == 1,
+ *     parcAssertTrue(parcBitVector_NumberOfBitsSet(parcBitVector) == 1,
  *                "First vector element should have rolled off");
  *
  *     parcBitVector_Release(&parcBitVector);
@@ -247,7 +247,7 @@ PARCBitVector *parcBitVector_LeftShift(PARCBitVector *parcBitVector, size_t left
  *     parcBitVector_Set(andVector, 11);
  *
  *     PARCBitVector *result = parcBitVector_And(parcBitVector, andVector);
- *     assertTrue(parcBitVector_NumberOfBitsSet(result) == 0, "Vector should have been empty");
+ *     parcAssertTrue(parcBitVector_NumberOfBitsSet(result) == 0, "Vector should have been empty");
  *
  *     parcBitVector_Release(&parcBitVector);
  *     parcBitVector_Release(&andVector);
@@ -274,7 +274,7 @@ PARCBitVector *parcBitVector_And(const PARCBitVector *a, const PARCBitVector *b)
  *     parcBitVector_Set(orVector, 11);
  *
  *     PARCBitVector *result = parcBitVector_Or(parcBitVector, orVector);
- *     assertTrue(parcBitVector_NumberOfBitsSet(result) == 2, "Vector should have been set");
+ *     parcAssertTrue(parcBitVector_NumberOfBitsSet(result) == 2, "Vector should have been set");
  *
  *     parcBitVector_Release(&parcBitVector);
  *     parcBitVector_Release(&orVector);
@@ -298,7 +298,7 @@ PARCBitVector *parcBitVector_Or(const PARCBitVector *a, const PARCBitVector *b);
  *     PARCBitVector *bitsToSet = parcBitVector_Create();
  *     parcBitVector_Set(bitsToSet, 10);
  *     parcBitVector_SetVector(parcBitVector, bitsToSet);
- *     assertTrue(parcBitVector_Get(parcBitVector, 10) == 1, "Vector should have been set");
+ *     parcAssertTrue(parcBitVector_Get(parcBitVector, 10) == 1, "Vector should have been set");
  * }
  * @endcode
  *
@@ -317,7 +317,7 @@ void parcBitVector_SetVector(PARCBitVector *parcBitVector, const PARCBitVector *
  *     parcBitVector_Set(parcBitVector, 10);
  *     parcBitVector_Set(parcBitVector, 42);
  *     parcBitVector_Reset(parcBitVector);
- *     assertTrue(parcBitVector_NumberOfBitsSet(parcBitVector) == 0, "Vector should have 0 bits set");
+ *     parcAssertTrue(parcBitVector_NumberOfBitsSet(parcBitVector) == 0, "Vector should have 0 bits set");
  * }
  * @endcode
  *
@@ -335,9 +335,9 @@ void parcBitVector_Reset(PARCBitVector *parcBitVector);
  * {
  *     PARCBitVector *parcBitVector = parcBitVector_Create();
  *     parcBitVector_Set(parcBitVector, 10);
- *     assertTrue(parcBitVector_Get(parcBitVector, 10) == 1, "Vector should have been set");
+ *     parcAssertTrue(parcBitVector_Get(parcBitVector, 10) == 1, "Vector should have been set");
  *     parcBitVector_Clear(parcBitVector, 10);
- *     assertTrue(parcBitVector_Get(parcBitVector, 10) == 0, "Vector should have been cleared");
+ *     parcAssertTrue(parcBitVector_Get(parcBitVector, 10) == 0, "Vector should have been cleared");
  * }
  * @endcode
  *
@@ -358,7 +358,7 @@ void parcBitVector_Clear(PARCBitVector *parcBitVector, unsigned bit);
  *     PARCBitVector *bitsToClear = parcBitVector_Create();
  *     parcBitVector_Set(bitsToClear, 10);
  *     parcBitVector_SetVector(parcBitVector, bitsToClear);
- *     assertTrue(parcBitVector_Get(parcBitVector, 10) == 0, "Vector should have been cleared");
+ *     parcAssertTrue(parcBitVector_Get(parcBitVector, 10) == 0, "Vector should have been cleared");
  * }
  * @endcode
  *
@@ -376,7 +376,7 @@ void parcBitVector_ClearVector(PARCBitVector *parcBitVector, const PARCBitVector
  * {
  *     PARCBitVector *parcBitVector = parcBitVector_Create();
  *     parcBitVector_Set(parcBitVector, 10);
- *     assertTrue(parcBitVector_NumberOfBitsSet(parcBitVector) == 1, "One bit should have been set");
+ *     parcAssertTrue(parcBitVector_NumberOfBitsSet(parcBitVector) == 1, "One bit should have been set");
  * }
  * @endcode
  *
@@ -396,8 +396,8 @@ unsigned parcBitVector_NumberOfBitsSet(const PARCBitVector *parcBitVector);
  *     PARCBitVector *parcBitVector = parcBitVector_Create();
  *     parcBitVector_Set(parcBitVector, 10);
  *     parcBitVector_Set(parcBitVector, 12);
- *     assertTrue(parcBitVector_NextBitSet(parcBitVector, 0) == 10, "Bit 10 should have been found first");
- *     assertTrue(parcBitVector_NextBitSet(parcBitVector, 11) == 12, "Bit 12 should have been found next");
+ *     parcAssertTrue(parcBitVector_NextBitSet(parcBitVector, 0) == 10, "Bit 10 should have been found first");
+ *     parcAssertTrue(parcBitVector_NextBitSet(parcBitVector, 11) == 12, "Bit 12 should have been found next");
  * }
  * @endcode
  *
diff --git a/libparc/parc/algol/parc_Buffer.c b/libparc/parc/algol/parc_Buffer.c
index b2ca3577..20520f9c 100755
--- a/libparc/parc/algol/parc_Buffer.c
+++ b/libparc/parc/algol/parc_Buffer.c
@@ -18,8 +18,7 @@
 #include <config.h>
 #include <ctype.h>
 
-#include <LongBow/runtime.h>
-#include <LongBow/debugging.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <parc/algol/parc_Object.h>
 #include <parc/algol/parc_Buffer.h>
@@ -65,8 +64,8 @@ _markIsDiscarded(const PARCBuffer *buffer)
 static inline void
 _trapIfIndexExceedsLimit(const PARCBuffer *buffer, const size_t index)
 {
-    trapOutOfBoundsIf(index > buffer->limit, "PARCBuffer limit at %zd, attempted to access at %zd",
-                      parcBuffer_Limit(buffer), index);
+    //parcTrapOutOfBoundsIf(index > buffer->limit, "PARCBuffer limit at %zd, attempted to access at %zd",
+    //                  parcBuffer_Limit(buffer), index);
 }
 
 static inline void
@@ -96,15 +95,15 @@ static inline void
 _assertInvariants(const PARCBuffer *buffer)
 {
     // 0 <= mark <= position <= limit <= capacity
-    assertTrue(0 <= buffer->mark,
+    parcAssertTrue(0 <= buffer->mark,
                "Expected 0 <= mark (%zd)", buffer->mark);
-    assertTrue(_markIsDiscarded(buffer) || buffer->mark <= buffer->position,
+    parcAssertTrue(_markIsDiscarded(buffer) || buffer->mark <= buffer->position,
                "Expected mark (%zd) <= position (%zd)", buffer->mark, buffer->position);
-    assertTrue(buffer->position <= buffer->limit,
+    parcAssertTrue(buffer->position <= buffer->limit,
                "Expected position (%zd) <= limit (%zd)", buffer->position, buffer->limit);
-    assertTrue(buffer->limit <= buffer->capacity,
+    parcAssertTrue(buffer->limit <= buffer->capacity,
                "Expected limit (%zd) <= capacity (%zd)", buffer->limit, buffer->capacity);
-    assertTrue((buffer->arrayOffset + buffer->capacity) <= parcByteArray_Capacity(buffer->array),
+    parcAssertTrue((buffer->arrayOffset + buffer->capacity) <= parcByteArray_Capacity(buffer->array),
                "Expected (%zd + %zd) <= %zd",
                buffer->arrayOffset, buffer->capacity, parcByteArray_Capacity(buffer->array));
 }
@@ -201,7 +200,7 @@ parcBuffer_AssertValid(const PARCBuffer *buffer)
 {
     char *explanation = _parcBuffer_CheckValidity(buffer);
 
-    trapIllegalValueIf(explanation != NULL, "PARCBuffer@%p %s.", (void *) buffer, explanation);
+    parcTrapIllegalValueIf(explanation != NULL, "PARCBuffer@%p %s.", (void *) buffer, explanation);
 }
 
 bool
@@ -450,7 +449,7 @@ parcBuffer_ParseHexString(const char *hexString)
 PARCBuffer *
 parcBuffer_CreateFromArray(const void *bytes, const size_t length)
 {
-    assertTrue(length == 0 || bytes != NULL,
+    parcAssertTrue(length == 0 || bytes != NULL,
                "If the byte array is NULL, then length MUST be zero.");
 
     PARCBuffer *result = parcBuffer_Allocate(length);
@@ -587,7 +586,7 @@ parcBuffer_Reset(PARCBuffer *buffer)
 {
     parcBuffer_OptionalAssertValid(buffer);
 
-    assertFalse(_markIsDiscarded(buffer),
+    parcAssertFalse(_markIsDiscarded(buffer),
                 "The mark has not been set");
     buffer->position = buffer->mark;
 
@@ -618,7 +617,7 @@ PARCBuffer *
 parcBuffer_SetLimit(PARCBuffer *buffer, size_t newLimit)
 {
     parcBuffer_OptionalAssertValid(buffer);
-    assertTrue(newLimit <= parcBuffer_Capacity(buffer),
+    parcAssertTrue(newLimit <= parcBuffer_Capacity(buffer),
                "new limit cannot be larger than the capacity");
 
     if (_markIsDiscarded(buffer)) {
@@ -666,7 +665,7 @@ parcBuffer_SetPosition(PARCBuffer *buffer, size_t newPosition)
 {
     parcBuffer_OptionalAssertValid(buffer);
 
-    assertFalse(newPosition > buffer->limit,
+    parcAssertFalse(newPosition > buffer->limit,
                 "new position cannot be greater the buffer's limit");
 
     buffer->position = newPosition;
@@ -808,7 +807,7 @@ PARCBuffer *
 parcBuffer_PutUint8(PARCBuffer *buffer, uint8_t value)
 {
     parcBuffer_OptionalAssertValid(buffer);
-    assertTrue(parcBuffer_Remaining(buffer) >= 1,
+    parcAssertTrue(parcBuffer_Remaining(buffer) >= 1,
                "Buffer overflow");
 
     parcByteArray_PutByte(buffer->array, _effectivePosition(buffer), value);
@@ -819,7 +818,7 @@ parcBuffer_PutUint8(PARCBuffer *buffer, uint8_t value)
 PARCBuffer *
 parcBuffer_PutUint16(PARCBuffer *buffer, uint16_t value)
 {
-    assertTrue(parcBuffer_Remaining(buffer) >= sizeof(uint16_t),
+    parcAssertTrue(parcBuffer_Remaining(buffer) >= sizeof(uint16_t),
                "Buffer overflow");
 
     parcBuffer_PutUint8(buffer, (value >> 8) & 0xFF);
@@ -830,7 +829,7 @@ parcBuffer_PutUint16(PARCBuffer *buffer, uint16_t value)
 PARCBuffer *
 parcBuffer_PutUint32(PARCBuffer *buffer, uint32_t value)
 {
-    assertTrue(parcBuffer_Remaining(buffer) >= sizeof(uint32_t),
+    parcAssertTrue(parcBuffer_Remaining(buffer) >= sizeof(uint32_t),
                "Buffer overflow");
     for (int i = sizeof(uint32_t) - 1; i > 0; i--) {
         uint8_t b = value >> (i * 8) & 0xFF;
@@ -843,7 +842,7 @@ parcBuffer_PutUint32(PARCBuffer *buffer, uint32_t value)
 PARCBuffer *
 parcBuffer_PutUint64(PARCBuffer *buffer, uint64_t value)
 {
-    assertTrue(parcBuffer_Remaining(buffer) >= sizeof(uint64_t),
+    parcAssertTrue(parcBuffer_Remaining(buffer) >= sizeof(uint64_t),
                "Buffer overflow");
     for (int i = sizeof(uint64_t) - 1; i > 0; i--) {
         uint8_t b = value >> (i * 8) & 0xFF;
@@ -857,7 +856,7 @@ PARCBuffer *
 parcBuffer_PutAtIndex(PARCBuffer *buffer, size_t index, uint8_t value)
 {
     parcBuffer_OptionalAssertValid(buffer);
-    assertTrue(_effectiveIndex(buffer, index) < parcBuffer_Limit(buffer), "Buffer overflow");
+    parcAssertTrue(_effectiveIndex(buffer, index) < parcBuffer_Limit(buffer), "Buffer overflow");
 
     parcByteArray_PutByte(buffer->array, _effectiveIndex(buffer, index), value);
     return buffer;
@@ -867,7 +866,7 @@ PARCBuffer *
 parcBuffer_PutArray(PARCBuffer *buffer, size_t arrayLength, const uint8_t array[arrayLength])
 {
     parcBuffer_OptionalAssertValid(buffer);
-    assertTrue(parcBuffer_Remaining(buffer) >= arrayLength,
+    parcAssertTrue(parcBuffer_Remaining(buffer) >= arrayLength,
                "Buffer overflow");
 
     parcByteArray_PutBytes(buffer->array, _effectivePosition(buffer), arrayLength, array);
@@ -884,7 +883,7 @@ PARCBuffer *
 parcBuffer_PutBuffer(PARCBuffer *result, const PARCBuffer *buffer)
 {
     parcBuffer_OptionalAssertValid(buffer);
-    assertTrue(parcBuffer_Remaining(result) >= parcBuffer_Remaining(buffer),
+    parcAssertTrue(parcBuffer_Remaining(result) >= parcBuffer_Remaining(buffer),
                "Buffer overflow. %zd bytes remaining, %zd required.", parcBuffer_Remaining(result), parcBuffer_Remaining(buffer));
 
     size_t length = parcBuffer_Remaining(buffer);
@@ -923,7 +922,7 @@ parcBuffer_ToString(const PARCBuffer *buffer)
 
     char *result = parcMemory_Allocate(remaining + 1);
     if (remaining > 0) {
-        assertNotNull(result, "parcMemory_Allocate returned NULL");
+        parcAssertNotNull(result, "parcMemory_Allocate returned NULL");
         if (result != NULL) {
             memcpy(result, parcBuffer_Overlay((PARCBuffer *) buffer, 0), remaining);
         }
@@ -965,7 +964,7 @@ parcBuffer_ToHexString(const PARCBuffer *buffer)
     // Hopefully length is less than (2^(sizeof(size_t)*8) / 2)
 
     char *result = parcMemory_AllocateAndClear((length * 2) + 1);
-    assertNotNull(result, "parcMemory_AllocateAndClear(%zu) returned NULL", (length * 2) + 1);
+    parcAssertNotNull(result, "parcMemory_AllocateAndClear(%zu) returned NULL", (length * 2) + 1);
 
     for (size_t i = 0; i < length; i++) {
         unsigned char byte = parcBuffer_GetAtIndex(buffer, i);
diff --git a/libparc/parc/algol/parc_Buffer.h b/libparc/parc/algol/parc_Buffer.h
index 2c7f56fd..665019db 100644
--- a/libparc/parc/algol/parc_Buffer.h
+++ b/libparc/parc/algol/parc_Buffer.h
@@ -140,7 +140,7 @@ extern parcObjectDescriptor_Declaration(PARCBuffer);
 /**
  * Assert that an instance of `PARCBuffer` is valid.
  *
- * If the instance is not valid, terminate via `trapIllegalValue()`
+ * If the instance is not valid, terminate via `parcTrapIllegalValue()`
  *
  * 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.
diff --git a/libparc/parc/algol/parc_BufferComposer.c b/libparc/parc/algol/parc_BufferComposer.c
index 20b7ecee..30e23acf 100755
--- a/libparc/parc/algol/parc_BufferComposer.c
+++ b/libparc/parc/algol/parc_BufferComposer.c
@@ -18,7 +18,7 @@
 
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <stdlib.h>
 #include <stdarg.h>
@@ -91,8 +91,8 @@ _ensureRemaining(PARCBufferComposer *composer, size_t required)
 void
 parcBufferComposer_AssertValid(const PARCBufferComposer *composer)
 {
-    trapIllegalValueIf(composer == NULL, "Parameter must be a non-null pointer to a valid PARCBufferComposer.");
-    trapIllegalValueIf(composer->incrementHeuristic < sizeof(void *), "Heuristic cannot be < sizeof(void *) (%zd), actual %zd", sizeof(void *), composer->incrementHeuristic);
+    parcTrapIllegalValueIf(composer == NULL, "Parameter must be a non-null pointer to a valid PARCBufferComposer.");
+    parcTrapIllegalValueIf(composer->incrementHeuristic < sizeof(void *), "Heuristic cannot be < sizeof(void *) (%zd), actual %zd", sizeof(void *), composer->incrementHeuristic);
 }
 
 PARCBufferComposer *
@@ -250,7 +250,7 @@ parcBufferComposer_Format(PARCBufferComposer *composer, const char *format, ...)
     va_start(ap, format);
     char *cString;
     ssize_t written = vasprintf(&cString, format, ap);
-    assertTrue(written >= 0, "Got error from vasprintf");
+    parcAssertTrue(written >= 0, "Got error from vasprintf");
     va_end(ap);
 
     parcBufferComposer_PutString(composer, cString);
diff --git a/libparc/parc/algol/parc_BufferComposer.h b/libparc/parc/algol/parc_BufferComposer.h
index f45aeb8e..25c69258 100755
--- a/libparc/parc/algol/parc_BufferComposer.h
+++ b/libparc/parc/algol/parc_BufferComposer.h
@@ -83,7 +83,7 @@ PARCBufferComposer *parcBufferComposer_Allocate(size_t length);
 /**
  * Assert that an instance of `PARCBufferComposer` is valid.
  *
- * If the instance is not valid, terminate via `trapIllegalValue()`.
+ * If the instance is not valid, terminate via `parcTrapIllegalValue()`.
  *
  * 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.
diff --git a/libparc/parc/algol/parc_BufferDictionary.c b/libparc/parc/algol/parc_BufferDictionary.c
index 56ed800a..c2438129 100755
--- a/libparc/parc/algol/parc_BufferDictionary.c
+++ b/libparc/parc/algol/parc_BufferDictionary.c
@@ -21,7 +21,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <parc/algol/parc_BufferDictionary.h>
 
@@ -73,8 +73,8 @@ _init(PARCBufferDictionary *result)
 static void
 _destroy(PARCBufferDictionary **dictionaryPtr)
 {
-    assertNotNull(dictionaryPtr, "Double pointer dictionaryPtr must be non-NULL");
-    assertNotNull(*dictionaryPtr, "Double pointer dictionaryPtr must dereference to non-NULL");
+    parcAssertNotNull(dictionaryPtr, "Double pointer dictionaryPtr must be non-NULL");
+    parcAssertNotNull(*dictionaryPtr, "Double pointer dictionaryPtr must dereference to non-NULL");
 
     PARCBufferDictionary *dict = *dictionaryPtr;
 
@@ -102,9 +102,9 @@ parcObject_ImplementRelease(parcBufferDictionary, PARCBufferDictionary);
 PARCBuffer *
 parcBufferDictionary_Put(PARCBufferDictionary *dictionary, PARCBuffer *key, PARCBuffer *value)
 {
-    assertNotNull(dictionary, "Parameter dictionary must be non-NULL");
-    assertNotNull(key, "Parameter key must be non-NULL");
-    assertNotNull(value, "Parameter value must be non-NULL");
+    parcAssertNotNull(dictionary, "Parameter dictionary must be non-NULL");
+    parcAssertNotNull(key, "Parameter key must be non-NULL");
+    parcAssertNotNull(value, "Parameter value must be non-NULL");
 
     PARCBuffer *oldValue = NULL;
 
@@ -126,8 +126,8 @@ parcBufferDictionary_Put(PARCBufferDictionary *dictionary, PARCBuffer *key, PARC
 PARCBuffer *
 parcBufferDictionary_Get(PARCBufferDictionary *dictionary, PARCBuffer *key)
 {
-    assertNotNull(dictionary, "Parameter dictionary must be non-NULL");
-    assertNotNull(key, "Parameter key must be non-NULL");
+    parcAssertNotNull(dictionary, "Parameter dictionary must be non-NULL");
+    parcAssertNotNull(key, "Parameter key must be non-NULL");
 
     return parcHashCodeTable_Get(dictionary->hashtable, key);
 }
@@ -135,8 +135,8 @@ parcBufferDictionary_Get(PARCBufferDictionary *dictionary, PARCBuffer *key)
 PARCBuffer *
 parcBufferDictionary_Remove(PARCBufferDictionary *dictionary, PARCBuffer *key)
 {
-    assertNotNull(dictionary, "Parameter dictionary must be non-NULL");
-    assertNotNull(key, "Parameter key must be non-NULL");
+    parcAssertNotNull(dictionary, "Parameter dictionary must be non-NULL");
+    parcAssertNotNull(key, "Parameter key must be non-NULL");
 
     // parcHashCodeTable_Del will free the referece, to make a copy of it
     PARCBuffer *original = (PARCBuffer *) parcHashCodeTable_Get(dictionary->hashtable, key);
diff --git a/libparc/parc/algol/parc_ByteArray.c b/libparc/parc/algol/parc_ByteArray.c
index 762421bd..1d81d211 100644
--- a/libparc/parc/algol/parc_ByteArray.c
+++ b/libparc/parc/algol/parc_ByteArray.c
@@ -21,7 +21,7 @@
 #include <ctype.h>
 #include <string.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <parc/algol/parc_ByteArray.h>
 #include <parc/algol/parc_Memory.h>
@@ -39,7 +39,7 @@ struct parc_byte_array {
 static inline void
 _trapIfOutOfBounds(const PARCByteArray *array, const size_t index)
 {
-    trapOutOfBoundsIf(index >= array->length, "parcByteArray index %zd exceeds the length %zd", index, array->length);
+    parcTrapOutOfBoundsIf(index >= array->length, "parcByteArray index %zd exceeds the length %zd", index, array->length);
 }
 
 static bool
@@ -66,7 +66,7 @@ parcObject_Override(PARCByteArray, PARCObject,
 void
 parcByteArray_AssertValid(const PARCByteArray *instance)
 {
-    trapInvalidValueIf(parcByteArray_IsValid(instance) == false,
+    parcTrapInvalidValueIf(parcByteArray_IsValid(instance) == false,
                        "PARCByteArray instance is invalid.");
 }
 
@@ -212,12 +212,12 @@ PARCByteArray *
 parcByteArray_PutBytes(PARCByteArray *result, size_t offset, size_t length, const uint8_t source[length])
 {
     parcByteArray_OptionalAssertValid(result);
-    trapOutOfBoundsIf(offset > result->length,
+    parcTrapOutOfBoundsIf(offset > result->length,
                       "The offset (%zd) exeeds the length (%zd) of the PARCByteArray.", offset, result->length);
 
     size_t available = result->length - offset;
 
-    trapOutOfBoundsIf(length > available, "%zd available bytes, %zd required.", available, length);
+    parcTrapOutOfBoundsIf(length > available, "%zd available bytes, %zd required.", available, length);
 
     memcpy(&result->array[offset], source, length);
     return result;
@@ -230,7 +230,7 @@ parcByteArray_GetBytes(const PARCByteArray *result, size_t offset, size_t length
 
     size_t available = result->length - offset;
 
-    trapOutOfBoundsIf(length > available, "parcByteArray_CopyOut %zd available bytes, %zd required", available, length);
+    parcTrapOutOfBoundsIf(length > available, "parcByteArray_CopyOut %zd available bytes, %zd required", available, length);
 
     memcpy(array, &result->array[offset], length);
     return (PARCByteArray *) result;
diff --git a/libparc/parc/algol/parc_ByteArray.h b/libparc/parc/algol/parc_ByteArray.h
index 98cc970a..c7a26285 100644
--- a/libparc/parc/algol/parc_ByteArray.h
+++ b/libparc/parc/algol/parc_ByteArray.h
@@ -91,7 +91,7 @@ typedef struct parc_byte_array PARCByteArray;
 /**
  * Assert that an instance of `PARCByteArray` is valid.
  *
- * If the instance is not valid, terminate via {@link trapIllegalValue}
+ * If the instance is not valid, terminate via {@link parcTrapIllegalValue}
  *
  * 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.
@@ -331,7 +331,7 @@ int parcByteArray_Compare(const PARCByteArray *a, const PARCByteArray *b);
  *
  * @return The given `PARCByteArray` pointer
  *
- * @throws SIGABRT `trapOutOfBounds` if the underlying `PARCByteArray` is not large enough
+ * @throws SIGABRT `parcTrapOutOfBounds` if the underlying `PARCByteArray` is not large enough
  *
  * Example:
  * @code
diff --git a/libparc/parc/algol/parc_Deque.c b/libparc/parc/algol/parc_Deque.c
index 4793b032..84808766 100644
--- a/libparc/parc/algol/parc_Deque.c
+++ b/libparc/parc/algol/parc_Deque.c
@@ -17,7 +17,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <stdio.h>
 #include <sys/queue.h>
@@ -104,27 +104,27 @@ _parcDequeNode_Destroy(PARCDeque *deque __attribute__((unused)), struct parc_deq
 static void
 _parcDequeNode_AssertInvariants(struct parc_deque_node *node)
 {
-    assertNotNull(node, "Expected non-null node pointer.");
+    parcAssertNotNull(node, "Expected non-null node pointer.");
     if (node->next != NULL) {
-        assertTrue(node->next->previous == node, "Expected next node to point to this node.");
+        parcAssertTrue(node->next->previous == node, "Expected next node to point to this node.");
     }
     if (node->previous != NULL) {
-        assertTrue(node->previous->next == node, "Expected previous node to point to this node.");
+        parcAssertTrue(node->previous->next == node, "Expected previous node to point to this node.");
     }
 }
 
 static void
 _parcDeque_AssertInvariants(const PARCDeque *deque)
 {
-    assertNotNull(deque, "Parameter cannot be null.");
+    parcAssertNotNull(deque, "Parameter cannot be null.");
     if (deque->head != NULL) {
-        assertTrue(deque->size != 0, "PARCDeque head is not-null, but size is zero.");
-        assertNotNull(deque->tail, "PARCDeque head is not-null, but tail is null.");
+        parcAssertTrue(deque->size != 0, "PARCDeque head is not-null, but size is zero.");
+        parcAssertNotNull(deque->tail, "PARCDeque head is not-null, but tail is null.");
         _parcDequeNode_AssertInvariants(deque->head);
         _parcDequeNode_AssertInvariants(deque->tail);
     } else {
-        assertNull(deque->tail, "PARCDeque head is null, but tail is not null.");
-        assertTrue(deque->size == 0, "PARCDeque head is null, but size is not zero.");
+        parcAssertNull(deque->tail, "PARCDeque head is null, but tail is not null.");
+        parcAssertTrue(deque->size == 0, "PARCDeque head is null, but size is not zero.");
     }
 }
 
@@ -159,7 +159,7 @@ _parcDequeNode_Next(PARCDeque *deque __attribute__((unused)), const struct parc_
     if (node == NULL) {
         return deque->head;
     }
-    trapOutOfBoundsIf(node->next == NULL, "No more elements.");
+    parcTrapOutOfBoundsIf(node->next == NULL, "No more elements.");
     return node->next;
 }
 
@@ -386,7 +386,7 @@ void *
 parcDeque_GetAtIndex(const PARCDeque *deque, size_t index)
 {
     if (index > (parcDeque_Size(deque) - 1)) {
-        trapOutOfBounds(index, "[0, %zd]", parcDeque_Size(deque) - 1);
+        parcTrapOutOfBounds(index, "[0, %zd]", parcDeque_Size(deque) - 1);
     }
     struct parc_deque_node *node = deque->head;
     while (index--) {
diff --git a/libparc/parc/algol/parc_Deque.h b/libparc/parc/algol/parc_Deque.h
index 3e11e845..57dd39b1 100755
--- a/libparc/parc/algol/parc_Deque.h
+++ b/libparc/parc/algol/parc_Deque.h
@@ -282,7 +282,7 @@ bool parcDeque_IsEmpty(const PARCDeque *deque);
  * @param [in] deque A pointer to a `PARCDeque` instance.
  * @param [in] index The index of the element to be retrieved.
  *
- * @throws `trapOutOfBounds`
+ * @throws `parcTrapOutOfBounds`
  *
  * Example:
  * @code
diff --git a/libparc/parc/algol/parc_Dictionary.c b/libparc/parc/algol/parc_Dictionary.c
index 628b08e2..a7a59de6 100755
--- a/libparc/parc/algol/parc_Dictionary.c
+++ b/libparc/parc/algol/parc_Dictionary.c
@@ -18,7 +18,7 @@
 
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <string.h>
 
@@ -43,10 +43,10 @@ parcDictionary_Create(PARCDictionary_CompareKey keyCompareFunction,
                       PARCDictionary_ValueEquals valueEqualsFunction,
                       PARCDictionary_FreeValue valueFreeFunction)
 {
-    assertNotNull(keyCompareFunction, "KeyCompareFunction can't be null");
-    assertNotNull(keyHashFunction, "KeyHashFunction can't be null");
+    parcAssertNotNull(keyCompareFunction, "KeyCompareFunction can't be null");
+    parcAssertNotNull(keyHashFunction, "KeyHashFunction can't be null");
     PARCDictionary *dictionary = parcMemory_Allocate(sizeof(PARCDictionary));
-    assertNotNull(dictionary, "parcMemory_Allocate(%zu) returned NULL", sizeof(PARCDictionary));
+    parcAssertNotNull(dictionary, "parcMemory_Allocate(%zu) returned NULL", sizeof(PARCDictionary));
     dictionary->keyCompareFunction = keyCompareFunction;
     dictionary->keyHashFunction = keyHashFunction;
     dictionary->keyFreeFunction = keyFreeFunction;
@@ -65,8 +65,8 @@ parcDictionary_Create(PARCDictionary_CompareKey keyCompareFunction,
 void
 parcDictionary_Destroy(PARCDictionary **dictionaryPointer)
 {
-    assertNotNull(dictionaryPointer, "Pointer to dictionary pointer can't be NULL");
-    assertNotNull(*dictionaryPointer, "Pointer to dictionary can't be NULL");
+    parcAssertNotNull(dictionaryPointer, "Pointer to dictionary pointer can't be NULL");
+    parcAssertNotNull(*dictionaryPointer, "Pointer to dictionary can't be NULL");
     parcTreeRedBlack_Destroy(&((*dictionaryPointer)->tree));
     parcMemory_Deallocate((void **) dictionaryPointer);
     *dictionaryPointer = NULL;
@@ -75,60 +75,60 @@ parcDictionary_Destroy(PARCDictionary **dictionaryPointer)
 void
 parcDictionary_SetValue(PARCDictionary *dictionary, void *key, void *value)
 {
-    assertNotNull(dictionary, "dictionary pointer can't be NULL");
-    assertNotNull(key, "Key pointer can't be NULL");
+    parcAssertNotNull(dictionary, "dictionary pointer can't be NULL");
+    parcAssertNotNull(key, "Key pointer can't be NULL");
     parcTreeRedBlack_Insert(dictionary->tree, key, value);
 }
 
 void *
 parcDictionary_GetValue(PARCDictionary *dictionary, const void *key)
 {
-    assertNotNull(dictionary, "dictionary pointer can't be NULL");
-    assertNotNull(key, "Key pointer can't be NULL");
+    parcAssertNotNull(dictionary, "dictionary pointer can't be NULL");
+    parcAssertNotNull(key, "Key pointer can't be NULL");
     return parcTreeRedBlack_Get(dictionary->tree, key);
 }
 
 void *
 parcDictionary_RemoveValue(PARCDictionary *dictionary, const void *key)
 {
-    assertNotNull(dictionary, "dictionary pointer can't be NULL");
-    assertNotNull(key, "Key pointer can't be NULL");
+    parcAssertNotNull(dictionary, "dictionary pointer can't be NULL");
+    parcAssertNotNull(key, "Key pointer can't be NULL");
     return parcTreeRedBlack_Remove(dictionary->tree, key);
 }
 
 void
 parcDictionary_RemoveAndDestroyValue(PARCDictionary *dictionary, const void *key)
 {
-    assertNotNull(dictionary, "dictionary pointer can't be NULL");
-    assertNotNull(key, "Key pointer can't be NULL");
+    parcAssertNotNull(dictionary, "dictionary pointer can't be NULL");
+    parcAssertNotNull(key, "Key pointer can't be NULL");
     parcTreeRedBlack_RemoveAndDestroy(dictionary->tree, key);
 }
 
 PARCArrayList *
 parcDictionary_Keys(const PARCDictionary *dictionary)
 {
-    assertNotNull(dictionary, "dictionary pointer can't be NULL");
+    parcAssertNotNull(dictionary, "dictionary pointer can't be NULL");
     return parcTreeRedBlack_Keys(dictionary->tree);
 }
 
 PARCArrayList *
 parcDictionary_Values(const PARCDictionary *dictionary)
 {
-    assertNotNull(dictionary, "dictionary pointer can't be NULL");
+    parcAssertNotNull(dictionary, "dictionary pointer can't be NULL");
     return parcTreeRedBlack_Values(dictionary->tree);
 }
 
 size_t
 parcDictionary_Size(const PARCDictionary *dictionary)
 {
-    assertNotNull(dictionary, "dictionary pointer can't be NULL");
+    parcAssertNotNull(dictionary, "dictionary pointer can't be NULL");
     return parcTreeRedBlack_Size(dictionary->tree);
 }
 
 int
 parcDictionary_Equals(const PARCDictionary *dictionary1, const PARCDictionary *dictionary2)
 {
-    assertNotNull(dictionary1, "dictionary pointer can't be NULL");
-    assertNotNull(dictionary2, "dictionary pointer can't be NULL");
+    parcAssertNotNull(dictionary1, "dictionary pointer can't be NULL");
+    parcAssertNotNull(dictionary2, "dictionary pointer can't be NULL");
     return parcTreeRedBlack_Equals(dictionary1->tree, dictionary2->tree);
 }
diff --git a/libparc/parc/algol/parc_DisplayIndented.c b/libparc/parc/algol/parc_DisplayIndented.c
index 5e043c15..39e1d76e 100755
--- a/libparc/parc/algol/parc_DisplayIndented.c
+++ b/libparc/parc/algol/parc_DisplayIndented.c
@@ -17,7 +17,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -39,7 +39,7 @@ _indent(int indentation)
 
     if (indentation > 0) {
         result = write(1, _spaces, indentation * _indentationFactor);
-        assertTrue(result == (indentation * _indentationFactor),
+        parcAssertTrue(result == (indentation * _indentationFactor),
                    "Write(2) failed to write %zd bytes.", indentation * _indentationFactor);
     }
     return result;
@@ -55,11 +55,11 @@ _parcDisplayIndented_Print(int indentation, char *string)
         _indent(indentation);
         if (end != NULL) {
             ssize_t nwritten = write(1, start, end - start + 1);
-            assertTrue(nwritten >= 0, "Error calling write");
+            parcAssertTrue(nwritten >= 0, "Error calling write");
             start = end + 1;
         } else {
             ssize_t nwritten = write(1, start, strlen(start));
-            assertTrue(nwritten >= 0, "Error calling write");
+            parcAssertTrue(nwritten >= 0, "Error calling write");
             break;
         }
         end = strchr(start, '\n');
@@ -74,14 +74,14 @@ parcDisplayIndented_PrintLine(int indentation, const char *format, ...)
 
     char *cString;
     int length = vasprintf(&cString, format, ap);
-    assertTrue(length >= 0, "Error in vasprintf");
+    parcAssertTrue(length >= 0, "Error in vasprintf");
 
     va_end(ap);
 
     _parcDisplayIndented_Print(indentation, cString);
 
     ssize_t nwritten = write(1, "\n", 1);
-    assertTrue(nwritten >= 0, "Error calling write");
+    parcAssertTrue(nwritten >= 0, "Error calling write");
 
     free(cString);
 }
@@ -98,7 +98,7 @@ parcDisplayIndented_PrintMemory(int indentation, size_t length, const char memor
     char *cString;
     for (size_t offset = 0; offset < length; /**/) {
         int nwritten = asprintf(&cString, "%p=[", &memory[offset]);
-        assertTrue(nwritten >= 0, "Error calling asprintf");
+        parcAssertTrue(nwritten >= 0, "Error calling asprintf");
         _parcDisplayIndented_Print(indentation, cString);
         free(cString);
 
diff --git a/libparc/parc/algol/parc_Event.c b/libparc/parc/algol/parc_Event.c
index 0a8391aa..1621edac 100755
--- a/libparc/parc/algol/parc_Event.c
+++ b/libparc/parc/algol/parc_Event.c
@@ -17,7 +17,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include "internal_parc_Event.h"
 #include <parc/algol/parc_EventScheduler.h>
@@ -70,7 +70,7 @@ PARCEvent *
 parcEvent_Create(PARCEventScheduler *parcEventScheduler, int fd, PARCEventType flags, PARCEvent_Callback *callback, void *callbackArgs)
 {
     PARCEvent *parcEvent = parcMemory_Allocate(sizeof(PARCEvent));
-    assertNotNull(parcEvent, "parcMemory_Allocate(%zu) returned NULL", sizeof(PARCEvent));
+    parcAssertNotNull(parcEvent, "parcMemory_Allocate(%zu) returned NULL", sizeof(PARCEvent));
 
     parcEvent->parcEventScheduler = parcEventScheduler;
     parcEvent->callback = callback;
@@ -78,7 +78,7 @@ parcEvent_Create(PARCEventScheduler *parcEventScheduler, int fd, PARCEventType f
 
     parcEvent->event = event_new(parcEventScheduler_GetEvBase(parcEventScheduler), fd,
                                  internal_PARCEventType_to_libevent_type(flags), _parc_event_callback, parcEvent);
-    assertNotNull(parcEvent->event, "Could not create a new event!");
+    parcAssertNotNull(parcEvent->event, "Could not create a new event!");
 
     parcEvent_LogDebug(parcEvent,
                        "parcEvent_Create(base=%p,fd=%x,events=%x,cb=%p,args=%p)\n",
@@ -91,7 +91,7 @@ int
 parcEvent_Start(PARCEvent *parcEvent)
 {
     parcEvent_LogDebug(parcEvent, "parcEvent_Start(%p)\n", parcEvent);
-    assertNotNull(parcEvent, "parcEvent_Start must be passed a valid event!");
+    parcAssertNotNull(parcEvent, "parcEvent_Start must be passed a valid event!");
 
     int result = event_add(parcEvent->event, NULL);
     return result;
@@ -101,7 +101,7 @@ int
 parcEvent_Stop(PARCEvent *parcEvent)
 {
     parcEvent_LogDebug(parcEvent, "parcEvent_Stop(%p)\n", parcEvent);
-    assertNotNull(parcEvent, "parcEvent_Stop must be passed a valid event!");
+    parcAssertNotNull(parcEvent, "parcEvent_Stop must be passed a valid event!");
 
     int result = event_del(parcEvent->event);
     return result;
@@ -111,7 +111,7 @@ int
 parcEvent_Poll(PARCEvent *parcEvent, PARCEventType event)
 {
     parcEvent_LogDebug(parcEvent, "parcEvent_Stop(%p)\n", parcEvent);
-    assertNotNull(parcEvent, "parcEvent_Stop must be passed a valid event!");
+    parcAssertNotNull(parcEvent, "parcEvent_Stop must be passed a valid event!");
 
     int result = event_pending(parcEvent->event, event, NULL);
     return result;
@@ -121,8 +121,8 @@ void
 parcEvent_Destroy(PARCEvent **parcEvent)
 {
     parcEvent_LogDebug((*parcEvent), "parcEvent_Destroy(%p)\n", *parcEvent);
-    assertNotNull(*parcEvent, "parcEvent_Destroy must be passed a valid parcEvent!");
-    assertNotNull((*parcEvent)->event, "parcEvent_Destroy passed a null event!");
+    parcAssertNotNull(*parcEvent, "parcEvent_Destroy must be passed a valid parcEvent!");
+    parcAssertNotNull((*parcEvent)->event, "parcEvent_Destroy passed a null event!");
 
     event_free((*parcEvent)->event);
     parcMemory_Deallocate((void **) parcEvent);
diff --git a/libparc/parc/algol/parc_EventBuffer.c b/libparc/parc/algol/parc_EventBuffer.c
index 49ba3354..6293680c 100644
--- a/libparc/parc/algol/parc_EventBuffer.c
+++ b/libparc/parc/algol/parc_EventBuffer.c
@@ -17,7 +17,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include "internal_parc_Event.h"
 #include <parc/algol/parc_Event.h>
@@ -55,10 +55,10 @@ parcEventBuffer_Create(void)
 {
     internal_parc_initializeLibevent();
     struct evbuffer *new_evbuffer = evbuffer_new();
-    assertNotNull(new_evbuffer, "libevent returned a null evbuffer.\n");
+    parcAssertNotNull(new_evbuffer, "libevent returned a null evbuffer.\n");
 
     PARCEventBuffer *parcEventBuffer = parcMemory_AllocateAndClear(sizeof(PARCEventBuffer));
-    assertNotNull(parcEventBuffer, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(PARCEventBuffer));
+    parcAssertNotNull(parcEventBuffer, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(PARCEventBuffer));
     parcEventBuffer->allocated_evbuffer = new_evbuffer;
     parcEventBuffer->evbuffer = parcEventBuffer->allocated_evbuffer;
 
@@ -71,8 +71,8 @@ void
 parcEventBuffer_Destroy(PARCEventBuffer **parcEventBuffer)
 {
     parcEventBuffer_LogDebug((*parcEventBuffer), "parcEventBuffer_Destroy(parcEventBuffer=%p)\n", *parcEventBuffer);
-    assertNotNull(parcEventBuffer, "parcEventBuffer_Destroy was passed a null parcEventBuffer pointer\n");
-    assertNotNull(*parcEventBuffer, "parcEventBuffer_Destroy was passed a null parcEventBuffer\n");
+    parcAssertNotNull(parcEventBuffer, "parcEventBuffer_Destroy was passed a null parcEventBuffer pointer\n");
+    parcAssertNotNull(*parcEventBuffer, "parcEventBuffer_Destroy was passed a null parcEventBuffer\n");
 
     // Destroy allocated eveventBuffer if it was allocated by us, otherwise it's owned by bufferevent
     if ((*parcEventBuffer)->allocated_evbuffer) {
@@ -100,7 +100,7 @@ parcEventBuffer_IsValid(const PARCEventBuffer *eventBuffer)
 void
 parcEventBuffer_AssertValid(const PARCEventBuffer *eventBuffer)
 {
-    assertTrue(parcEventBuffer_IsValid(eventBuffer),
+    parcAssertTrue(parcEventBuffer_IsValid(eventBuffer),
                "PARCEventBuffer@%p is not valid.", (void *) eventBuffer);
 }
 
@@ -109,7 +109,7 @@ parcEventBuffer_GetLength(PARCEventBuffer *parcEventBuffer)
 {
     parcEventBuffer_LogDebug(parcEventBuffer, "parcEventBuffer_GetLength(parcEventBuffer=%p)\n", parcEventBuffer);
 //    parcEventBuffer_OptionalAssertValid(parcEventBuffer);
-    assertNotNull(parcEventBuffer, "parcEventBuffer_GetLength was passed a null parcEventBuffer\n");
+    parcAssertNotNull(parcEventBuffer, "parcEventBuffer_GetLength was passed a null parcEventBuffer\n");
 
     if (parcEventBuffer->evbuffer) {
         return evbuffer_get_length(parcEventBuffer->evbuffer);
@@ -124,8 +124,8 @@ parcEventBuffer_Pullup(PARCEventBuffer *parcEventBuffer, ssize_t size)
     parcEventBuffer_LogDebug(parcEventBuffer, "parcEventBuffer_Pullup(parcEventBuffer=%p,size=%zx)\n", parcEventBuffer, size);
 
     parcEventBuffer_OptionalAssertValid(parcEventBuffer);
-//    assertNotNull(parcEventBuffer, "parcEventBuffer_Pullup was passed a null parcEventBuffer\n");
-//    assertNotNull(parcEventBuffer->evbuffer, "parcEventBuffer_Pullup was passed a null libevent evbuffer\n");
+//    parcAssertNotNull(parcEventBuffer, "parcEventBuffer_Pullup was passed a null parcEventBuffer\n");
+//    parcAssertNotNull(parcEventBuffer->evbuffer, "parcEventBuffer_Pullup was passed a null libevent evbuffer\n");
 
     return evbuffer_pullup(parcEventBuffer->evbuffer, (ev_ssize_t) size);
 }
@@ -135,10 +135,10 @@ parcEventBuffer_ReadIntoBuffer(PARCEventBuffer *source, PARCEventBuffer *destina
 {
     parcEventBuffer_OptionalAssertValid(source);
     parcEventBuffer_OptionalAssertValid(destination);
-//    assertNotNull(source, "parcEventBuffer_ReadIntoBuffer was passed a null source buffer\n");
-//    assertNotNull(source->evbuffer, "parcEventBuffer_ReadIntoBuffer was passed a null source evbuffer\n");
-//    assertNotNull(destination, "parcEventBuffer_ReadIntoBuffer was passed a null destination buffer\n");
-//    assertNotNull(destination->evbuffer, "parcEventBuffer_ReadIntoBuffer was passed a null destination evbuffer\n");
+//    parcAssertNotNull(source, "parcEventBuffer_ReadIntoBuffer was passed a null source buffer\n");
+//    parcAssertNotNull(source->evbuffer, "parcEventBuffer_ReadIntoBuffer was passed a null source evbuffer\n");
+//    parcAssertNotNull(destination, "parcEventBuffer_ReadIntoBuffer was passed a null destination buffer\n");
+//    parcAssertNotNull(destination->evbuffer, "parcEventBuffer_ReadIntoBuffer was passed a null destination evbuffer\n");
 
     return evbuffer_remove_buffer(source->evbuffer, destination->evbuffer, length);
 }
@@ -147,8 +147,8 @@ int
 parcEventBuffer_Read(PARCEventBuffer *readBuffer, void *data, size_t length)
 {
     parcEventBuffer_OptionalAssertValid(readBuffer);
-//    assertNotNull(readBuffer, "parcEventBuffer_Read was passed a null buffer\n");
-//    assertNotNull(readBuffer->evbuffer, "parcEventBuffer_Read was passed a null libevent evbuffer\n");
+//    parcAssertNotNull(readBuffer, "parcEventBuffer_Read was passed a null buffer\n");
+//    parcAssertNotNull(readBuffer->evbuffer, "parcEventBuffer_Read was passed a null libevent evbuffer\n");
 
     if (data == NULL) {
         return evbuffer_drain(readBuffer->evbuffer, length);
@@ -160,7 +160,7 @@ parcEventBuffer_Read(PARCEventBuffer *readBuffer, void *data, size_t length)
 int
 parcEventBuffer_copyOut(PARCEventBuffer *readBuffer, void *data_out, size_t length)
 {
-    assertNotNull(data_out, "parcEventBuffer_Copy was passed a null data_out buffer\n");
+    parcAssertNotNull(data_out, "parcEventBuffer_Copy was passed a null data_out buffer\n");
     parcEventBuffer_OptionalAssertValid(readBuffer);
     return evbuffer_copyout(readBuffer->evbuffer, data_out, length);
 }
@@ -170,8 +170,8 @@ parcEventBuffer_WriteToFileDescriptor(PARCEventBuffer *writeBuffer, int fd, ssiz
 {
     parcEventBuffer_OptionalAssertValid(writeBuffer);
 
-//    assertNotNull(writeBuffer, "parcEventBuffer_WriteToFileDescriptor was passed a null buffer\n");
-//    assertNotNull(writeBuffer->evbuffer, "parcEventBuffer_WriteToFileDescriptor was passed a null libevent evbuffer\n");
+//    parcAssertNotNull(writeBuffer, "parcEventBuffer_WriteToFileDescriptor was passed a null buffer\n");
+//    parcAssertNotNull(writeBuffer->evbuffer, "parcEventBuffer_WriteToFileDescriptor was passed a null libevent evbuffer\n");
 
     return evbuffer_write_atmost(writeBuffer->evbuffer, fd, length);
 }
@@ -180,8 +180,8 @@ int
 parcEventBuffer_ReadFromFileDescriptor(PARCEventBuffer *readBuffer, int fd, size_t length)
 {
     parcEventBuffer_OptionalAssertValid(readBuffer);
-//    assertNotNull(readBuffer, "parcEventBuffer_ReadFromFileDescriptor was passed a null buffer\n");
-//    assertNotNull(readBuffer->evbuffer, "parcEventBuffer_ReadFromFileDescriptor was passed a null libevent evbuffer\n");
+//    parcAssertNotNull(readBuffer, "parcEventBuffer_ReadFromFileDescriptor was passed a null buffer\n");
+//    parcAssertNotNull(readBuffer->evbuffer, "parcEventBuffer_ReadFromFileDescriptor was passed a null libevent evbuffer\n");
 
     return evbuffer_read(readBuffer->evbuffer, fd, (int) length);
 }
@@ -190,8 +190,8 @@ void
 parcEventBuffer_FreeLine(PARCEventBuffer *readBuffer, char **line)
 {
     parcEventBuffer_OptionalAssertValid(readBuffer);
-//    assertNotNull(readBuffer, "parcEventBuffer_ReadLine was passed a null readBuffer\n");
-//    assertNotNull(readBuffer->evbuffer, "parcEventBuffer_ReadLine was passed a null libevent evbuffer\n");
+//    parcAssertNotNull(readBuffer, "parcEventBuffer_ReadLine was passed a null readBuffer\n");
+//    parcAssertNotNull(readBuffer->evbuffer, "parcEventBuffer_ReadLine was passed a null libevent evbuffer\n");
 
     parcMemory_Deallocate((void **) line);
 }
@@ -200,8 +200,8 @@ char *
 parcEventBuffer_ReadLine(PARCEventBuffer *readBuffer, size_t *length)
 {
     parcEventBuffer_OptionalAssertValid(readBuffer);
-//    assertNotNull(readBuffer, "parcEventBuffer_ReadLine was passed a null readBuffer\n");
-//    assertNotNull(readBuffer->evbuffer, "parcEventBuffer_ReadLine was passed a null libevent evbuffer\n");
+//    parcAssertNotNull(readBuffer, "parcEventBuffer_ReadLine was passed a null readBuffer\n");
+//    parcAssertNotNull(readBuffer->evbuffer, "parcEventBuffer_ReadLine was passed a null libevent evbuffer\n");
 
     return evbuffer_readln(readBuffer->evbuffer, length, EVBUFFER_EOL_CRLF);
 }
@@ -211,10 +211,10 @@ parcEventBuffer_AppendBuffer(PARCEventBuffer *source, PARCEventBuffer *destinati
 {
     parcEventBuffer_OptionalAssertValid(source);
     parcEventBuffer_OptionalAssertValid(destination);
-//    assertNotNull(source, "parcEventBuffer_AppendBuffer was passed a null source parcEventBuffer\n");
-//    assertNotNull(destination, "parcEventBuffer_AppendBuffer was passed a null destination parcEventBuffer\n");
-//    assertNotNull(source->evbuffer, "parcEventBuffer_AppendBuffer was passed a null source libevent evbuffer\n");
-//    assertNotNull(destination->evbuffer, "parcEventBuffer_AppendBuffer was passed a null destination libevent evbuffer\n");
+//    parcAssertNotNull(source, "parcEventBuffer_AppendBuffer was passed a null source parcEventBuffer\n");
+//    parcAssertNotNull(destination, "parcEventBuffer_AppendBuffer was passed a null destination parcEventBuffer\n");
+//    parcAssertNotNull(source->evbuffer, "parcEventBuffer_AppendBuffer was passed a null source libevent evbuffer\n");
+//    parcAssertNotNull(destination->evbuffer, "parcEventBuffer_AppendBuffer was passed a null destination libevent evbuffer\n");
 
     return evbuffer_add_buffer(destination->evbuffer, source->evbuffer);
 }
@@ -223,9 +223,9 @@ int
 parcEventBuffer_Append(PARCEventBuffer *parcEventBuffer, void *data, size_t length)
 {
     parcEventBuffer_OptionalAssertValid(parcEventBuffer);
-//    assertNotNull(parcEventBuffer, "parcEventBuffer_Append was passed a null parcEventBuffer\n");
-//    assertNotNull(parcEventBuffer->evbuffer, "parcEventBuffer_Append was passed a null libevent evbuffer\n");
-    assertNotNull(data, "parcEventBuffer_Append was passed a null data buffer\n");
+//    parcAssertNotNull(parcEventBuffer, "parcEventBuffer_Append was passed a null parcEventBuffer\n");
+//    parcAssertNotNull(parcEventBuffer->evbuffer, "parcEventBuffer_Append was passed a null libevent evbuffer\n");
+    parcAssertNotNull(data, "parcEventBuffer_Append was passed a null data buffer\n");
 
     return evbuffer_add(parcEventBuffer->evbuffer, data, length);
 }
@@ -234,9 +234,9 @@ int
 parcEventBuffer_Prepend(PARCEventBuffer *readBuffer, void *data, size_t length)
 {
     parcEventBuffer_OptionalAssertValid(readBuffer);
-//    assertNotNull(readBuffer->evbuffer, "parcEventBuffer_Prepend was passed a null libevent evbuffer\n");
-//    assertNotNull(readBuffer, "parcEventBuffer_Prepend was passed a null buffer\n");
-    assertNotNull(data, "parcEventBuffer_Prepend was passed a null data buffer\n");
+//    parcAssertNotNull(readBuffer->evbuffer, "parcEventBuffer_Prepend was passed a null libevent evbuffer\n");
+//    parcAssertNotNull(readBuffer, "parcEventBuffer_Prepend was passed a null buffer\n");
+    parcAssertNotNull(data, "parcEventBuffer_Prepend was passed a null data buffer\n");
 
     return evbuffer_prepend(readBuffer->evbuffer, data, length);
 }
@@ -244,10 +244,10 @@ parcEventBuffer_Prepend(PARCEventBuffer *readBuffer, void *data, size_t length)
 PARCEventBuffer *
 parcEventBuffer_GetQueueBufferInput(PARCEventQueue *queue)
 {
-    assertNotNull(queue, "parcEventBuffer_GetQueueBufferInput was passed a null queue\n");
+    parcAssertNotNull(queue, "parcEventBuffer_GetQueueBufferInput was passed a null queue\n");
 
     PARCEventBuffer *parcEventBuffer = parcMemory_AllocateAndClear(sizeof(PARCEventBuffer));
-    assertNotNull(parcEventBuffer, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(PARCEventBuffer));
+    parcAssertNotNull(parcEventBuffer, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(PARCEventBuffer));
 
     parcEventBuffer->evbuffer = internal_parcEventQueue_GetEvInputBuffer(queue);
     parcEventBuffer_LogDebug(parcEventBuffer, "parcEventBuffer_GetQueueBufferInput(queue=%p)\n", queue);
@@ -258,10 +258,10 @@ parcEventBuffer_GetQueueBufferInput(PARCEventQueue *queue)
 PARCEventBuffer *
 parcEventBuffer_GetQueueBufferOutput(PARCEventQueue *queue)
 {
-    assertNotNull(queue, "parcEventBuffer_GetQueueBufferOutput was passed a null queue\n");
+    parcAssertNotNull(queue, "parcEventBuffer_GetQueueBufferOutput was passed a null queue\n");
 
     PARCEventBuffer *parcEventBuffer = parcMemory_AllocateAndClear(sizeof(PARCEventBuffer));
-    assertNotNull(parcEventBuffer, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(PARCEventBuffer));
+    parcAssertNotNull(parcEventBuffer, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(PARCEventBuffer));
 
     parcEventBuffer->evbuffer = internal_parcEventQueue_GetEvOutputBuffer(queue);
     parcEventBuffer_LogDebug(parcEventBuffer, "parcEventBuffer_GetQueueBufferInput(queue=%p)\n", queue);
diff --git a/libparc/parc/algol/parc_EventQueue.c b/libparc/parc/algol/parc_EventQueue.c
index 5d656a12..dffab1e7 100755
--- a/libparc/parc/algol/parc_EventQueue.c
+++ b/libparc/parc/algol/parc_EventQueue.c
@@ -18,7 +18,7 @@
 #include <config.h>
 #include <errno.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include "internal_parc_Event.h"
 #include <parc/algol/parc_EventScheduler.h>
@@ -70,7 +70,7 @@ _parc_queue_read_callback(struct bufferevent *bev, void *ptr)
     parcEventQueue_LogDebug(parcEventQueue,
                             "_parc_queue_read_callback(bev=%p,ptr->buffereventBuffer=%p,parcEventQueue=%p)\n",
                             bev, parcEventQueue->buffereventBuffer, parcEventQueue);
-    assertNotNull(parcEventQueue->readCallback, "parcEvent read callback called when NULL");
+    parcAssertNotNull(parcEventQueue->readCallback, "parcEvent read callback called when NULL");
 
     parcEventQueue->readCallback(parcEventQueue, PARCEventType_Read, parcEventQueue->readUserData);
 }
@@ -82,7 +82,7 @@ _parc_queue_write_callback(struct bufferevent *bev, void *ptr)
     parcEventQueue_LogDebug(parcEventQueue,
                             "_parc_queue_write_callback(bev=%p,ptr->buffereventBuffer=%p,parcEventQueue=%p)\n",
                             bev, parcEventQueue->buffereventBuffer, parcEventQueue);
-    assertNotNull(parcEventQueue->writeCallback, "parcEvent write callback called when NULL");
+    parcAssertNotNull(parcEventQueue->writeCallback, "parcEvent write callback called when NULL");
 
     parcEventQueue->writeCallback(parcEventQueue, PARCEventType_Write, parcEventQueue->writeUserData);
 }
@@ -95,7 +95,7 @@ _parc_queue_event_callback(struct bufferevent *bev, short events, void *ptr)
     parcEventQueue_LogDebug(parcEventQueue,
                             "_parc_queue_event_callback(bev=%p,events=%x,errno=%d,ptr->buffereventBuffer=%p,parcEventQueue=%p)\n",
                             bev, events, errno, parcEventQueue->buffereventBuffer, parcEventQueue);
-    assertNotNull(parcEventQueue->eventCallback, "parcEvent event callback called when NULL");
+    parcAssertNotNull(parcEventQueue->eventCallback, "parcEvent event callback called when NULL");
 
     errno = errno_forwarded;
     parcEventQueue->eventCallback(parcEventQueue, internal_bufferevent_type_to_PARCEventQueueEventType(events), parcEventQueue->eventUserData);
@@ -130,9 +130,9 @@ parcEventQueue_SetCallbacks(PARCEventQueue *parcEventQueue,
 PARCEventQueue *
 parcEventQueue_Create(PARCEventScheduler *eventScheduler, int fd, PARCEventQueueOption flags)
 {
-    assertNotNull(eventScheduler, "parcEventQueue_Create passed a NULL scheduler instance.");
+    parcAssertNotNull(eventScheduler, "parcEventQueue_Create passed a NULL scheduler instance.");
     PARCEventQueue *parcEventQueue = parcMemory_AllocateAndClear(sizeof(PARCEventQueue));
-    assertNotNull(parcEventQueue, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(PARCEventQueue));
+    parcAssertNotNull(parcEventQueue, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(PARCEventQueue));
     parcEventQueue->eventScheduler = eventScheduler;
 
     //
@@ -145,7 +145,7 @@ parcEventQueue_Create(PARCEventScheduler *eventScheduler, int fd, PARCEventQueue
     //
     parcEventQueue->buffereventBuffer = bufferevent_socket_new(parcEventScheduler_GetEvBase(eventScheduler), fd,
                                                                internal_PARCEventQueueOption_to_bufferevent_options(flags));
-    assertNotNull(parcEventQueue->buffereventBuffer,
+    parcAssertNotNull(parcEventQueue->buffereventBuffer,
                   "Got null from bufferevent_socket_new for socket %d", fd);
 
     parcEventQueue_LogDebug(parcEventQueue,
@@ -161,7 +161,7 @@ void
 parcEventQueue_Destroy(PARCEventQueue **parcEventQueue)
 {
     parcEventQueue_LogDebug((*parcEventQueue), "parcEventQueue_Destroy(ptr=%p)\n", *parcEventQueue);
-    assertNotNull((*parcEventQueue)->buffereventBuffer, "parcEventQueue_Destroy passed a null buffer!");
+    parcAssertNotNull((*parcEventQueue)->buffereventBuffer, "parcEventQueue_Destroy passed a null buffer!");
 
     bufferevent_free((*parcEventQueue)->buffereventBuffer);
     parcMemory_Deallocate((void *) parcEventQueue);
@@ -226,7 +226,7 @@ int
 parcEventQueue_Printf(PARCEventQueue *parcEventQueue, const char *fmt, ...)
 {
     struct evbuffer *buffer = bufferevent_get_output(parcEventQueue->buffereventBuffer);
-    assertNotNull(buffer, "bufferevent_get_output returned NULL");
+    parcAssertNotNull(buffer, "bufferevent_get_output returned NULL");
 
     va_list ap;
 
@@ -258,9 +258,9 @@ parcEventQueue_SetPriority(PARCEventQueue *eventQueue, PARCEventPriority priorit
 PARCEventQueuePair *
 parcEventQueue_CreateConnectedPair(PARCEventScheduler *eventScheduler)
 {
-    assertNotNull(eventScheduler, "parcEventQueue_CreateConnectedPair must be passed a valid Event Scheduler");
+    parcAssertNotNull(eventScheduler, "parcEventQueue_CreateConnectedPair must be passed a valid Event Scheduler");
     PARCEventQueuePair *parcEventQueuePair = parcMemory_AllocateAndClear(sizeof(PARCEventQueuePair));
-    assertNotNull(parcEventQueuePair, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(PARCEventQueuePair));
+    parcAssertNotNull(parcEventQueuePair, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(PARCEventQueuePair));
 
     parcEventQueuePair->up = parcMemory_AllocateAndClear(sizeof(PARCEventQueue));
     parcEventQueuePair->up->eventScheduler = eventScheduler;
@@ -269,7 +269,7 @@ parcEventQueue_CreateConnectedPair(PARCEventScheduler *eventScheduler)
                             eventScheduler,
                             parcEventScheduler_GetEvBase(eventScheduler),
                             parcEventQueuePair->up);
-    assertNotNull(parcEventQueuePair->up, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(PARCEventQueue));
+    parcAssertNotNull(parcEventQueuePair->up, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(PARCEventQueue));
 
     parcEventQueuePair->down = parcMemory_AllocateAndClear(sizeof(PARCEventQueue));
     parcEventQueuePair->down->eventScheduler = eventScheduler;
@@ -278,7 +278,7 @@ parcEventQueue_CreateConnectedPair(PARCEventScheduler *eventScheduler)
                             eventScheduler,
                             parcEventScheduler_GetEvBase(eventScheduler),
                             parcEventQueuePair->down);
-    assertNotNull(parcEventQueuePair->down, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(PARCEventQueue));
+    parcAssertNotNull(parcEventQueuePair->down, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(PARCEventQueue));
 
     struct bufferevent *evpair[2];
     int result = bufferevent_pair_new(parcEventScheduler_GetEvBase(eventScheduler), 0, evpair);
diff --git a/libparc/parc/algol/parc_EventScheduler.c b/libparc/parc/algol/parc_EventScheduler.c
index 55de5c52..3983740e 100755
--- a/libparc/parc/algol/parc_EventScheduler.c
+++ b/libparc/parc/algol/parc_EventScheduler.c
@@ -17,7 +17,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <stdio.h>
 #include <unistd.h>
@@ -76,17 +76,17 @@ parcEventScheduler_Create(void)
     internal_parc_initializeLibevent();
 
     PARCEventScheduler *parcEventScheduler = parcMemory_Allocate(sizeof(PARCEventScheduler));
-    assertNotNull(parcEventScheduler, "parcMemory_Allocate(%zu) returned NULL", sizeof(PARCEventScheduler));
+    parcAssertNotNull(parcEventScheduler, "parcMemory_Allocate(%zu) returned NULL", sizeof(PARCEventScheduler));
 
     // Initialize libevent base pointer.
     parcEventScheduler->evbase = event_base_new();
 
-    assertNotNull(parcEventScheduler->evbase, "Could not obtain an event base!");
+    parcAssertNotNull(parcEventScheduler->evbase, "Could not obtain an event base!");
     int result = event_base_priority_init(parcEventScheduler->evbase, PARCEventPriority_NumberOfPriorities);
-    assertTrue(result == 0, "Could not set scheduler priorities (%d)", result);
+    parcAssertTrue(result == 0, "Could not set scheduler priorities (%d)", result);
 
     parcEventScheduler->log = _parc_logger_create();
-    assertNotNull(parcEventScheduler->log, "Could not create parc logger");
+    parcAssertNotNull(parcEventScheduler->log, "Could not create parc logger");
 
     parcEventScheduler_LogDebug(parcEventScheduler, "parcEventScheduler_Create() = %p\n", parcEventScheduler);
 
@@ -97,7 +97,7 @@ int
 parcEventScheduler_Start(PARCEventScheduler *parcEventScheduler, PARCEventSchedulerDispatchType type)
 {
     parcEventScheduler_LogDebug(parcEventScheduler, "parcEventScheduler_Start(%p, %d)\n", parcEventScheduler, type);
-    assertNotNull(parcEventScheduler, "parcEventScheduler_Start must be passed a valid base parcEventScheduler!");
+    parcAssertNotNull(parcEventScheduler, "parcEventScheduler_Start must be passed a valid base parcEventScheduler!");
     int result = event_base_loop(parcEventScheduler->evbase,
                                  internal_PARCEventSchedulerDispatchType_to_eventloop_options(type));
     return result;
@@ -119,7 +119,7 @@ int
 parcEventScheduler_Stop(PARCEventScheduler *parcEventScheduler, struct timeval *delay)
 {
     parcEventScheduler_LogDebug(parcEventScheduler, "parcEventScheduler_Stop(%p, %p)\n", parcEventScheduler, delay);
-    assertNotNull(parcEventScheduler, "parcEventScheduler_Stop must be passed a valid base parcEventScheduler!");
+    parcAssertNotNull(parcEventScheduler, "parcEventScheduler_Stop must be passed a valid base parcEventScheduler!");
     int result = event_base_loopexit(parcEventScheduler->evbase, delay);
     return result;
 }
@@ -128,7 +128,7 @@ int
 parcEventScheduler_Abort(PARCEventScheduler *parcEventScheduler)
 {
     parcEventScheduler_LogDebug(parcEventScheduler, "parcEventScheduler_Abort(%p)\n", parcEventScheduler);
-    assertNotNull(parcEventScheduler, "parcEventScheduler_Abort must be passed a valid base parcEventScheduler!");
+    parcAssertNotNull(parcEventScheduler, "parcEventScheduler_Abort must be passed a valid base parcEventScheduler!");
     int result = event_base_loopbreak(parcEventScheduler->evbase);
     return result;
 }
@@ -156,8 +156,8 @@ parcEventScheduler_Destroy(PARCEventScheduler **parcEventScheduler)
 {
     parcEventScheduler_LogDebug((*parcEventScheduler), "parcEventScheduler_Destroy(%p)\n", *parcEventScheduler);
 
-    assertNotNull(*parcEventScheduler, "parcEventScheduler_Destroy must be passed a valid base parcEventScheduler!");
-    assertNotNull((*parcEventScheduler)->evbase, "parcEventScheduler_Destroy passed a NULL event base member!");
+    parcAssertNotNull(*parcEventScheduler, "parcEventScheduler_Destroy must be passed a valid base parcEventScheduler!");
+    parcAssertNotNull((*parcEventScheduler)->evbase, "parcEventScheduler_Destroy passed a NULL event base member!");
 
     event_base_free((*parcEventScheduler)->evbase);
     parcLog_Release(&((*parcEventScheduler)->log));
diff --git a/libparc/parc/algol/parc_EventSignal.c b/libparc/parc/algol/parc_EventSignal.c
index 7b8d1191..7bb094bd 100755
--- a/libparc/parc/algol/parc_EventSignal.c
+++ b/libparc/parc/algol/parc_EventSignal.c
@@ -17,7 +17,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include "internal_parc_Event.h"
 #include <parc/algol/parc_EventScheduler.h>
@@ -66,7 +66,7 @@ PARCEventSignal *
 parcEventSignal_Create(PARCEventScheduler *eventScheduler, int signal, PARCEventType flags, PARCEvent_Callback *callback, void *callbackArgs)
 {
     PARCEventSignal *parcEventSignal = parcMemory_Allocate(sizeof(PARCEventSignal));
-    assertNotNull(parcEventSignal, "parcMemory_Allocate(%zu) returned NULL", sizeof(PARCEventSignal));
+    parcAssertNotNull(parcEventSignal, "parcMemory_Allocate(%zu) returned NULL", sizeof(PARCEventSignal));
 
     parcEventSignal->eventScheduler = eventScheduler;
     parcEventSignal->callback = callback;
@@ -75,7 +75,7 @@ parcEventSignal_Create(PARCEventScheduler *eventScheduler, int signal, PARCEvent
     parcEventSignal->event = event_new(parcEventScheduler_GetEvBase(eventScheduler), signal,
                                        internal_PARCEventType_to_libevent_type(flags),
                                        _parc_event_signal_callback, parcEventSignal);
-    assertNotNull(parcEventSignal->event, "Could not create a new event!");
+    parcAssertNotNull(parcEventSignal->event, "Could not create a new event!");
 
     parcEventSignal_LogDebug(parcEventSignal,
                              "parcEventSignal_Create(base=%p,signal=%x,flags=%x,cb=%p,args=%p) = %p\n",
@@ -88,7 +88,7 @@ int
 parcEventSignal_Start(PARCEventSignal *parcEventSignal)
 {
     parcEventSignal_LogDebug(parcEventSignal, "parcEventSignal_Start(event=%p)\n", parcEventSignal);
-    assertNotNull(parcEventSignal, "parcEventStart_Signal must be passed a valid event!");
+    parcAssertNotNull(parcEventSignal, "parcEventStart_Signal must be passed a valid event!");
 
     int result = event_add(parcEventSignal->event, NULL);
     return result;
@@ -98,7 +98,7 @@ int
 parcEventSignal_Stop(PARCEventSignal *parcEventSignal)
 {
     parcEventSignal_LogDebug(parcEventSignal, "parcEventSignal_Stop(event=%p)\n", parcEventSignal);
-    assertNotNull(parcEventSignal, "parcEvent_Stop must be passed a valid event!");
+    parcAssertNotNull(parcEventSignal, "parcEvent_Stop must be passed a valid event!");
 
     int result = event_del(parcEventSignal->event);
     return result;
@@ -108,8 +108,8 @@ void
 parcEventSignal_Destroy(PARCEventSignal **parcEventSignal)
 {
     parcEventSignal_LogDebug((*parcEventSignal), "parcEventSignal_Destroy(event=%p)\n", parcEventSignal);
-    assertNotNull(*parcEventSignal, "parcEvent_Destroy must be passed a valid parcEventSignal!");
-    assertNotNull((*parcEventSignal)->event, "parcEvent_Destroy passed a null event!");
+    parcAssertNotNull(*parcEventSignal, "parcEvent_Destroy must be passed a valid parcEventSignal!");
+    parcAssertNotNull((*parcEventSignal)->event, "parcEvent_Destroy passed a null event!");
     event_free((*parcEventSignal)->event);
     parcMemory_Deallocate((void **) parcEventSignal);
 }
diff --git a/libparc/parc/algol/parc_EventSocket.c b/libparc/parc/algol/parc_EventSocket.c
index dcb2fd69..62aa10bc 100755
--- a/libparc/parc/algol/parc_EventSocket.c
+++ b/libparc/parc/algol/parc_EventSocket.c
@@ -17,7 +17,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <parc/algol/parc_EventScheduler.h>
 #include <parc/algol/parc_EventSocket.h>
@@ -87,7 +87,7 @@ parcEventSocket_Create(PARCEventScheduler *eventScheduler,
                        void *userData, const struct sockaddr *sa, int socklen)
 {
     PARCEventSocket *parcEventSocket = parcMemory_AllocateAndClear(sizeof(PARCEventSocket));
-    assertNotNull(parcEventSocket, "parcMemory_Allocate(%zu) returned NULL", sizeof(PARCEventSocket));
+    parcAssertNotNull(parcEventSocket, "parcMemory_Allocate(%zu) returned NULL", sizeof(PARCEventSocket));
 
     parcEventSocket->eventScheduler = eventScheduler;
     parcEventSocket->socketCallback = callback;
@@ -118,7 +118,7 @@ parcEventSocket_Create(PARCEventScheduler *eventScheduler,
 void
 parcEventSocket_Destroy(PARCEventSocket **socketEvent)
 {
-    assertNotNull(*socketEvent, "parcEventSocket_Destroy must be passed a valid socketEvent!");
+    parcAssertNotNull(*socketEvent, "parcEventSocket_Destroy must be passed a valid socketEvent!");
 
     if ((*socketEvent)->listener) {
         evconnlistener_free((*socketEvent)->listener);
diff --git a/libparc/parc/algol/parc_EventTimer.c b/libparc/parc/algol/parc_EventTimer.c
index 529188b1..82f731b1 100755
--- a/libparc/parc/algol/parc_EventTimer.c
+++ b/libparc/parc/algol/parc_EventTimer.c
@@ -17,7 +17,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include "internal_parc_Event.h"
 #include <parc/algol/parc_EventTimer.h>
@@ -62,7 +62,7 @@ PARCEventTimer *
 parcEventTimer_Create(PARCEventScheduler *eventScheduler, PARCEventType flags, PARCEvent_Callback *callback, void *callbackArgs)
 {
     PARCEventTimer *parcEventTimer = parcMemory_Allocate(sizeof(PARCEventTimer));
-    assertNotNull(parcEventTimer, "parcMemory_Allocate(%zu) returned NULL", sizeof(PARCEventTimer));
+    parcAssertNotNull(parcEventTimer, "parcMemory_Allocate(%zu) returned NULL", sizeof(PARCEventTimer));
 
     parcEventTimer->eventScheduler = eventScheduler;
     parcEventTimer->callback = callback;
@@ -72,7 +72,7 @@ parcEventTimer_Create(PARCEventScheduler *eventScheduler, PARCEventType flags, P
     parcEventTimer->event = event_new(parcEventScheduler_GetEvBase(eventScheduler), -1,
                                       internal_PARCEventType_to_libevent_type(flags),
                                       _parc_event_timer_callback, parcEventTimer);
-    assertNotNull(parcEventTimer->event, "Could not create a new event!");
+    parcAssertNotNull(parcEventTimer->event, "Could not create a new event!");
 
     parcEventTimer_LogDebug(parcEventTimer,
                             "parcEventTimer_Create(base=%p,events=%x,cb=%p,args=%p) = %p\n",
@@ -88,7 +88,7 @@ parcEventTimer_Start(PARCEventTimer *parcEventTimer, struct timeval *timeout)
     parcEventTimer_LogDebug(parcEventTimer,
                             "parcEventTimer_Start(event=%p, timeout=%d:%d)\n",
                             parcEventTimer, timeout->tv_sec, timeout->tv_usec);
-    assertNotNull(parcEventTimer, "parcEventTimer_Start must be passed a valid event!");
+    parcAssertNotNull(parcEventTimer, "parcEventTimer_Start must be passed a valid event!");
 
     int result = event_add(parcEventTimer->event, timeout);
     return result;
@@ -98,7 +98,7 @@ int
 parcEventTimer_Stop(PARCEventTimer *parcEventTimer)
 {
     parcEventTimer_LogDebug(parcEventTimer, "parcEventTimer_Stop(event=%p)\n", parcEventTimer);
-    assertNotNull(parcEventTimer, "parcEventTimer_Stop must be passed a valid event!");
+    parcAssertNotNull(parcEventTimer, "parcEventTimer_Stop must be passed a valid event!");
 
     int result = event_del(parcEventTimer->event);
     return result;
@@ -108,8 +108,8 @@ void
 parcEventTimer_Destroy(PARCEventTimer **parcEventTimer)
 {
     parcEventTimer_LogDebug((*parcEventTimer), "parcEventTimer_Destroy(parcEventTimer=%p)\n", *parcEventTimer);
-    assertNotNull(*parcEventTimer, "parcEventTimer_Destroy must be passed a valid parcEventTimer!");
-    assertNotNull((*parcEventTimer)->event, "parcEventTimer_Destroy passed a null event!");
+    parcAssertNotNull(*parcEventTimer, "parcEventTimer_Destroy must be passed a valid parcEventTimer!");
+    parcAssertNotNull((*parcEventTimer)->event, "parcEventTimer_Destroy passed a null event!");
 
     event_free((*parcEventTimer)->event);
     parcMemory_Deallocate((void **) parcEventTimer);
diff --git a/libparc/parc/algol/parc_File.c b/libparc/parc/algol/parc_File.c
index 2ab307a2..353ffcca 100644
--- a/libparc/parc/algol/parc_File.c
+++ b/libparc/parc/algol/parc_File.c
@@ -37,7 +37,7 @@
 #include <string.h>
 #include <errno.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <parc/algol/parc_Object.h>
 #include <parc/algol/parc_PathName.h>
@@ -66,8 +66,8 @@ parcObject_Override(PARCFile, PARCObject,
 void
 parcFile_AssertValid(const PARCFile *instance)
 {
-    trapIllegalValueIf(instance == NULL, "Parameter must be a non-null pointer to a valid PARCFile.");
-    trapIllegalValueIf(instance->pathName == NULL, "PARCFile cannot have a NULL path-name");
+    parcTrapIllegalValueIf(instance == NULL, "Parameter must be a non-null pointer to a valid PARCFile.");
+    parcTrapIllegalValueIf(instance->pathName == NULL, "PARCFile cannot have a NULL path-name");
 }
 
 PARCFile *
@@ -194,10 +194,10 @@ parcFile_Delete(const PARCFile *file)
     char *string = parcPathName_ToString(file->pathName);
 
     // only allow under tmp
-    assertTrue(strncmp(string, "/tmp/", 5) == 0,
+    parcAssertTrue(strncmp(string, "/tmp/", 5) == 0,
                "Path must begin with /tmp/: %s", string);
     // dont allow ".."
-    assertNull(strstr(string, ".."), "Path cannot have .. in it: %s", string);
+    parcAssertNull(strstr(string, ".."), "Path cannot have .. in it: %s", string);
 
     bool result = false;
     if (parcFile_IsDirectory(file)) {
@@ -208,7 +208,7 @@ parcFile_Delete(const PARCFile *file)
         int maximumFileDescriptors = 20;
 
         int failure = nftw(string, _deleteNode, maximumFileDescriptors, flags);
-        assertFalse(failure, "Error on recursive delete: (%d) %s", errno, strerror(errno));
+        parcAssertFalse(failure, "Error on recursive delete: (%d) %s", errno, strerror(errno));
 
         result = failure == false;
     } else {
diff --git a/libparc/parc/algol/parc_FileInputStream.c b/libparc/parc/algol/parc_FileInputStream.c
index f42ced73..186d07b5 100755
--- a/libparc/parc/algol/parc_FileInputStream.c
+++ b/libparc/parc/algol/parc_FileInputStream.c
@@ -24,7 +24,7 @@
 #include <unistd.h>
 #include <sys/stat.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <parc/algol/parc_Memory.h>
 #include <parc/algol/parc_File.h>
@@ -70,7 +70,7 @@ parcFileInputStream_Open(const PARCFile *file)
 PARCFileInputStream *
 parcFileInputStream_Create(int fileDescriptor)
 {
-    trapIllegalValueIf(fileDescriptor < 0, "File descriptor must not be negative.");
+    parcTrapIllegalValueIf(fileDescriptor < 0, "File descriptor must not be negative.");
 
     PARCFileInputStream *result = parcObject_CreateInstance(PARCFileInputStream);
     if (result != NULL) {
diff --git a/libparc/parc/algol/parc_FileInputStream.h b/libparc/parc/algol/parc_FileInputStream.h
index 3641e08a..f7f7987a 100755
--- a/libparc/parc/algol/parc_FileInputStream.h
+++ b/libparc/parc/algol/parc_FileInputStream.h
@@ -140,7 +140,7 @@ void parcFileInputStream_Release(PARCFileInputStream **inputStreamPtr);
  *
  *     parcFileOutputStream_Write(stream, buffer);
  *
- *     assertFalse(parcBuffer_HasRemaining(buffer), "Expected the buffer to be emtpy");
+ *     parcAssertFalse(parcBuffer_HasRemaining(buffer), "Expected the buffer to be emtpy");
  *
  *     parcBuffer_Release(&buffer);
  *
diff --git a/libparc/parc/algol/parc_FileOutputStream.c b/libparc/parc/algol/parc_FileOutputStream.c
index a17dc66c..3e5c8cd6 100755
--- a/libparc/parc/algol/parc_FileOutputStream.c
+++ b/libparc/parc/algol/parc_FileOutputStream.c
@@ -20,7 +20,7 @@
 #include <stdio.h>
 #include <unistd.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <parc/algol/parc_FileOutputStream.h>
 #include <parc/algol/parc_Object.h>
@@ -48,7 +48,7 @@ parcObject_ExtendPARCObject(PARCFileOutputStream, _destroy, NULL, NULL, NULL, NU
 PARCFileOutputStream *
 parcFileOutputStream_Create(int fileDescriptor)
 {
-    assertTrue(fileDescriptor != -1, "Invalid file descriptor");
+    parcAssertTrue(fileDescriptor != -1, "Invalid file descriptor");
 
     PARCFileOutputStream *result = parcObject_CreateInstance(PARCFileOutputStream);
     result->fd = fileDescriptor;
diff --git a/libparc/parc/algol/parc_FileOutputStream.h b/libparc/parc/algol/parc_FileOutputStream.h
index 51251561..a9708b0d 100644
--- a/libparc/parc/algol/parc_FileOutputStream.h
+++ b/libparc/parc/algol/parc_FileOutputStream.h
@@ -130,7 +130,7 @@ void parcFileOutputStream_Release(PARCFileOutputStream **streamPtr);
  *
  *     parcFileOutputStream_Write(stream, buffer);
  *
- *     assertFalse(parcBuffer_HasRemaining(buffer), "Expected the buffer to be emtpy");
+ *     parcAssertFalse(parcBuffer_HasRemaining(buffer), "Expected the buffer to be emtpy");
  *
  *     parcBuffer_Release(&buffer);
  *
diff --git a/libparc/parc/algol/parc_HashCodeTable.c b/libparc/parc/algol/parc_HashCodeTable.c
index ea1945b3..9531e312 100755
--- a/libparc/parc/algol/parc_HashCodeTable.c
+++ b/libparc/parc/algol/parc_HashCodeTable.c
@@ -28,7 +28,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <stdio.h>
 #include <string.h>
@@ -181,7 +181,7 @@ _expand(PARCHashCodeTable *hashCodeTable)
         temp_table.tableLimit = old_table->tableLimit * expandby;
         temp_table.expandThreshold = temp_table.tableLimit - temp_table.tableLimit / 4;
         temp_table.entries = parcMemory_AllocateAndClear(temp_table.tableLimit * sizeof(HashTableEntry));
-        assertNotNull(temp_table.entries, "parcMemory_AllocateAndClear(%zu) returned NULL", temp_table.tableLimit * sizeof(HashTableEntry));
+        parcAssertNotNull(temp_table.entries, "parcMemory_AllocateAndClear(%zu) returned NULL", temp_table.tableLimit * sizeof(HashTableEntry));
 
         result = _rehash(old_table, &temp_table, hashCodeTable->keyEqualsFunc);
         if (result == ADD_NOSPACE) {
@@ -203,11 +203,11 @@ parcHashCodeTable_Create_Size(PARCHashCodeTable_KeyEqualsFunc keyEqualsFunc,
                               size_t minimumSize)
 {
     PARCHashCodeTable *table = parcMemory_AllocateAndClear(sizeof(PARCHashCodeTable));
-    assertNotNull(table, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(PARCHashCodeTable));
+    parcAssertNotNull(table, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(PARCHashCodeTable));
 
-    assertNotNull(keyEqualsFunc, "keyEqualsFunc must be non-null");
-    assertNotNull(keyHashCodeFunc, "keyHashCodeFunc must be non-null");
-    assertTrue(minimumSize > 0, "minimumSize must be greater than zero");
+    parcAssertNotNull(keyEqualsFunc, "keyEqualsFunc must be non-null");
+    parcAssertNotNull(keyHashCodeFunc, "keyHashCodeFunc must be non-null");
+    parcAssertTrue(minimumSize > 0, "minimumSize must be greater than zero");
 
     table->keyEqualsFunc = keyEqualsFunc;
     table->keyHashCodeFunc = keyHashCodeFunc;
@@ -215,7 +215,7 @@ parcHashCodeTable_Create_Size(PARCHashCodeTable_KeyEqualsFunc keyEqualsFunc,
     table->dataDestroyer = dataDestroyer;
 
     table->hashtable.entries = parcMemory_AllocateAndClear(minimumSize * sizeof(HashTableEntry));
-    assertNotNull(table->hashtable.entries, "parcMemory_AllocateAndClear(%zu) returned NULL", minimumSize * sizeof(HashTableEntry));
+    parcAssertNotNull(table->hashtable.entries, "parcMemory_AllocateAndClear(%zu) returned NULL", minimumSize * sizeof(HashTableEntry));
     table->hashtable.tableLimit = minimumSize;
     table->hashtable.tableSize = 0;
 
@@ -239,8 +239,8 @@ parcHashCodeTable_Create(PARCHashCodeTable_KeyEqualsFunc keyEqualsFunc,
 void
 parcHashCodeTable_Destroy(PARCHashCodeTable **tablePtr)
 {
-    assertNotNull(tablePtr, "Parameter must be non-null double pointer");
-    assertNotNull(*tablePtr, "Parameter must dereference to non-null pointer");
+    parcAssertNotNull(tablePtr, "Parameter must be non-null double pointer");
+    parcAssertNotNull(*tablePtr, "Parameter must dereference to non-null pointer");
     PARCHashCodeTable *table = *tablePtr;
     size_t i;
 
@@ -264,9 +264,9 @@ parcHashCodeTable_Destroy(PARCHashCodeTable **tablePtr)
 bool
 parcHashCodeTable_Add(PARCHashCodeTable *table, void *key, void *data)
 {
-    assertNotNull(table, "Parameter table must be non-null");
-    assertNotNull(key, "Parameter key must be non-null");
-    assertNotNull(data, "Parameter data must be non-null");
+    parcAssertNotNull(table, "Parameter table must be non-null");
+    parcAssertNotNull(key, "Parameter key must be non-null");
+    parcAssertNotNull(data, "Parameter data must be non-null");
 
     if (table->hashtable.tableSize >= table->hashtable.expandThreshold) {
         _expand(table);
@@ -291,13 +291,13 @@ parcHashCodeTable_Del(PARCHashCodeTable *table, const void *key)
     size_t index;
     bool found;
 
-    assertNotNull(table, "Parameter table must be non-null");
-    assertNotNull(key, "parameter key must be non-null");
+    parcAssertNotNull(table, "Parameter table must be non-null");
+    parcAssertNotNull(key, "parameter key must be non-null");
 
     found = _findIndex(table, key, &index);
 
     if (found) {
-        assertTrue(table->hashtable.tableSize > 0, "Illegal state: found entry in a hash table with 0 size");
+        parcAssertTrue(table->hashtable.tableSize > 0, "Illegal state: found entry in a hash table with 0 size");
 
         if (table->keyDestroyer) {
             table->keyDestroyer(&table->hashtable.entries[index].key);
@@ -318,8 +318,8 @@ parcHashCodeTable_Get(PARCHashCodeTable *table, const void *key)
 {
     size_t index;
 
-    assertNotNull(table, "Parameter table must be non-null");
-    assertNotNull(key, "parameter key must be non-null");
+    parcAssertNotNull(table, "Parameter table must be non-null");
+    parcAssertNotNull(key, "parameter key must be non-null");
 
     bool found = _findIndex(table, key, &index);
 
@@ -333,6 +333,6 @@ parcHashCodeTable_Get(PARCHashCodeTable *table, const void *key)
 size_t
 parcHashCodeTable_Length(const PARCHashCodeTable *table)
 {
-    assertNotNull(table, "Parameter table must be non-null");
+    parcAssertNotNull(table, "Parameter table must be non-null");
     return table->hashtable.tableSize;
 }
diff --git a/libparc/parc/algol/parc_HashMap.c b/libparc/parc/algol/parc_HashMap.c
index 35a4414f..5e73a4c3 100644
--- a/libparc/parc/algol/parc_HashMap.c
+++ b/libparc/parc/algol/parc_HashMap.c
@@ -16,7 +16,7 @@
 /**
  */
 #include <config.h>
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <parc/algol/parc_Object.h>
 #include <parc/algol/parc_DisplayIndented.h>
@@ -54,7 +54,7 @@ _parcHashMapEntry_IsValid(_PARCHashMapEntry *hashEntry)
 static void
 _parcHashMapEntry_Finalize(_PARCHashMapEntry **instancePtr)
 {
-    assertNotNull(instancePtr, "Parameter must be a non-null pointer to a PARCHashMap pointer.");
+    parcAssertNotNull(instancePtr, "Parameter must be a non-null pointer to a PARCHashMap pointer.");
     _PARCHashMapEntry *hashMapEntry = *instancePtr;
 
     _parcHashMapEntry_IsValid(hashMapEntry);
@@ -134,7 +134,7 @@ _parcHashMapEntry_Create(const PARCObject *key, const PARCObject *value)
 static void
 _parcHashMap_Finalize(PARCHashMap **instancePtr)
 {
-    assertNotNull(instancePtr, "Parameter must be a non-null pointer to a PARCHashMap pointer.");
+    parcAssertNotNull(instancePtr, "Parameter must be a non-null pointer to a PARCHashMap pointer.");
     PARCHashMap *hashMap = *instancePtr;
 
     for (unsigned int i = 0; i < hashMap->capacity; i++) {
@@ -157,7 +157,7 @@ parcObject_ExtendPARCObject(PARCHashMap, _parcHashMap_Finalize, parcHashMap_Copy
 void
 parcHashMap_AssertValid(const PARCHashMap *instance)
 {
-    assertTrue(parcHashMap_IsValid(instance),
+    parcAssertTrue(parcHashMap_IsValid(instance),
                "PARCHashMap is not valid.");
 }
 
@@ -566,7 +566,7 @@ _parcHashMap_Init(PARCHashMap *map __attribute__((unused)))
             }
         }
 
-        trapOutOfMemoryIf(state->listIterator == NULL, "Cannot create parcLinkedList_CreateIterator");
+        parcTrapOutOfMemoryIf(state->listIterator == NULL, "Cannot create parcLinkedList_CreateIterator");
     }
 
     return state;
@@ -613,7 +613,7 @@ _parcHashMap_HasNext(PARCHashMap *map __attribute__((unused)), _PARCHashMapItera
                 if (map->buckets[state->bucket] != NULL) {
                     parcIterator_Release(&state->listIterator);
                     state->listIterator = parcLinkedList_CreateIterator(map->buckets[state->bucket]);
-                    trapOutOfMemoryIf(state->listIterator == NULL, "Cannot create parcLinkedList_CreateIterator");
+                    parcTrapOutOfMemoryIf(state->listIterator == NULL, "Cannot create parcLinkedList_CreateIterator");
                     result = parcIterator_HasNext(state->listIterator);
                 }
             }
diff --git a/libparc/parc/algol/parc_Iterator.c b/libparc/parc/algol/parc_Iterator.c
index e70a0ff9..5ef67bf4 100755
--- a/libparc/parc/algol/parc_Iterator.c
+++ b/libparc/parc/algol/parc_Iterator.c
@@ -77,12 +77,12 @@ parcIterator_Create(PARCObject *object,
                     void (*fini)(PARCObject *, void *),
                     void (*assertValid)(const void *))
 {
-    assertNotNull(object, "PARCObject cannot be NULL.");
-    assertNotNull(init, "'init' function cannot be NULL.");
-    assertNotNull(hasNext, "'hasNext' function cannot be NULL.");
-    assertNotNull(next, "'next' function cannot be NULL.");
-    assertNotNull(element, "'element' function cannot be NULL.");
-    assertNotNull(fini, "'fini' function cannot be NULL.");
+    parcAssertNotNull(object, "PARCObject cannot be NULL.");
+    parcAssertNotNull(init, "'init' function cannot be NULL.");
+    parcAssertNotNull(hasNext, "'hasNext' function cannot be NULL.");
+    parcAssertNotNull(next, "'next' function cannot be NULL.");
+    parcAssertNotNull(element, "'element' function cannot be NULL.");
+    parcAssertNotNull(fini, "'fini' function cannot be NULL.");
 
     PARCIterator *result = parcObject_CreateInstance(PARCIterator);
 
@@ -120,7 +120,7 @@ parcIterator_IsValid(const PARCIterator *iterator)
 void
 parcIterator_AssertValid(const PARCIterator *iterator)
 {
-    assertTrue(parcIterator_IsValid(iterator), "PARCIterator is not valid.");
+    parcAssertTrue(parcIterator_IsValid(iterator), "PARCIterator is not valid.");
 }
 
 parcObject_ImplementAcquire(parcIterator, PARCIterator);
diff --git a/libparc/parc/algol/parc_Iterator.h b/libparc/parc/algol/parc_Iterator.h
index 275a16e7..1f402cba 100644
--- a/libparc/parc/algol/parc_Iterator.h
+++ b/libparc/parc/algol/parc_Iterator.h
@@ -62,7 +62,7 @@ typedef struct parc_iterator PARCIterator;
  *
  * * `next`
  * Returns the next element in the iteration.
- * If there are no remaining elements in the iteration, then this function must induce a trapOutOfBounds
+ * If there are no remaining elements in the iteration, then this function must induce a parcTrapOutOfBounds
  *
  * * `remove`
  * Removes the element returned by the `next` function.
diff --git a/libparc/parc/algol/parc_JSON.c b/libparc/parc/algol/parc_JSON.c
index d70a302e..f69396d2 100755
--- a/libparc/parc/algol/parc_JSON.c
+++ b/libparc/parc/algol/parc_JSON.c
@@ -17,7 +17,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <stdio.h>
 #include <ctype.h>
diff --git a/libparc/parc/algol/parc_JSONArray.c b/libparc/parc/algol/parc_JSONArray.c
index 87421e12..a92e6422 100755
--- a/libparc/parc/algol/parc_JSONArray.c
+++ b/libparc/parc/algol/parc_JSONArray.c
@@ -18,7 +18,7 @@
 
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 #include <parc/algol/parc_JSONArray.h>
 
 #include <parc/algol/parc_Object.h>
@@ -54,8 +54,8 @@ static const PARCObjectDescriptor parcArrayValue_ObjInterface = {
 void
 parcJSONArray_AssertValid(const PARCJSONArray *array)
 {
-    assertNotNull(array, "Must be a non-null pointer to a PARCJSONArray instance.");
-    assertNotNull(array->array, "Must be a non-null pointer to a PARCDeque instance.");
+    parcAssertNotNull(array, "Must be a non-null pointer to a PARCJSONArray instance.");
+    parcAssertNotNull(array->array, "Must be a non-null pointer to a PARCDeque instance.");
 }
 
 PARCJSONArray *
diff --git a/libparc/parc/algol/parc_JSONArray.h b/libparc/parc/algol/parc_JSONArray.h
index 32fa9817..7b322867 100755
--- a/libparc/parc/algol/parc_JSONArray.h
+++ b/libparc/parc/algol/parc_JSONArray.h
@@ -95,7 +95,7 @@ void parcJSONArray_Release(PARCJSONArray **arrayPtr);
 /**
  * Assert that an instance of `PARCJSONArray` is valid.
  *
- * If the instance is not valid, terminate via {@link trapIllegalValue}
+ * If the instance is not valid, terminate via {@link parcTrapIllegalValue}
  *
  * 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.
diff --git a/libparc/parc/algol/parc_JSONPair.c b/libparc/parc/algol/parc_JSONPair.c
index a5df700f..11676523 100755
--- a/libparc/parc/algol/parc_JSONPair.c
+++ b/libparc/parc/algol/parc_JSONPair.c
@@ -20,7 +20,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <stdio.h>
 #include <ctype.h>
@@ -49,7 +49,7 @@ _destroyJSONPair(PARCJSONPair **pairPtr)
 {
     if (pairPtr != NULL) {
         PARCJSONPair *pair = *pairPtr;
-        assertNotNull(pair, "Parameter must be a non-null pointer to a valid PARCJSONPair.");
+        parcAssertNotNull(pair, "Parameter must be a non-null pointer to a valid PARCJSONPair.");
         parcBuffer_Release(&pair->name);
         parcJSONValue_Release(&pair->value);
     }
diff --git a/libparc/parc/algol/parc_JSONParser.c b/libparc/parc/algol/parc_JSONParser.c
index a0022597..a8a0510b 100755
--- a/libparc/parc/algol/parc_JSONParser.c
+++ b/libparc/parc/algol/parc_JSONParser.c
@@ -17,7 +17,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <ctype.h>
 #include <string.h>
@@ -59,7 +59,7 @@ parcJSONParser_Create(PARCBuffer *buffer)
 void
 parcJSONParser_AssertValid(const PARCJSONParser *parser)
 {
-    assertNotNull(parser, "PARCJSONParser cannot be NULL");
+    parcAssertNotNull(parser, "PARCJSONParser cannot be NULL");
     parcBuffer_OptionalAssertValid(parser->buffer);
 }
 
@@ -166,7 +166,7 @@ parcJSONParser_ParseString(PARCJSONParser *parser)
                     c = '\t';
                 } else if (c == 'u') {
                     // Not supporting unicode at this point.
-                    trapNotImplemented("Unicode is not supported.");
+                    parcTrapNotImplemented("Unicode is not supported.");
                 }
             } else if (iscntrl(c)) {
                 // !! Syntax Error.
diff --git a/libparc/parc/algol/parc_JSONParser.h b/libparc/parc/algol/parc_JSONParser.h
index 18ee9d1a..425a2427 100755
--- a/libparc/parc/algol/parc_JSONParser.h
+++ b/libparc/parc/algol/parc_JSONParser.h
@@ -64,7 +64,7 @@ PARCJSONParser *parcJSONParser_Create(PARCBuffer *buffer);
 /**
  * Assert that an instance of `PARCJSONParser` is valid.
  *
- * If the instance is not valid, terminate via {@link trapIllegalValue()}
+ * If the instance is not valid, terminate via {@link parcTrapIllegalValue()}
  *
  * 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.
diff --git a/libparc/parc/algol/parc_JSONValue.c b/libparc/parc/algol/parc_JSONValue.c
index 3a3ba9cd..f5aff0b4 100755
--- a/libparc/parc/algol/parc_JSONValue.c
+++ b/libparc/parc/algol/parc_JSONValue.c
@@ -17,7 +17,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <stdio.h>
 #include <ctype.h>
@@ -463,7 +463,7 @@ _displayNumber(const PARCJSONValue *value, int indentation)
 void
 parcJSONValue_AssertValid(const PARCJSONValue *value)
 {
-    assertNotNull(value, "PARCJSONValue cannot be NULL.");
+    parcAssertNotNull(value, "PARCJSONValue cannot be NULL.");
 }
 
 bool
@@ -577,7 +577,7 @@ parcJSONValue_CreateFromString(PARCBuffer *value)
 PARCJSONValue *
 parcJSONValue_CreateFromCString(const char *value)
 {
-    assertNotNull(value, "String cannot be NULL.");
+    parcAssertNotNull(value, "String cannot be NULL.");
 
     PARCJSONValue *result = _createValue(PARCJSONValueType_String);
     if (result != NULL) {
@@ -663,7 +663,7 @@ parcJSONValue_Display(const PARCJSONValue *value, int indentation)
                 parcDisplayIndented_PrintLine(indentation + 1, ".value=null");
                 break;
             default:
-                trapIllegalValue(value->type, "Unknown PARCJSONValue type %d", value->type);
+                parcTrapIllegalValue(value->type, "Unknown PARCJSONValue type %d", value->type);
         }
     }
     parcDisplayIndented_PrintLine(indentation, "}");
@@ -739,7 +739,7 @@ parcJSONValue_GetArray(const PARCJSONValue *value)
 {
     parcJSONValue_OptionalAssertValid(value);
 
-    trapUnexpectedStateIf(!parcJSONValue_IsArray(value), "Expected type to be array, actual type %d", value->type);
+    parcTrapUnexpectedStateIf(!parcJSONValue_IsArray(value), "Expected type to be array, actual type %d", value->type);
 
     return value->value.array;
 }
@@ -749,7 +749,7 @@ parcJSONValue_GetBoolean(const PARCJSONValue *value)
 {
     parcJSONValue_OptionalAssertValid(value);
 
-    trapUnexpectedStateIf(!parcJSONValue_IsBoolean(value), "Expected type to be boolean, actual type %d", value->type);
+    parcTrapUnexpectedStateIf(!parcJSONValue_IsBoolean(value), "Expected type to be boolean, actual type %d", value->type);
 
     return value->value.boolean;
 }
@@ -793,7 +793,7 @@ parcJSONValue_GetString(const PARCJSONValue *value)
 {
     parcJSONValue_OptionalAssertValid(value);
 
-    trapUnexpectedStateIf(!parcJSONValue_IsString(value), "Expected type to be string, actual type %d", value->type);
+    parcTrapUnexpectedStateIf(!parcJSONValue_IsString(value), "Expected type to be string, actual type %d", value->type);
 
     return value->value.string;
 }
@@ -803,7 +803,7 @@ parcJSONValue_GetJSON(const PARCJSONValue *value)
 {
     parcJSONValue_OptionalAssertValid(value);
 
-    trapUnexpectedStateIf(!parcJSONValue_IsJSON(value), "Expected type to be string, actual type %d", value->type);
+    parcTrapUnexpectedStateIf(!parcJSONValue_IsJSON(value), "Expected type to be string, actual type %d", value->type);
 
     return value->value.object;
 }
@@ -811,7 +811,7 @@ parcJSONValue_GetJSON(const PARCJSONValue *value)
 struct timeval *
 parcJSONValue_GetTimeval(const PARCJSONValue *jsonTimeval, struct timeval *timeval)
 {
-    assertNotNull(jsonTimeval, "Parameter jsonTimeval must be a non-null PARCJSON pointer.");
+    parcAssertNotNull(jsonTimeval, "Parameter jsonTimeval must be a non-null PARCJSON pointer.");
 
     PARCJSON *json = parcJSONValue_GetJSON(jsonTimeval);
     PARCJSONValue *value = parcJSON_GetValueByName(json, "seconds");
@@ -825,7 +825,7 @@ parcJSONValue_GetTimeval(const PARCJSONValue *jsonTimeval, struct timeval *timev
 struct timespec *
 parcJSONValue_GetTimespec(const PARCJSONValue *jsonTimespec, struct timespec *timespec)
 {
-    assertNotNull(jsonTimespec, "Parameter jsonTimeval must be a non-null PARCJSON pointer.");
+    parcAssertNotNull(jsonTimespec, "Parameter jsonTimeval must be a non-null PARCJSON pointer.");
 
     PARCJSON *json = parcJSONValue_GetJSON(jsonTimespec);
     PARCJSONValue *value = parcJSON_GetValueByName(json, "seconds");
@@ -911,7 +911,7 @@ parcJSONValue_BuildString(const PARCJSONValue *value, PARCBufferComposer *compos
     } else if (value->type == PARCJSONValueType_Null) {
         parcBufferComposer_PutString(composer, "null");
     } else {
-        trapIllegalValue(value->type, "Unknown value type: %d", value->type);
+        parcTrapIllegalValue(value->type, "Unknown value type: %d", value->type);
     }
 
     return composer;
diff --git a/libparc/parc/algol/parc_JSONValue.h b/libparc/parc/algol/parc_JSONValue.h
index 300a1c0c..0f93b2bc 100755
--- a/libparc/parc/algol/parc_JSONValue.h
+++ b/libparc/parc/algol/parc_JSONValue.h
@@ -174,7 +174,7 @@ bool parcJSONValue_IsValid(const PARCJSONValue *value);
 /**
  * Assert that an instance of `PARCJSONValue` is valid.
  *
- * If the instance is not valid, terminate via {@link trapIllegalValue()}
+ * If the instance is not valid, terminate via {@link parcTrapIllegalValue()}
  *
  * 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.
diff --git a/libparc/parc/algol/parc_KeyValue.c b/libparc/parc/algol/parc_KeyValue.c
index 27b20f35..352bf3e8 100755
--- a/libparc/parc/algol/parc_KeyValue.c
+++ b/libparc/parc/algol/parc_KeyValue.c
@@ -24,7 +24,7 @@
 #include "parc_KeyValue.h"
 #include "parc_Object.h"
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 struct parc_key_value {
     PARCObject *key;
@@ -52,10 +52,10 @@ PARCKeyValue *
 parcKeyValue_Create(const PARCObject *key,
                     const PARCObject *value)
 {
-    assertNotNull(key, "Key may not be null in a KeyValue element");
+    parcAssertNotNull(key, "Key may not be null in a KeyValue element");
 
     PARCKeyValue *keyValue = parcObject_CreateInstance(PARCKeyValue);
-    assertNotNull(keyValue, "parcMemory_Allocate(%zu) returned NULL", sizeof(PARCKeyValue));
+    parcAssertNotNull(keyValue, "parcMemory_Allocate(%zu) returned NULL", sizeof(PARCKeyValue));
 
     keyValue->key = parcObject_Acquire(key);
     keyValue->value = NULL;
@@ -82,7 +82,7 @@ parcKeyValue_Copy(const PARCKeyValue *source)
 void
 parcKeyValue_SetValue(PARCKeyValue *keyValue, PARCObject *value)
 {
-    assertNotNull(keyValue, "Not a valid keyValue");
+    parcAssertNotNull(keyValue, "Not a valid keyValue");
     PARCObject *oldValue = keyValue->value;
     if (value != NULL) {
         keyValue->value = parcObject_Acquire(value);
@@ -97,7 +97,7 @@ parcKeyValue_SetValue(PARCKeyValue *keyValue, PARCObject *value)
 void
 parcKeyValue_SetKey(PARCKeyValue *keyValue, PARCObject *key)
 {
-    assertNotNull(keyValue, "Not a valid keyValue");
+    parcAssertNotNull(keyValue, "Not a valid keyValue");
     PARCObject *oldKey = keyValue->key;
     keyValue->key = parcObject_Acquire(key);
     parcObject_Release(&oldKey);
@@ -106,14 +106,14 @@ parcKeyValue_SetKey(PARCKeyValue *keyValue, PARCObject *key)
 PARCObject *
 parcKeyValue_GetValue(PARCKeyValue *keyValue)
 {
-    assertNotNull(keyValue, "Not a valid keyValue");
+    parcAssertNotNull(keyValue, "Not a valid keyValue");
     return keyValue->value;
 }
 
 PARCObject *
 parcKeyValue_GetKey(PARCKeyValue *keyValue)
 {
-    assertNotNull(keyValue, "Not a valid keyValue");
+    parcAssertNotNull(keyValue, "Not a valid keyValue");
     return keyValue->key;
 }
 
diff --git a/libparc/parc/algol/parc_KeyedElement.c b/libparc/parc/algol/parc_KeyedElement.c
index a55de891..265987cd 100755
--- a/libparc/parc/algol/parc_KeyedElement.c
+++ b/libparc/parc/algol/parc_KeyedElement.c
@@ -21,7 +21,7 @@
 
 #include <string.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <parc/algol/parc_KeyedElement.h>
 #include <parc/algol/parc_Memory.h>
@@ -36,10 +36,10 @@ PARCKeyedElement *
 parcKeyedElement_Create(void *data, const void *key, size_t keylen)
 {
     PARCKeyedElement *keyedElement = parcMemory_Allocate(sizeof(PARCKeyedElement));
-    assertNotNull(keyedElement, "parcMemory_Allocate(%zu) returned NULL", sizeof(PARCKeyedElement));
+    parcAssertNotNull(keyedElement, "parcMemory_Allocate(%zu) returned NULL", sizeof(PARCKeyedElement));
     keyedElement->element = data;
     keyedElement->key = parcMemory_Allocate(sizeof(PARCKeyedElement));
-    assertNotNull(keyedElement->key, "parcMemory_Allocate(%zu) returned NULL", sizeof(PARCKeyedElement));
+    parcAssertNotNull(keyedElement->key, "parcMemory_Allocate(%zu) returned NULL", sizeof(PARCKeyedElement));
     memcpy(keyedElement->key, key, keylen);
     keyedElement->keylen = keylen;
     return keyedElement;
diff --git a/libparc/parc/algol/parc_LinkedList.c b/libparc/parc/algol/parc_LinkedList.c
index d220e223..b5bbd0a6 100644
--- a/libparc/parc/algol/parc_LinkedList.c
+++ b/libparc/parc/algol/parc_LinkedList.c
@@ -17,7 +17,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <stdio.h>
 #include <sys/queue.h>
@@ -136,7 +136,7 @@ static void
 _parcLinkedListIterator_IsValid(const _PARCLinkedListNode *node)
 {
     if (node != NULL) {
-        assertTrue(_parcLinkedListNode_IsValid(node), "node is invalid");
+        parcAssertTrue(_parcLinkedListNode_IsValid(node), "node is invalid");
     }
 }
 
@@ -183,12 +183,12 @@ _parcLinkedListNode_Next(PARCLinkedList *list __attribute__((unused)), const _PA
     if (node == NULL) {
         result = list->head;
     } else {
-        assertTrue(_parcLinkedListNode_IsValid(node), "node is invalid");
-        trapOutOfBoundsIf(node->next == NULL, "No more elements.");
+        parcAssertTrue(_parcLinkedListNode_IsValid(node), "node is invalid");
+        parcTrapOutOfBoundsIf(node->next == NULL, "No more elements.");
         result = node->next;
     }
 
-    assertTrue(_parcLinkedListNode_IsValid(result), "result is invalid");
+    parcAssertTrue(_parcLinkedListNode_IsValid(result), "result is invalid");
     parcObject_OptionalAssertValid(result->object);
 
     return result;
@@ -244,12 +244,12 @@ _parcLinkedListNode_HasNext(PARCLinkedList *list, const _PARCLinkedListNode *nod
     if (node == NULL) {
         result = (list->head != NULL);
         if (result) {
-            assertTrue(_parcLinkedListNode_IsValid(list->head), "node is invalid");
+            parcAssertTrue(_parcLinkedListNode_IsValid(list->head), "node is invalid");
         }
     } else {
         result = node->next != NULL;
         if (result) {
-            assertTrue(_parcLinkedListNode_IsValid(node->next), "node is invalid");
+            parcAssertTrue(_parcLinkedListNode_IsValid(node->next), "node is invalid");
         }
     }
 
@@ -333,7 +333,7 @@ parcLinkedList_IsValid(const PARCLinkedList *list)
 void
 parcLinkedList_AssertValid(const PARCLinkedList *instance)
 {
-    assertTrue(parcLinkedList_IsValid(instance),
+    parcAssertTrue(parcLinkedList_IsValid(instance),
                "PARCLinkedList is not valid.");
 }
 
@@ -462,7 +462,7 @@ parcLinkedList_RemoveLast(PARCLinkedList *list)
 bool
 parcLinkedList_Remove(PARCLinkedList *list, const PARCObject *element)
 {
-    assertTrue(element != NULL, "Element must not be NULL");
+    parcAssertTrue(element != NULL, "Element must not be NULL");
     bool result = false;
 
     _PARCLinkedListNode *node = _parcLinkedListNode_getByValue(list, element);
@@ -592,7 +592,7 @@ parcLinkedList_SetAtIndex(PARCLinkedList *list, size_t index, PARCObject *elemen
     PARCObject *result = NULL;
 
     if (index > (parcLinkedList_Size(list) - 1)) {
-        trapOutOfBounds(index, "[0, %zd]", parcLinkedList_Size(list) - 1);
+        parcTrapOutOfBounds(index, "[0, %zd]", parcLinkedList_Size(list) - 1);
     }
 
     _PARCLinkedListNode *node = _parcLinkedListNode_getByIndex(list, index);
@@ -607,7 +607,7 @@ PARCObject *
 parcLinkedList_GetAtIndex(const PARCLinkedList *list, size_t index)
 {
     if (index > (parcLinkedList_Size(list) - 1)) {
-        trapOutOfBounds(index, "[0, %zd]", parcLinkedList_Size(list) - 1);
+        parcTrapOutOfBounds(index, "[0, %zd]", parcLinkedList_Size(list) - 1);
     }
 
     _PARCLinkedListNode *node = _parcLinkedListNode_getByIndex(list, index);
diff --git a/libparc/parc/algol/parc_LinkedList.h b/libparc/parc/algol/parc_LinkedList.h
index 7babff79..381e2a18 100644
--- a/libparc/parc/algol/parc_LinkedList.h
+++ b/libparc/parc/algol/parc_LinkedList.h
@@ -421,7 +421,7 @@ bool parcLinkedList_IsEmpty(const PARCLinkedList *list);
  * @param [in] list A pointer to a `PARCLinkedList` instance.
  * @param [in] index The index of the element to be retrieved.
  *
- * @throws `trapOutOfBounds`
+ * @throws `parcTrapOutOfBounds`
  *
  * Example:
  * @code
@@ -437,7 +437,7 @@ PARCObject *parcLinkedList_GetAtIndex(const PARCLinkedList *list, size_t index);
  * @param [in] index The index of the element to be replaced.
  * @param [in] element A pointer to a valid PARCObject instance that will replace the current element at @p index.
  *
- * @throws `trapOutOfBounds`
+ * @throws `parcTrapOutOfBounds`
  *
  * Example:
  * @code
diff --git a/libparc/parc/algol/parc_List.c b/libparc/parc/algol/parc_List.c
index 0e62cda6..bdb343f8 100644
--- a/libparc/parc/algol/parc_List.c
+++ b/libparc/parc/algol/parc_List.c
@@ -17,7 +17,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <stdio.h>
 #include <stdarg.h>
diff --git a/libparc/parc/algol/parc_List.h b/libparc/parc/algol/parc_List.h
index 6c17453c..d6d94adf 100644
--- a/libparc/parc/algol/parc_List.h
+++ b/libparc/parc/algol/parc_List.h
@@ -364,7 +364,7 @@ void parcList_Release(PARCList **listPtr);
  * @return NULL Memory could not be allocated.
  * @return non-NULL A pointer to a new `PARCList` instance.
  *
- * @throws trapIllegalValue if @p instance is NULL.
+ * @throws parcTrapIllegalValue if @p instance is NULL.
  *
  * Example:
  * @code
@@ -429,7 +429,7 @@ bool parcList_Add(PARCList *list, void *element);
  *   parcList_AddAll(array, 3, elements);
  *   size_t actual = parcList_Length(array);
  *
- *   assertTrue(3 == actual, "Expected=%d, actual=%d", 3, actual);
+ *   parcAssertTrue(3 == actual, "Expected=%d, actual=%d", 3, actual);
  *
  *   parcListRelease(&array);
  * }
diff --git a/libparc/parc/algol/parc_Memory.c b/libparc/parc/algol/parc_Memory.c
index e444baba..eebdadf0 100755
--- a/libparc/parc/algol/parc_Memory.c
+++ b/libparc/parc/algol/parc_Memory.c
@@ -17,7 +17,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <unistd.h>
 #include <stdlib.h>
@@ -37,7 +37,7 @@ static const PARCMemoryInterface *parcMemory = &PARCStdlibMemoryAsPARCMemory;
 const PARCMemoryInterface *
 parcMemory_SetInterface(const PARCMemoryInterface *memoryProvider)
 {
-    assertFalse(memoryProvider == &PARCMemoryAsPARCMemory,
+    parcAssertFalse(memoryProvider == &PARCMemoryAsPARCMemory,
                 "You cannot use PARCMemoryAsPARCMemory as a memory provider for parcMemory.");
     const PARCMemoryInterface *result = parcMemory;
     parcMemory = memoryProvider;
diff --git a/libparc/parc/algol/parc_Network.c b/libparc/parc/algol/parc_Network.c
index 35279648..2b6c8888 100644
--- a/libparc/parc/algol/parc_Network.c
+++ b/libparc/parc/algol/parc_Network.c
@@ -17,7 +17,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <sys/socket.h>
 #include <ctype.h>
@@ -49,9 +49,9 @@ parcNetwork_SockAddress(const char *address, in_port_t port)
         switch (ai->ai_family) {
             case PF_INET: {
                 struct sockaddr_in *result = parcMemory_AllocateAndClear(sizeof(struct sockaddr_in));
-                assertNotNull(result, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(struct sockaddr_in));
+                parcAssertNotNull(result, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(struct sockaddr_in));
                 if (result != NULL) {
-                    assertTrue(ai->ai_addrlen == sizeof(struct sockaddr_in),
+                    parcAssertTrue(ai->ai_addrlen == sizeof(struct sockaddr_in),
                                "Sockaddr wrong length, expected %zu got %u", sizeof(struct sockaddr_in), ai->ai_addrlen);
                     memcpy(result, ai->ai_addr, ai->ai_addrlen);
                     result->sin_port = htons(port);
@@ -62,9 +62,9 @@ parcNetwork_SockAddress(const char *address, in_port_t port)
 
             case PF_INET6: {
                 struct sockaddr_in6 *result = parcMemory_AllocateAndClear(sizeof(struct sockaddr_in6));
-                assertNotNull(result, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(struct sockaddr_in6));
+                parcAssertNotNull(result, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(struct sockaddr_in6));
                 if (result != NULL) {
-                    assertTrue(ai->ai_addrlen == sizeof(struct sockaddr_in6),
+                    parcAssertTrue(ai->ai_addrlen == sizeof(struct sockaddr_in6),
                                "Sockaddr wrong length, expected %zu got %u", sizeof(struct sockaddr_in6), ai->ai_addrlen);
 
                     memcpy(result, ai->ai_addr, ai->ai_addrlen);
@@ -93,7 +93,7 @@ struct sockaddr_in *
 parcNetwork_SockInet4Address(const char *address, in_port_t port)
 {
     struct sockaddr_in *result = parcMemory_AllocateAndClear(sizeof(struct sockaddr_in));
-    assertNotNull(result, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(struct sockaddr_in));
+    parcAssertNotNull(result, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(struct sockaddr_in));
     if (result != NULL) {
         result->sin_family = AF_INET;
         result->sin_port = htons(port);
@@ -113,7 +113,7 @@ struct sockaddr_in6 *
 parcNetwork_SockInet6Address(const char *address, in_port_t port, uint32_t flowInfo, uint32_t scopeId)
 {
     struct sockaddr_in6 *result = parcMemory_AllocateAndClear(sizeof(struct sockaddr_in6));
-    assertNotNull(result, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(struct sockaddr_in6));
+    parcAssertNotNull(result, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(struct sockaddr_in6));
     if (result != NULL) {
         result->sin6_family = AF_INET6;
         result->sin6_port = htons(port);
@@ -136,7 +136,7 @@ struct sockaddr_in *
 parcNetwork_SockInet4AddressAny()
 {
     struct sockaddr_in *result = parcMemory_AllocateAndClear(sizeof(struct sockaddr_in));
-    assertNotNull(result, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(struct sockaddr_in));
+    parcAssertNotNull(result, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(struct sockaddr_in));
     if (result != NULL) {
         result->sin_family = AF_INET;
         result->sin_addr.s_addr = INADDR_ANY;
@@ -151,10 +151,10 @@ parcNetwork_SockInet4AddressAny()
 PARCBufferComposer *
 parcNetwork_SockInet4Address_BuildString(const struct sockaddr_in *address, PARCBufferComposer *composer)
 {
-    assertNotNull(address, "Parameter must be a non-null pointer to a struct sockaddr_in.");
+    parcAssertNotNull(address, "Parameter must be a non-null pointer to a struct sockaddr_in.");
 
     if (address->sin_family != AF_INET) {
-        trapIllegalValue(address->sin_family, "Expected an AF_INET configured address, not %d", address->sin_family);
+        parcTrapIllegalValue(address->sin_family, "Expected an AF_INET configured address, not %d", address->sin_family);
     }
 
     char buffer[INET_ADDRSTRLEN];
@@ -167,10 +167,10 @@ parcNetwork_SockInet4Address_BuildString(const struct sockaddr_in *address, PARC
 PARCBufferComposer *
 parcNetwork_SockInet6Address_BuildString(const struct sockaddr_in6 *address, PARCBufferComposer *composer)
 {
-    assertNotNull(address, "Parameter must be a non-null pointer to a struct sockaddr_in.");
+    parcAssertNotNull(address, "Parameter must be a non-null pointer to a struct sockaddr_in.");
 
     if (address->sin6_family != AF_INET6) {
-        trapIllegalValue(address->sin_family, "Expected an AF_INET6 configured address, not %d", address->sin6_family);
+        parcTrapIllegalValue(address->sin_family, "Expected an AF_INET6 configured address, not %d", address->sin6_family);
     }
 
     char buffer[INET6_ADDRSTRLEN];
@@ -297,13 +297,13 @@ parcNetwork_ParseLinkAddress(const char *address)
 
         if (parcNetwork_ParseMAC48Address(&address[7], result) == false) {
             parcBuffer_Release(&result);
-            trapIllegalValue(address, "Syntax error '%s'", address);
+            parcTrapIllegalValue(address, "Syntax error '%s'", address);
         }
 
         return parcBuffer_Flip(result);
     }
 
-    trapIllegalValue(address, "Bad scheme '%s'", address);
+    parcTrapIllegalValue(address, "Bad scheme '%s'", address);
 }
 
 bool
@@ -366,7 +366,7 @@ _isInet4Loopback(struct sockaddr_in *sin4)
 bool
 parcNetwork_IsSocketLocal(struct sockaddr *sock)
 {
-    assertNotNull(sock, "Parameter sock must be non-null");
+    parcAssertNotNull(sock, "Parameter sock must be non-null");
     bool isLocal = false;
 
     switch (sock->sa_family) {
diff --git a/libparc/parc/algol/parc_Network.h b/libparc/parc/algol/parc_Network.h
index efd5e632..bf7cfcbd 100644
--- a/libparc/parc/algol/parc_Network.h
+++ b/libparc/parc/algol/parc_Network.h
@@ -55,24 +55,24 @@ typedef uint16_t in_port_t;
  * {
  *    struct sockaddr *addr;
  *    addr = parcNetwork_SockAddress("1.2.3.4", 555);
- *    assertTrue(addr && addr->sa_family == AF_INET, "Addr not IPv4 for a dotted quad.");
+ *    parcAssertTrue(addr && addr->sa_family == AF_INET, "Addr not IPv4 for a dotted quad.");
  *    struct sockaddr_in *addr_in = (struct sockaddr_in *) addr;
  *    // ...
  *    parcMemory_Deallocate((void **)&addr);
  *
  *    addr = parcNetwork_SockAddress("fe80::aa20:66ff:fe00:314a", 555);
- *    assertTrue(addr && addr->sa_family == AF_INET6, "Addr not IPv6.");
+ *    parcAssertTrue(addr && addr->sa_family == AF_INET6, "Addr not IPv6.");
  *    struct sockaddr_in6 *addr_in6 = (struct sockaddr_in6 *) addr;
  *    // ...
  *    parcMemory_Deallocate((void **)&addr);
  *
  *    addr = parcNetwork_SockAddress("alpha.parc.com", 555);
- *    assertTrue(addr && addr->sa_family == AF_INET, "Addr not IPv4 hostname with only ipv4 address.");
+ *    parcAssertTrue(addr && addr->sa_family == AF_INET, "Addr not IPv4 hostname with only ipv4 address.");
  *    // ...
  *    parcMemory_Deallocate((void **)&addr);
  *
  *    addr = parcNetwork_SockAddress("Over the rainbow, way up high", 555);
- *    assertNull(addr, "Addr no null for bogus name.");
+ *    parcAssertNull(addr, "Addr no null for bogus name.");
  *
  * }
  * @endcode
@@ -256,7 +256,7 @@ struct sockaddr_in *parcNetwork_ParseInet4Address(const char *addressURI);
  * @code
  * {
  *   struct sockaddr *s = parcNetwork_SockAddress("127.1.1.1", 5900);
- *   assertTrue(parcNetwork_IsSocketLocal(s), "This will not assert");
+ *   parcAssertTrue(parcNetwork_IsSocketLocal(s), "This will not assert");
  *   parcMemory_Deallocate((void **)&s);
  * }
  * @endcode
diff --git a/libparc/parc/algol/parc_Object.c b/libparc/parc/algol/parc_Object.c
index 578f1e1a..70a24f34 100644
--- a/libparc/parc/algol/parc_Object.c
+++ b/libparc/parc/algol/parc_Object.c
@@ -17,7 +17,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <stdio.h>
 #include <inttypes.h>
@@ -246,7 +246,7 @@ _parcObject_ToString(const PARCObject *object)
                             "Object@%p { .references=%" PRId64 ", .objectLength = %zd, .objectAlignment=%u } data %p\n",
                             (void *) header,
                             header->references, header->descriptor->objectSize, header->descriptor->objectAlignment, object);
-    assertTrue(nwritten >= 0, "Error calling asprintf");
+    parcAssertTrue(nwritten >= 0, "Error calling asprintf");
     char *result = parcMemory_StringDuplicate(string, strlen(string));
     free(string);
     return result;
@@ -265,7 +265,7 @@ _parcObject_ToJSON(const PARCObject *object)
 
     char *addressString;
     int nwritten = asprintf(&addressString, "%p", object);
-    assertTrue(nwritten >= 0, "Error calling asprintf");
+    parcAssertTrue(nwritten >= 0, "Error calling asprintf");
 
     parcJSON_AddString(json, "address", addressString);
 
@@ -335,17 +335,17 @@ parcObject_IsValid(const PARCObject *object)
 static inline void
 _parcObjectHeader_AssertValid(const _PARCObjectHeader *header, const PARCObject *object)
 {
-    trapIllegalValueIf(header->magicGuardNumber != PARCObject_HEADER_MAGIC_GUARD_NUMBER, "PARCObject@%p is corrupt.", object);
-    trapIllegalValueIf(header->descriptor == NULL, "PARCObject@%p descriptor cannot be NULL.", object);
+    parcTrapIllegalValueIf(header->magicGuardNumber != PARCObject_HEADER_MAGIC_GUARD_NUMBER, "PARCObject@%p is corrupt.", object);
+    parcTrapIllegalValueIf(header->descriptor == NULL, "PARCObject@%p descriptor cannot be NULL.", object);
     if (header->descriptor->isLockable) {
-        trapIllegalValueIf(header->locking == NULL, "PARCObject@%p is corrupt. Is Lockable but no locking structure", object);
+        parcTrapIllegalValueIf(header->locking == NULL, "PARCObject@%p is corrupt. Is Lockable but no locking structure", object);
     }
 }
 
 static inline void
 _parcObject_AssertValid(const PARCObject *object)
 {
-    trapIllegalValueIf(object == NULL, "PARCObject must be a non-null pointer.");
+    parcTrapIllegalValueIf(object == NULL, "PARCObject must be a non-null pointer.");
 
     _PARCObjectHeader *header = _parcObject_Header(object);
     _parcObjectHeader_AssertValid(header, object);
@@ -628,7 +628,7 @@ parcObject_Release(PARCObject **objectPointer)
 
     _PARCObjectHeader *header = _parcObject_Header(object);
 
-    trapIllegalValueIf(header->references == 0, "PARCObject@%p references must be > 0", object);
+    parcTrapIllegalValueIf(header->references == 0, "PARCObject@%p references must be > 0", object);
 
     PARCReferenceCount result = parcAtomicUint64_Decrement(&header->references);
 
@@ -641,9 +641,9 @@ parcObject_Release(PARCObject **objectPointer)
                 void *origin = _parcObject_Origin(object);
                 parcMemory_Deallocate(&origin);
             }
-            assertNotNull(*objectPointer, "Class implementation unnecessarily clears the object pointer.");
+            parcAssertNotNull(*objectPointer, "Class implementation unnecessarily clears the object pointer.");
         } else {
-            assertNull(*objectPointer, "Class implementation must clear the object pointer.");
+            parcAssertNull(*objectPointer, "Class implementation must clear the object pointer.");
         }
     }
 
@@ -675,7 +675,7 @@ const PARCObjectDescriptor *
 parcObject_SetDescriptor(PARCObject *object, const PARCObjectDescriptor *descriptor)
 {
     parcObject_OptionalAssertValid(object);
-    assertNotNull(descriptor, "PARCObjectDescriptor cannot be NULL.");
+    parcAssertNotNull(descriptor, "PARCObjectDescriptor cannot be NULL.");
 
     _PARCObjectHeader *header = _parcObject_Header(object);
 
@@ -702,7 +702,7 @@ parcObjectDescriptor_Create(const char *name,
                             const PARCObjectDescriptor *superType,
                             PARCObjectTypeState *typeState)
 {
-    assertNotNull(superType, "Supertype descriptor cannot be NULL.");
+    parcAssertNotNull(superType, "Supertype descriptor cannot be NULL.");
 
     PARCObjectDescriptor *result = parcMemory_AllocateAndClear(sizeof(PARCObjectDescriptor));
     if (result != NULL) {
@@ -773,7 +773,7 @@ parcObject_Unlock(const PARCObject *object)
                 locking->locker = (pthread_t) NULL;
                 result = (pthread_mutex_unlock(&locking->lock) == 0);
 
-                assertTrue(result, "Attempted to unlock an unowned lock.");
+                parcAssertTrue(result, "Attempted to unlock an unowned lock.");
             }
         }
     }
@@ -793,7 +793,7 @@ parcObject_Lock(const PARCObject *object)
     if (object != NULL) {
         _PARCObjectLocking *locking = _parcObjectHeader_Locking(object);
         if (locking != NULL) {
-            trapCannotObtainLockIf(pthread_equal(locking->locker, pthread_self()),
+            parcTrapCannotObtainLockIf(pthread_equal(locking->locker, pthread_self()),
                                    "Recursive locks on %p are not supported.", object);
 
             errno = pthread_mutex_lock(&locking->lock);
@@ -818,7 +818,7 @@ parcObject_TryLock(const PARCObject *object)
 
         _PARCObjectLocking *locking = _parcObjectHeader_Locking(object);
         if (locking != NULL) {
-            trapCannotObtainLockIf(pthread_equal(locking->locker, pthread_self()), "Recursive locks are not supported.");
+            parcTrapCannotObtainLockIf(pthread_equal(locking->locker, pthread_self()), "Recursive locks are not supported.");
 
             int lockStatus = pthread_mutex_trylock(&locking->lock);
 
diff --git a/libparc/parc/algol/parc_Object.h b/libparc/parc/algol/parc_Object.h
index 0f3a932b..ac7e9652 100644
--- a/libparc/parc/algol/parc_Object.h
+++ b/libparc/parc/algol/parc_Object.h
@@ -42,8 +42,7 @@
 #include <stdint.h>
 #include <time.h>
 
-#include <LongBow/runtime.h>
-#include <LongBow/longBow_Compiler.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <parc/algol/parc_CMacro.h>
 //#include <parc/algol/parc_JSON.h>
@@ -598,8 +597,11 @@ const PARCObjectDescriptor *parcObject_SetDescriptor(PARCObject *object, const P
  * Create new `PARCObjectDescriptor` based on an existing `PARCObjectDescriptor.`
  * The new `PARCObjectDescriptor` uses the existing `PARCObjectDescriptor` as the super-type of the new descriptor.
  */
+
+#ifdef __clang__
 #define parcObject_Extends(_subtype, _superType, ...) \
-    LongBowCompiler_IgnoreInitializerOverrides \
+    _Pragma("GCC diagnostic push") \
+    _Pragma("GCC diagnostic ignored \"-Winitializer-overrides\"") \
     parcObjectDescriptor_Declaration(_subtype) = { \
         .super           = &parcObject_DescriptorName(_superType), \
         .name            = #_subtype, \
@@ -619,8 +621,33 @@ const PARCObjectDescriptor *parcObject_SetDescriptor(PARCObject *object, const P
         .typeState       = NULL, \
         __VA_ARGS__  \
     }; \
-    LongBowCompiler_WarnInitializerOverrides \
+    _Pragma("GCC diagnostic pop") \
     const PARCObjectDescriptor parcObject_DescriptorName(_subtype)
+#else
+    #define parcObject_Extends(_subtype, _superType, ...) \
+    _Pragma("GCC diagnostic ignored \"-Woverride-init\"") \
+    parcObjectDescriptor_Declaration(_subtype) = { \
+        .super           = &parcObject_DescriptorName(_superType), \
+        .name            = #_subtype, \
+        .objectSize      = 0, \
+        .objectAlignment = 0, \
+        .destroy         = NULL,    \
+        .destructor      = NULL, \
+        .release         = NULL,   \
+        .copy            = NULL,   \
+        .toString        = NULL,   \
+        .equals          = NULL,   \
+        .compare         = NULL,   \
+        .hashCode        = NULL,   \
+        .toJSON          = NULL,   \
+        .display         = NULL,   \
+        .isLockable      = true, \
+        .typeState       = NULL, \
+        __VA_ARGS__  \
+    }; \
+    _Pragma("GCC diagnostic warning \"-Woverride-init\"") \
+    const PARCObjectDescriptor parcObject_DescriptorName(_subtype)
+#endif
 
 /**
  * Define a new PARC Object implementation, by composing a new PARC Object Descriptor referencing an old one.
diff --git a/libparc/parc/algol/parc_OldSortedList.c b/libparc/parc/algol/parc_OldSortedList.c
index ef007388..c50d856d 100755
--- a/libparc/parc/algol/parc_OldSortedList.c
+++ b/libparc/parc/algol/parc_OldSortedList.c
@@ -17,7 +17,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <parc/algol/parc_SortedList.h>
 
@@ -33,7 +33,7 @@ PARCSortedList *
 parcSortedList_Create(parcSortedList_Compare compareFunction)
 {
     PARCSortedList *sortedList = parcMemory_Allocate(sizeof(PARCSortedList));
-    assertNotNull(sortedList, "parcMemory_Allocate(%zu) returned NULL", sizeof(PARCSortedList));
+    parcAssertNotNull(sortedList, "parcMemory_Allocate(%zu) returned NULL", sizeof(PARCSortedList));
     sortedList->arrayList = parcArrayList_Create(NULL);
     sortedList->compare = compareFunction;
     return sortedList;
@@ -50,9 +50,9 @@ parcSortedList_Destroy(PARCSortedList **parcSortedListPointer)
 void
 parcSortedList_Add(PARCSortedList *parcSortedList, void *newItem)
 {
-    assertNotNull(parcSortedList, "sortedList parameter can't be null");
-    assertNotNull(parcSortedList->arrayList, "arrayList can't be null");
-    assertNotNull(newItem, "newItem can't be null");
+    parcAssertNotNull(parcSortedList, "sortedList parameter can't be null");
+    parcAssertNotNull(parcSortedList->arrayList, "arrayList can't be null");
+    parcAssertNotNull(newItem, "newItem can't be null");
 
     size_t total_items = parcArrayList_Size(parcSortedList->arrayList);
     for (size_t i = 0; i < total_items; i++) {
@@ -77,8 +77,8 @@ parcSortedList_Length(PARCSortedList *parcSortedList)
 void *
 parcSortedList_PopFirst(PARCSortedList *parcSortedList)
 {
-    assertNotNull(parcSortedList, "sortedList parameter can't be null");
-    assertNotNull(parcSortedList->arrayList, "arrayList can't be null");
+    parcAssertNotNull(parcSortedList, "sortedList parameter can't be null");
+    parcAssertNotNull(parcSortedList->arrayList, "arrayList can't be null");
 
     if (parcArrayList_Size(parcSortedList->arrayList) == 0) {
         return NULL;
@@ -91,8 +91,8 @@ parcSortedList_PopFirst(PARCSortedList *parcSortedList)
 void *
 parcSortedList_GetFirst(PARCSortedList *parcSortedList)
 {
-    assertNotNull(parcSortedList, "sortedList parameter can't be null");
-    assertNotNull(parcSortedList->arrayList, "arrayList can't be null");
+    parcAssertNotNull(parcSortedList, "sortedList parameter can't be null");
+    parcAssertNotNull(parcSortedList->arrayList, "arrayList can't be null");
 
     if (parcArrayList_Size(parcSortedList->arrayList) == 0) {
         return NULL;
diff --git a/libparc/parc/algol/parc_PathName.c b/libparc/parc/algol/parc_PathName.c
index e329ee88..56e57d27 100755
--- a/libparc/parc/algol/parc_PathName.c
+++ b/libparc/parc/algol/parc_PathName.c
@@ -17,7 +17,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <stdbool.h>
 #include <stdio.h>
diff --git a/libparc/parc/algol/parc_PriorityQueue.c b/libparc/parc/algol/parc_PriorityQueue.c
index 93744b2c..c6c003b1 100755
--- a/libparc/parc/algol/parc_PriorityQueue.c
+++ b/libparc/parc/algol/parc_PriorityQueue.c
@@ -30,7 +30,7 @@
 
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <stdio.h>
 #include <stdbool.h>
@@ -263,8 +263,8 @@ _expand(PARCPriorityQueue *queue)
 void
 parcPriorityQueue_ParcFreeDestroyer(void **elementPtr)
 {
-    assertNotNull(elementPtr, "Double pointer must be non-null");
-    assertNotNull(*elementPtr, "Double pointer must dereference to non-null");
+    parcAssertNotNull(elementPtr, "Double pointer must be non-null");
+    parcAssertNotNull(*elementPtr, "Double pointer must dereference to non-null");
     void *element = *elementPtr;
     parcMemory_Deallocate((void **) &element);
     *elementPtr = NULL;
@@ -286,13 +286,13 @@ parcPriorityQueue_Uint64CompareTo(const void *a, const void *b)
 PARCPriorityQueue *
 parcPriorityQueue_Create(PARCPriorityQueueCompareTo *compare, PARCPriorityQueueDestroyer *destroyer)
 {
-    assertNotNull(compare, "Parameter compare must be non-null");
+    parcAssertNotNull(compare, "Parameter compare must be non-null");
 
     size_t initialSize = 128;
     PARCPriorityQueue *queue = parcMemory_AllocateAndClear(sizeof(PARCPriorityQueue));
-    assertNotNull(queue, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(PARCPriorityQueue));
+    parcAssertNotNull(queue, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(PARCPriorityQueue));
     queue->array = parcMemory_AllocateAndClear(sizeof(HeapEntry) * initialSize);
-    assertNotNull(queue->array, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(HeapEntry) * initialSize);
+    parcAssertNotNull(queue->array, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(HeapEntry) * initialSize);
     queue->capacity = initialSize;
     queue->size = 0;
     queue->compare = compare;
@@ -304,8 +304,8 @@ parcPriorityQueue_Create(PARCPriorityQueueCompareTo *compare, PARCPriorityQueueD
 void
 parcPriorityQueue_Destroy(PARCPriorityQueue **queuePtr)
 {
-    assertNotNull(queuePtr, "Double pointer must be non-null");
-    assertNotNull(*queuePtr, "Double pointer must dereference to non-null");
+    parcAssertNotNull(queuePtr, "Double pointer must be non-null");
+    parcAssertNotNull(*queuePtr, "Double pointer must dereference to non-null");
     PARCPriorityQueue *queue = *queuePtr;
     parcPriorityQueue_Clear(queue);
     parcMemory_Deallocate((void **) &(queue->array));
@@ -316,8 +316,8 @@ parcPriorityQueue_Destroy(PARCPriorityQueue **queuePtr)
 bool
 parcPriorityQueue_Add(PARCPriorityQueue *queue, void *data)
 {
-    assertNotNull(queue, "Parameter queue must be non-null");
-    assertNotNull(data, "Parameter data must be non-null");
+    parcAssertNotNull(queue, "Parameter queue must be non-null");
+    parcAssertNotNull(data, "Parameter data must be non-null");
 
     if (queue->size + 1 > queue->capacity) {
         _expand(queue);
@@ -338,7 +338,7 @@ parcPriorityQueue_Add(PARCPriorityQueue *queue, void *data)
 void
 parcPriorityQueue_Clear(PARCPriorityQueue *queue)
 {
-    assertNotNull(queue, "Parameter queue must be non-null");
+    parcAssertNotNull(queue, "Parameter queue must be non-null");
     if (queue->destroyer != NULL) {
         for (size_t i = 0; i < queue->size; i++) {
             queue->destroyer(&queue->array[i].data);
@@ -351,7 +351,7 @@ parcPriorityQueue_Clear(PARCPriorityQueue *queue)
 void *
 parcPriorityQueue_Peek(PARCPriorityQueue *queue)
 {
-    assertNotNull(queue, "Parameter queue must be non-null");
+    parcAssertNotNull(queue, "Parameter queue must be non-null");
     if (queue->size > 0) {
         return queue->array[0].data;
     }
@@ -361,7 +361,7 @@ parcPriorityQueue_Peek(PARCPriorityQueue *queue)
 void *
 parcPriorityQueue_Poll(PARCPriorityQueue *queue)
 {
-    assertNotNull(queue, "Parameter queue must be non-null");
+    parcAssertNotNull(queue, "Parameter queue must be non-null");
     if (queue->size > 0) {
         void *data = queue->array[0].data;
 
@@ -382,6 +382,6 @@ parcPriorityQueue_Poll(PARCPriorityQueue *queue)
 size_t
 parcPriorityQueue_Size(const PARCPriorityQueue *queue)
 {
-    assertNotNull(queue, "Parameter queue must be non-null");
+    parcAssertNotNull(queue, "Parameter queue must be non-null");
     return queue->size;
 }
diff --git a/libparc/parc/algol/parc_Properties.c b/libparc/parc/algol/parc_Properties.c
index 19aea290..2a6c7d33 100644
--- a/libparc/parc/algol/parc_Properties.c
+++ b/libparc/parc/algol/parc_Properties.c
@@ -18,7 +18,7 @@
 #include <config.h>
 #include <stdio.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <parc/algol/parc_Object.h>
 #include <parc/algol/parc_DisplayIndented.h>
@@ -35,7 +35,7 @@ struct PARCProperties {
 static void
 _parcProperties_Finalize(PARCProperties **instancePtr)
 {
-    assertNotNull(instancePtr, "Parameter must be a non-null pointer to a PARCProperties pointer.");
+    parcAssertNotNull(instancePtr, "Parameter must be a non-null pointer to a PARCProperties pointer.");
     PARCProperties *instance = *instancePtr;
 
     parcProperties_OptionalAssertValid(instance);
@@ -53,7 +53,7 @@ parcObject_ExtendPARCObject(PARCProperties, _parcProperties_Finalize, parcProper
 void
 parcProperties_AssertValid(const PARCProperties *instance)
 {
-    assertTrue(parcProperties_IsValid(instance),
+    parcAssertTrue(parcProperties_IsValid(instance),
                "PARCProperties is not valid.");
 }
 
@@ -94,7 +94,7 @@ void
 parcProperties_Display(const PARCProperties *properties, int indentation)
 {
     parcDisplayIndented_PrintLine(indentation, "PARCProperties@%p {", properties);
-    trapCannotObtainLockIf(parcHashMap_Lock(properties->properties) == false, "Cannot lock PARCProperties object.");
+    parcTrapCannotObtainLockIf(parcHashMap_Lock(properties->properties) == false, "Cannot lock PARCProperties object.");
 
     PARCIterator *iterator = parcHashMap_CreateKeyIterator(properties->properties);
     while (parcIterator_HasNext(iterator)) {
@@ -151,7 +151,7 @@ parcProperties_ToJSON(const PARCProperties *properties)
 {
     PARCJSON *result = parcJSON_Create();
 
-    trapCannotObtainLockIf(parcHashMap_Lock(properties->properties) == false, "Cannot lock PARCProperties object.");
+    parcTrapCannotObtainLockIf(parcHashMap_Lock(properties->properties) == false, "Cannot lock PARCProperties object.");
 
     PARCIterator *iterator = parcHashMap_CreateKeyIterator(properties->properties);
     while (parcIterator_HasNext(iterator)) {
@@ -170,7 +170,7 @@ parcProperties_ToJSON(const PARCProperties *properties)
 PARCBufferComposer *
 parcProperties_BuildString(const PARCProperties *properties, PARCBufferComposer *composer)
 {
-    trapCannotObtainLockIf(parcHashMap_Lock(properties->properties) == false, "Cannot lock PARCProperties object.");
+    parcTrapCannotObtainLockIf(parcHashMap_Lock(properties->properties) == false, "Cannot lock PARCProperties object.");
 
     PARCIterator *iterator = parcHashMap_CreateKeyIterator(properties->properties);
     while (parcIterator_HasNext(iterator)) {
diff --git a/libparc/parc/algol/parc_RandomAccessFile.c b/libparc/parc/algol/parc_RandomAccessFile.c
index 65bff1d1..9a5e7914 100755
--- a/libparc/parc/algol/parc_RandomAccessFile.c
+++ b/libparc/parc/algol/parc_RandomAccessFile.c
@@ -33,7 +33,7 @@ struct PARCRandomAccessFile {
 static void
 _parcRandomAccessFile_Finalize(PARCRandomAccessFile **instancePtr)
 {
-    assertNotNull(instancePtr, "Parameter must be a non-null pointer to a PARCRandomAccessFile pointer.");
+    parcAssertNotNull(instancePtr, "Parameter must be a non-null pointer to a PARCRandomAccessFile pointer.");
     PARCRandomAccessFile *instance = *instancePtr;
     if (instance->fhandle != NULL) {
         fclose(instance->fhandle);
@@ -55,7 +55,7 @@ parcObject_ExtendPARCObject(PARCRandomAccessFile, _parcRandomAccessFile_Finalize
 void
 parcRandomAccessFile_AssertValid(const PARCRandomAccessFile *instance)
 {
-    assertTrue(parcRandomAccessFile_IsValid(instance),
+    parcAssertTrue(parcRandomAccessFile_IsValid(instance),
                "PARCRandomAccessFile is not valid.");
 }
 
@@ -138,7 +138,7 @@ parcRandomAccessFile_Open(PARCFile *file)
 bool
 parcRandomAccessFile_Close(PARCRandomAccessFile *fileHandle)
 {
-    assertNotNull(fileHandle->fhandle, "Can't fclose a null pointer. How did they get one anyway?");
+    parcAssertNotNull(fileHandle->fhandle, "Can't fclose a null pointer. How did they get one anyway?");
     bool result = fclose(fileHandle->fhandle) == 0;
     fileHandle->fhandle = NULL;
     parcMemory_Deallocate(&fileHandle->fname);
@@ -179,7 +179,7 @@ parcRandomAccessFile_Seek(PARCRandomAccessFile *fileHandle, long offset, PARCRan
             result = fseek(fileHandle->fhandle, offset, SEEK_END); // end of the file
             break;
         default:
-            assertTrue(false, "Invalid position %d", position);
+            parcAssertTrue(false, "Invalid position %d", position);
     }
     return result;
 }
diff --git a/libparc/parc/algol/parc_SafeMemory.c b/libparc/parc/algol/parc_SafeMemory.c
index 1f152af9..76908548 100644
--- a/libparc/parc/algol/parc_SafeMemory.c
+++ b/libparc/parc/algol/parc_SafeMemory.c
@@ -36,7 +36,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #if defined(_WIN64)
 #  define backtrace(...) (0)
@@ -340,7 +340,7 @@ _parcSafeMemory_Report(const PARCSafeMemoryUsable *safeMemory, int outputFd)
                                         (void *) safeMemory,
                                         (void *) prefix,
                                         _parcSafeMemory_StateToString(_parcSafeMemory_GetState(safeMemory)));
-        trapUnexpectedStateIf(charactersPrinted < 0, "Cannot write to file descriptor %d", outputFd);
+        parcTrapUnexpectedStateIf(charactersPrinted < 0, "Cannot write to file descriptor %d", outputFd);
     }
     _backtraceReport(prefix->backtrace, outputFd);
 }
@@ -359,7 +359,7 @@ parcSafeMemory_ReportAllocation(int outputFd)
             int charactersPrinted = dprintf(outputFd,
                                             "\n%u SafeMemory@%p: %p={ .requestedLength=%zd, .actualLength=%zd, .alignment=%zd }\n",
                                             index, e->memory, (void *) prefix, prefix->requestedLength, prefix->actualLength, prefix->alignment);
-            trapUnexpectedStateIf(charactersPrinted < 0, "Cannot write to file descriptor %d", outputFd)
+            parcTrapUnexpectedStateIf(charactersPrinted < 0, "Cannot write to file descriptor %d", outputFd)
             {
                 pthread_mutex_unlock(&head_mutex);
             }
@@ -394,7 +394,7 @@ _parcSafeMemory_Destroy(void **memoryPointer)
     PARCSafeMemoryUsable *memory = *memoryPointer;
 
     PARCSafeMemoryState state = _parcSafeMemory_GetState(memory);
-    trapUnexpectedStateIf(state != PARCSafeMemoryState_OK,
+    parcTrapUnexpectedStateIf(state != PARCSafeMemoryState_OK,
                           "Expected PARCSafeMemoryState_OK, actual %s (see parc_SafeMemory.h)",
                           _parcSafeMemory_StateToString(state))
     {
@@ -474,7 +474,7 @@ _parcSafeMemory_FormatPrefix(PARCSafeMemoryOrigin *origin, size_t requestedLengt
 
     PARCSafeMemoryUsable *result = _pointerAdd(origin, prefixSize);
 
-    assertAligned(result, alignment, "Return value is not properly aligned to %zu", alignment);
+    parcAssertAligned(result, alignment, "Return value is not properly aligned to %zu", alignment);
     return result;
 }
 
diff --git a/libparc/parc/algol/parc_SafeMemory.h b/libparc/parc/algol/parc_SafeMemory.h
index 0383fe39..a2574e87 100644
--- a/libparc/parc/algol/parc_SafeMemory.h
+++ b/libparc/parc/algol/parc_SafeMemory.h
@@ -209,7 +209,7 @@ void parcSafeMemory_Deallocate(void **pointer);
  *     size_t newLength = 0;
  *     unsigned char *newMemory = parcSafeMemory_Reallocate(memory, newLength);
  *
- *     assertTrue(newMemory == NULL, "Expected NULL, actual %p", newMemory);
+ *     parcAssertTrue(newMemory == NULL, "Expected NULL, actual %p", newMemory);
  * }
  * @endcode
  */
diff --git a/libparc/parc/algol/parc_SortedList.c b/libparc/parc/algol/parc_SortedList.c
index 8a941701..1efa25ea 100644
--- a/libparc/parc/algol/parc_SortedList.c
+++ b/libparc/parc/algol/parc_SortedList.c
@@ -32,7 +32,7 @@ struct PARCSortedList {
 static void
 _parcSortedList_Finalize(PARCSortedList **instancePtr)
 {
-    assertNotNull(instancePtr, "Parameter must be a non-null pointer to a PARCSortedList pointer.");
+    parcAssertNotNull(instancePtr, "Parameter must be a non-null pointer to a PARCSortedList pointer.");
     PARCSortedList *instance = *instancePtr;
 
     parcSortedList_OptionalAssertValid(instance);
@@ -50,7 +50,7 @@ parcObject_ExtendPARCObject(PARCSortedList, _parcSortedList_Finalize, parcSorted
 void
 parcSortedList_AssertValid(const PARCSortedList *instance)
 {
-    assertTrue(parcSortedList_IsValid(instance),
+    parcAssertTrue(parcSortedList_IsValid(instance),
                "PARCSortedList is not valid.");
 }
 
@@ -245,7 +245,7 @@ void
 parcSortedList_Add(PARCSortedList *instance, PARCObject *element)
 {
     size_t insertionPoint = _parcSortedList_GetInsertionIndex(instance, element);
-    assertTrue(insertionPoint >= 0 && insertionPoint <= parcLinkedList_Size(instance->list),
+    parcAssertTrue(insertionPoint >= 0 && insertionPoint <= parcLinkedList_Size(instance->list),
                "%zd is bad insertion point.  Must be >=0 and <= %zd", insertionPoint, parcLinkedList_Size(instance->list));
 
     parcLinkedList_InsertAtIndex(instance->list, insertionPoint, element);
diff --git a/libparc/parc/algol/parc_Stack.c b/libparc/parc/algol/parc_Stack.c
index 5930169b..72cae53c 100755
--- a/libparc/parc/algol/parc_Stack.c
+++ b/libparc/parc/algol/parc_Stack.c
@@ -19,7 +19,7 @@
 
 #include <stdio.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <parc/algol/parc_Memory.h>
 #include <parc/algol/parc_Deque.h>
@@ -34,7 +34,7 @@ PARCStack *
 parcStack(void *instance, PARCStackInterface *interface)
 {
     PARCStack *result = parcMemory_AllocateAndClear(sizeof(PARCStack));
-    assertNotNull(result, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(PARCStack));
+    parcAssertNotNull(result, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(PARCStack));
     result->instance = instance;
     result->interface = interface;
 
diff --git a/libparc/parc/algol/parc_StdlibMemory.c b/libparc/parc/algol/parc_StdlibMemory.c
index a919f727..11381a54 100755
--- a/libparc/parc/algol/parc_StdlibMemory.c
+++ b/libparc/parc/algol/parc_StdlibMemory.c
@@ -25,7 +25,7 @@
 #include <strings.h>
 #include <pthread.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <parc/algol/parc_StdlibMemory.h>
 
@@ -132,7 +132,7 @@ void
 parcStdlibMemory_Deallocate(void **pointer)
 {
 #ifndef PARCLibrary_DISABLE_VALIDATION
-    trapIllegalValueIf(_parcStdlibMemory_OutstandingAllocations == 0,
+    parcTrapIllegalValueIf(_parcStdlibMemory_OutstandingAllocations == 0,
                        "parcStdlibMemory_Deallocate invoked with nothing left to free (double free somewhere?)\n");
 #endif
     free(*pointer);
diff --git a/libparc/parc/algol/parc_String.c b/libparc/parc/algol/parc_String.c
index e5af5f71..78aaf470 100755
--- a/libparc/parc/algol/parc_String.c
+++ b/libparc/parc/algol/parc_String.c
@@ -30,7 +30,7 @@ struct PARCString {
 static bool
 _parcString_Destructor(PARCString **instancePtr)
 {
-    assertNotNull(instancePtr, "Parameter must be a non-null pointer to a PARCString pointer.");
+    parcAssertNotNull(instancePtr, "Parameter must be a non-null pointer to a PARCString pointer.");
     PARCString *string = *instancePtr;
 
     parcMemory_Deallocate(&string->string);
@@ -55,7 +55,7 @@ parcObject_Override(PARCString, PARCObject,
 void
 parcString_AssertValid(const PARCString *instance)
 {
-    assertTrue(parcString_IsValid(instance),
+    parcAssertTrue(parcString_IsValid(instance),
                "PARCString is not valid.");
 }
 
diff --git a/libparc/parc/algol/parc_Time.c b/libparc/parc/algol/parc_Time.c
index 7cc358b9..07ab185b 100755
--- a/libparc/parc/algol/parc_Time.c
+++ b/libparc/parc/algol/parc_Time.c
@@ -22,7 +22,7 @@
 #include <time.h>
 #include <sys/time.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <parc/algol/parc_Time.h>
 #include <parc/algol/parc_Memory.h>
@@ -32,7 +32,7 @@ parcTime_TimevalAsString(struct timeval timeval)
 {
     char *string;
     int nwritten = asprintf(&string, "%ld.%06ld", timeval.tv_sec, (long) timeval.tv_usec);
-    assertTrue(nwritten >= 0, "Error calling asprintf");
+    parcAssertTrue(nwritten >= 0, "Error calling asprintf");
 
     char *result = parcMemory_StringDuplicate(string, strlen(string));
     free(string);
diff --git a/libparc/parc/algol/parc_TreeMap.c b/libparc/parc/algol/parc_TreeMap.c
index 9c776b30..9922829b 100755
--- a/libparc/parc/algol/parc_TreeMap.c
+++ b/libparc/parc/algol/parc_TreeMap.c
@@ -17,7 +17,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <stdio.h>
 
@@ -167,7 +167,7 @@ static _RBNode *
 _rbNodeCreate(PARCTreeMap *tree, int color)
 {
     _RBNode *node = parcMemory_AllocateAndClear(sizeof(_RBNode));
-    assertNotNull(node, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(_RBNode));
+    parcAssertNotNull(node, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(_RBNode));
     node->color = color;
     node->leftChild = tree->nil;
     node->rightChild = tree->nil;
@@ -353,28 +353,28 @@ static void
 _rbNodeAssertNodeInvariants(_RBNode *node, PARCObject *data)
 {
     PARCTreeMap *tree = (PARCTreeMap *) data;
-    assertNotNull(node->parent, "Node has NULL parent");
-    assertNotNull(node->leftChild, "Left child NULL");
-    assertNotNull(node->rightChild, "Richt child NULL");
+    parcAssertNotNull(node->parent, "Node has NULL parent");
+    parcAssertNotNull(node->leftChild, "Left child NULL");
+    parcAssertNotNull(node->rightChild, "Richt child NULL");
     if (node != tree->root) {
-        assertTrue(node->parent != tree->nil, "Paren't can't be nill for node!");
+        parcAssertTrue(node->parent != tree->nil, "Paren't can't be nill for node!");
         // Don't need to compare to parent, they compared to us
     }
-    assertNotNull(node->element, "We have a null element!!");
-    assertNotNull(parcKeyValue_GetKey(node->element), "We have a null key!!");
-    assertNotNull(parcKeyValue_GetValue(node->element), "We have a null value!!");
+    parcAssertNotNull(node->element, "We have a null element!!");
+    parcAssertNotNull(parcKeyValue_GetKey(node->element), "We have a null key!!");
+    parcAssertNotNull(parcKeyValue_GetValue(node->element), "We have a null value!!");
     if (node->leftChild != tree->nil) {
         if (tree->customCompare != NULL) {
-            assertTrue(tree->customCompare(parcKeyValue_GetKey(node->element), parcKeyValue_GetKey(node->leftChild->element)) > 0, "Left child not smaller?");
+            parcAssertTrue(tree->customCompare(parcKeyValue_GetKey(node->element), parcKeyValue_GetKey(node->leftChild->element)) > 0, "Left child not smaller?");
         } else {
-            assertTrue(parcObject_Compare(parcKeyValue_GetKey(node->element), parcKeyValue_GetKey(node->leftChild->element)) > 0, "Left child not smaller?");
+            parcAssertTrue(parcObject_Compare(parcKeyValue_GetKey(node->element), parcKeyValue_GetKey(node->leftChild->element)) > 0, "Left child not smaller?");
         }
     }
     if (node->rightChild != tree->nil) {
         if (tree->customCompare != NULL) {
-            assertTrue(tree->customCompare(parcKeyValue_GetKey(node->element), parcKeyValue_GetKey(node->rightChild->element)) < 0, "Right child not bigger?");
+            parcAssertTrue(tree->customCompare(parcKeyValue_GetKey(node->element), parcKeyValue_GetKey(node->rightChild->element)) < 0, "Right child not bigger?");
         } else {
-            assertTrue(parcObject_Compare(parcKeyValue_GetKey(node->element), parcKeyValue_GetKey(node->rightChild->element)) < 0, "Right child not bigger?");
+            parcAssertTrue(parcObject_Compare(parcKeyValue_GetKey(node->element), parcKeyValue_GetKey(node->rightChild->element)) < 0, "Right child not bigger?");
         }
     }
 }
@@ -383,11 +383,11 @@ static
 void
 _rbNodeAssertTreeInvariants(const PARCTreeMap *tree)
 {
-    assertNotNull(tree, "Tree is null!");
-    assertTrue(tree->size >= 0, "Tree has negative size");
+    parcAssertNotNull(tree, "Tree is null!");
+    parcAssertTrue(tree->size >= 0, "Tree has negative size");
     if (tree->size != 0) {
-        assertTrue(tree->root != tree->nil, "Tree size = %d > 0 but root is nil", tree->size);
-        assertNotNull(tree->root, "Tree size > 0 but root is NULL");
+        parcAssertTrue(tree->root != tree->nil, "Tree size = %d > 0 but root is nil", tree->size);
+        parcAssertNotNull(tree->root, "Tree size > 0 but root is NULL");
 #ifdef ASSERT_INVARIANTS
         _rbNodeRecursiveRun((PARCTreeMap *) tree, tree->root, _rbNodeAssertNodeInvariants, (PARCObject *) tree);
 #endif
@@ -558,8 +558,8 @@ _rbNodeRemove(PARCTreeMap *tree, _RBNode *node)
 static void
 _parcTreeMap_Destroy(PARCTreeMap **treePointer)
 {
-    assertNotNull(treePointer, "pointer to pointer to tree can't be null");
-    assertNotNull(*treePointer, "pointer to tree can't be null");
+    parcAssertNotNull(treePointer, "pointer to pointer to tree can't be null");
+    parcAssertNotNull(*treePointer, "pointer to tree can't be null");
     _rbNodeAssertTreeInvariants(*treePointer);
 
     if ((*treePointer)->size > 0) {
@@ -582,7 +582,7 @@ PARCTreeMap *
 parcTreeMap_CreateCustom(PARCTreeMap_CustomCompare *customCompare)
 {
     PARCTreeMap *tree = parcObject_CreateInstance(PARCTreeMap);
-    assertNotNull(tree, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(PARCTreeMap));
+    parcAssertNotNull(tree, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(PARCTreeMap));
     tree->nil = _rbNodeCreate(tree, BLACK);
     tree->nil->leftChild = tree->nil;
     tree->nil->rightChild = tree->nil;
@@ -602,9 +602,9 @@ parcTreeMap_Create(void)
 void
 parcTreeMap_Put(PARCTreeMap *tree, const PARCObject *key, const PARCObject *value)
 {
-    assertNotNull(tree, "Tree can't be NULL");
-    assertNotNull(key, "Key can't be NULL");
-    assertNotNull(value, "Value can't be NULL");
+    parcAssertNotNull(tree, "Tree can't be NULL");
+    parcAssertNotNull(key, "Key can't be NULL");
+    parcAssertNotNull(value, "Value can't be NULL");
 
     _RBNode *newNode = _rbNodeCreate(tree, RED);
     _RBNode *parent = tree->nil;
@@ -660,7 +660,7 @@ parcTreeMap_Put(PARCTreeMap *tree, const PARCObject *key, const PARCObject *valu
 PARCObject *
 parcTreeMap_Get(PARCTreeMap *tree, const PARCObject *key)
 {
-    assertNotNull(tree, "Tree can't be NULL");
+    parcAssertNotNull(tree, "Tree can't be NULL");
     _rbNodeAssertTreeInvariants(tree);
 
     PARCObject *result = NULL;
@@ -678,8 +678,8 @@ parcTreeMap_Get(PARCTreeMap *tree, const PARCObject *key)
 PARCObject *
 parcTreeMap_Remove(PARCTreeMap *tree, const PARCObject *key)
 {
-    assertNotNull(tree, "Tree can't be NULL");
-    assertNotNull(key, "Key can't be NULL");
+    parcAssertNotNull(tree, "Tree can't be NULL");
+    parcAssertNotNull(key, "Key can't be NULL");
     _rbNodeAssertTreeInvariants(tree);
 
     PARCObject *result = NULL;
@@ -703,8 +703,8 @@ parcTreeMap_Remove(PARCTreeMap *tree, const PARCObject *key)
 void
 parcTreeMap_RemoveAndRelease(PARCTreeMap *tree, const PARCObject *key)
 {
-    assertNotNull(tree, "Tree can't be NULL");
-    assertNotNull(key, "Key can't be NULL");
+    parcAssertNotNull(tree, "Tree can't be NULL");
+    parcAssertNotNull(key, "Key can't be NULL");
 
     _RBNode *node = _rbFindNode(tree, tree->root, key);
 
@@ -719,7 +719,7 @@ parcTreeMap_RemoveAndRelease(PARCTreeMap *tree, const PARCObject *key)
 PARCKeyValue *
 parcTreeMap_GetLastEntry(const PARCTreeMap *tree)
 {
-    assertNotNull(tree, "Tree can't be NULL");
+    parcAssertNotNull(tree, "Tree can't be NULL");
     _rbNodeAssertTreeInvariants(tree);
     _RBNode *node = tree->root;
 
@@ -752,7 +752,7 @@ parcTreeMap_GetLastKey(const PARCTreeMap *tree)
 PARCKeyValue *
 parcTreeMap_GetFirstEntry(const PARCTreeMap *tree)
 {
-    assertNotNull(tree, "Tree can't be NULL");
+    parcAssertNotNull(tree, "Tree can't be NULL");
     _rbNodeAssertTreeInvariants(tree);
 
     if (tree->size == 0) {
@@ -840,7 +840,7 @@ parcTreeMap_GetLowerKey(const PARCTreeMap *tree, const PARCObject *key)
 size_t
 parcTreeMap_Size(const PARCTreeMap *tree)
 {
-    assertNotNull(tree, "Tree can't be NULL");
+    parcAssertNotNull(tree, "Tree can't be NULL");
     _rbNodeAssertTreeInvariants(tree);
 
     return tree->size;
@@ -867,7 +867,7 @@ _rbAddElementToList(_RBNode *node, PARCList *list)
 PARCList *
 parcTreeMap_AcquireKeys(const PARCTreeMap *tree)
 {
-    assertNotNull(tree, "Tree can't be NULL");
+    parcAssertNotNull(tree, "Tree can't be NULL");
     _rbNodeAssertTreeInvariants(tree);
 
     PARCList *keys = parcList(parcArrayList_Create_Capacity((bool (*)(void *x, void *y))parcObject_Equals,
@@ -883,7 +883,7 @@ parcTreeMap_AcquireKeys(const PARCTreeMap *tree)
 PARCList *
 parcTreeMap_AcquireValues(const PARCTreeMap *tree)
 {
-    assertNotNull(tree, "Tree can't be NULL");
+    parcAssertNotNull(tree, "Tree can't be NULL");
     _rbNodeAssertTreeInvariants(tree);
 
     PARCList *values = parcList(parcArrayList_Create_Capacity((bool (*)(void *x, void *y))parcObject_Equals,
@@ -899,7 +899,7 @@ parcTreeMap_AcquireValues(const PARCTreeMap *tree)
 static PARCList *
 _parcTreeMap_Elements(const PARCTreeMap *tree)
 {
-    assertNotNull(tree, "Tree can't be NULL");
+    parcAssertNotNull(tree, "Tree can't be NULL");
     _rbNodeAssertTreeInvariants(tree);
 
     PARCList *elements = parcList(parcArrayList_Create_Capacity((bool (*)(void *x, void *y))parcObject_Equals,
@@ -917,8 +917,8 @@ parcTreeMap_Equals(const PARCTreeMap *tree1, const PARCTreeMap *tree2)
 {
     _rbNodeAssertTreeInvariants(tree1);
     _rbNodeAssertTreeInvariants(tree2);
-    assertNotNull(tree1, "Tree can't be NULL");
-    assertNotNull(tree2, "Tree can't be NULL");
+    parcAssertNotNull(tree1, "Tree can't be NULL");
+    parcAssertNotNull(tree2, "Tree can't be NULL");
 
     bool result = false;
 
@@ -968,7 +968,7 @@ PARCTreeMap *
 parcTreeMap_Copy(const PARCTreeMap *sourceTree)
 {
     _rbNodeAssertTreeInvariants(sourceTree);
-    assertNotNull(sourceTree, "Tree can't be NULL");
+    parcAssertNotNull(sourceTree, "Tree can't be NULL");
 
     PARCObject *keySource;
     PARCObject *keyCopy;
@@ -1019,7 +1019,7 @@ _parcTreeMapIterator_Init(PARCTreeMap *map)
         state->list = _parcTreeMap_Elements(map);
         state->currentIndex = 0;
         state->currentElement = parcList_GetAtIndex(state->list, 0);
-        trapOutOfMemoryIf(state->list == NULL, "Cannot create parcList");
+        parcTrapOutOfMemoryIf(state->list == NULL, "Cannot create parcList");
     }
 
     return state;
diff --git a/libparc/parc/algol/parc_TreeRedBlack.c b/libparc/parc/algol/parc_TreeRedBlack.c
index 2d772555..71a23f10 100755
--- a/libparc/parc/algol/parc_TreeRedBlack.c
+++ b/libparc/parc/algol/parc_TreeRedBlack.c
@@ -17,7 +17,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <stdio.h>
 
@@ -102,7 +102,7 @@ static Node *
 _rbNodeCreate(PARCTreeRedBlack *tree, int color)
 {
     Node *node = parcMemory_AllocateAndClear(sizeof(Node));
-    assertNotNull(node, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(Node));
+    parcAssertNotNull(node, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(Node));
     node->color = color;
     node->left_child = tree->nil;
     node->right_child = tree->nil;
@@ -414,9 +414,9 @@ parcTreeRedBlack_Create(PARCTreeRedBlack_KeyCompare *keyCompare,
                         PARCTreeRedBlack_ValueFree *valueFree,
                         PARCTreeRedBlack_ValueCopy *valueCopy)
 {
-    assertNotNull(keyCompare, "We need a key compare function");
+    parcAssertNotNull(keyCompare, "We need a key compare function");
     PARCTreeRedBlack *tree = parcMemory_AllocateAndClear(sizeof(PARCTreeRedBlack));
-    assertNotNull(tree, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(PARCTreeRedBlack));
+    parcAssertNotNull(tree, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(PARCTreeRedBlack));
     tree->nil = _rbNodeCreate(tree, BLACK);
     tree->nil->left_child = tree->nil;
     tree->nil->right_child = tree->nil;
@@ -435,8 +435,8 @@ parcTreeRedBlack_Create(PARCTreeRedBlack_KeyCompare *keyCompare,
 void
 parcTreeRedBlack_Destroy(PARCTreeRedBlack **treePointer)
 {
-    assertNotNull(treePointer, "pointer to pointer to tree can't be null");
-    assertNotNull(*treePointer, "pointer to tree can't be null");
+    parcAssertNotNull(treePointer, "pointer to pointer to tree can't be null");
+    parcAssertNotNull(*treePointer, "pointer to tree can't be null");
 
     if ((*treePointer)->size > 0) {
         // If we have any elements in the tree, free them
@@ -453,9 +453,9 @@ parcTreeRedBlack_Destroy(PARCTreeRedBlack **treePointer)
 void
 parcTreeRedBlack_Insert(PARCTreeRedBlack *tree, void *key, void *value)
 {
-    assertNotNull(tree, "Tree can't be NULL");
-    assertNotNull(key, "Key can't be NULL");
-    assertNotNull(value, "Value can't be NULL");
+    parcAssertNotNull(tree, "Tree can't be NULL");
+    parcAssertNotNull(key, "Key can't be NULL");
+    parcAssertNotNull(value, "Value can't be NULL");
 
     Node *newNode = _rbNodeCreate(tree, RED);
     Node *parent = tree->nil;
@@ -511,7 +511,7 @@ parcTreeRedBlack_Insert(PARCTreeRedBlack *tree, void *key, void *value)
 void *
 parcTreeRedBlack_Get(PARCTreeRedBlack *tree, const void *key)
 {
-    assertNotNull(tree, "Tree can't be NULL");
+    parcAssertNotNull(tree, "Tree can't be NULL");
 
     Node *node = tree->root;
 
@@ -535,8 +535,8 @@ parcTreeRedBlack_Get(PARCTreeRedBlack *tree, const void *key)
 void *
 parcTreeRedBlack_Remove(PARCTreeRedBlack *tree, const void *key)
 {
-    assertNotNull(tree, "Tree can't be NULL");
-    assertNotNull(key, "Key can't be NULL");
+    parcAssertNotNull(tree, "Tree can't be NULL");
+    parcAssertNotNull(key, "Key can't be NULL");
 
     Node *node = tree->root;
 
@@ -568,8 +568,8 @@ parcTreeRedBlack_Remove(PARCTreeRedBlack *tree, const void *key)
 void
 parcTreeRedBlack_RemoveAndDestroy(PARCTreeRedBlack *tree, const void *key)
 {
-    assertNotNull(tree, "Tree can't be NULL");
-    assertNotNull(key, "Key can't be NULL");
+    parcAssertNotNull(tree, "Tree can't be NULL");
+    parcAssertNotNull(key, "Key can't be NULL");
 
     Node *node = tree->root;
     // Let's get to the bottom of the tree to insert.
@@ -591,7 +591,7 @@ parcTreeRedBlack_RemoveAndDestroy(PARCTreeRedBlack *tree, const void *key)
 void *
 parcTreeRedBlack_LastKey(const PARCTreeRedBlack *tree)
 {
-    assertNotNull(tree, "Tree can't be NULL");
+    parcAssertNotNull(tree, "Tree can't be NULL");
     Node *node = tree->root;
 
     if (tree->size == 0) {
@@ -610,7 +610,7 @@ parcTreeRedBlack_LastKey(const PARCTreeRedBlack *tree)
 void *
 parcTreeRedBlack_FirstKey(const PARCTreeRedBlack *tree)
 {
-    assertNotNull(tree, "Tree can't be NULL");
+    parcAssertNotNull(tree, "Tree can't be NULL");
     Node *node = tree->root;
 
 
@@ -630,7 +630,7 @@ parcTreeRedBlack_FirstKey(const PARCTreeRedBlack *tree)
 size_t
 parcTreeRedBlack_Size(const PARCTreeRedBlack *tree)
 {
-    assertNotNull(tree, "Tree can't be NULL");
+    parcAssertNotNull(tree, "Tree can't be NULL");
 
     return tree->size;
 }
@@ -645,7 +645,7 @@ _rbGetKeys(Node *node, void *data)
 PARCArrayList *
 parcTreeRedBlack_Keys(const PARCTreeRedBlack *tree)
 {
-    assertNotNull(tree, "Tree can't be NULL");
+    parcAssertNotNull(tree, "Tree can't be NULL");
 
     PARCArrayList *keys = parcArrayList_Create(NULL);
 
@@ -665,7 +665,7 @@ _rbGetValues(Node *node, void *data)
 PARCArrayList *
 parcTreeRedBlack_Values(const PARCTreeRedBlack *tree)
 {
-    assertNotNull(tree, "Tree can't be NULL");
+    parcAssertNotNull(tree, "Tree can't be NULL");
 
     PARCArrayList *values = parcArrayList_Create(NULL);
 
@@ -678,8 +678,8 @@ parcTreeRedBlack_Values(const PARCTreeRedBlack *tree)
 int
 parcTreeRedBlack_Equals(const PARCTreeRedBlack *tree1, const PARCTreeRedBlack *tree2)
 {
-    assertNotNull(tree1, "Tree can't be NULL");
-    assertNotNull(tree2, "Tree can't be NULL");
+    parcAssertNotNull(tree1, "Tree can't be NULL");
+    parcAssertNotNull(tree2, "Tree can't be NULL");
 
     int ret = 1;
 
@@ -736,7 +736,7 @@ parcTreeRedBlack_Equals(const PARCTreeRedBlack *tree1, const PARCTreeRedBlack *t
 PARCTreeRedBlack *
 parcTreeRedBlack_Copy(const PARCTreeRedBlack *source_tree)
 {
-    assertNotNull(source_tree, "Tree can't be NULL");
+    parcAssertNotNull(source_tree, "Tree can't be NULL");
 
     void *key_source;
     void *key_copy;
diff --git a/libparc/parc/algol/parc_URI.c b/libparc/parc/algol/parc_URI.c
index 172468d8..e14dfc9f 100644
--- a/libparc/parc/algol/parc_URI.c
+++ b/libparc/parc/algol/parc_URI.c
@@ -18,7 +18,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <unistd.h>
 #include <stdio.h>
@@ -61,7 +61,7 @@ struct parc_uri {
 static void
 _parcURI_Finalize(PARCURI **uriPtr)
 {
-    assertNotNull(uriPtr, "Parameter must be a non-null pointer to a pointer to a PARCURI instance.");
+    parcAssertNotNull(uriPtr, "Parameter must be a non-null pointer to a pointer to a PARCURI instance.");
 
     PARCURI *uri = *uriPtr;
 
diff --git a/libparc/parc/algol/parc_URIAuthority.c b/libparc/parc/algol/parc_URIAuthority.c
index ac2ee351..1e3468d1 100644
--- a/libparc/parc/algol/parc_URIAuthority.c
+++ b/libparc/parc/algol/parc_URIAuthority.c
@@ -18,7 +18,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <unistd.h>
 #include <stdio.h>
diff --git a/libparc/parc/algol/parc_URIPath.c b/libparc/parc/algol/parc_URIPath.c
index ef46dac9..04636852 100755
--- a/libparc/parc/algol/parc_URIPath.c
+++ b/libparc/parc/algol/parc_URIPath.c
@@ -17,7 +17,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <unistd.h>
 #include <stdio.h>
@@ -40,7 +40,7 @@ struct parc_uri_path {
 static void
 _parcURIPath_Finalize(PARCURIPath **pathPtr)
 {
-    assertNotNull(pathPtr, "Parameter must be a non-null pointer to a pointer to a PARCURIPath instance.");
+    parcAssertNotNull(pathPtr, "Parameter must be a non-null pointer to a pointer to a PARCURIPath instance.");
 
     PARCURIPath *path = *pathPtr;
     if (path != NULL) {
@@ -89,7 +89,7 @@ parcURIPath_Trim(PARCURIPath *path, size_t numberToRemove)
 //
 //    result->segments = parcArrayList_Create((void (*)(void **))parcURISegment_Release);
 //    if (*string != 0) {
-//        assertTrue(*string == '/', "Expected initial '/' character.");
+//        parcAssertTrue(*string == '/', "Expected initial '/' character.");
 //        *pointer = string;
 //        while (**pointer != 0 && **pointer != '?' && **pointer != '#') {
 //            PARCURISegment *segment = parcURISegment_Parse(++(*pointer), pointer);
@@ -148,7 +148,7 @@ parcURIPath_Equals(const PARCURIPath *pathA, const PARCURIPath *pathB)
 PARCURIPath *
 parcURIPath_Copy(const PARCURIPath *path)
 {
-    assertNotNull(path, "Parameter must be a non-null PARC_URIPath pointer.");
+    parcAssertNotNull(path, "Parameter must be a non-null PARC_URIPath pointer.");
 
     PARCURIPath *result = parcURIPath_Create();
     result->segments = parcArrayList_Create((void (*)(void **))parcURISegment_Release);
diff --git a/libparc/parc/algol/parc_URIPath.h b/libparc/parc/algol/parc_URIPath.h
index d43d8651..4e2d62e5 100755
--- a/libparc/parc/algol/parc_URIPath.h
+++ b/libparc/parc/algol/parc_URIPath.h
@@ -332,7 +332,7 @@ PARCURIPath *parcURIPath_Append(PARCURIPath *path, const PARCURISegment *segment
  * Retrieve the URI path segment at the specified index.
  *
  *   The index must be within the range [0, number of segments]
- *   prior to invocation.  Otherwise, the program is terminated with LongBow trapOutOfBounds.
+ *   prior to invocation.  Otherwise, the program is terminated with parcTrapOutOfBounds.
  *
  * @param [in] path A `PARCURIPath` instance to be examined.
  * @param [in] index The index of the URI segment to retrieve.
diff --git a/libparc/parc/algol/parc_URISegment.c b/libparc/parc/algol/parc_URISegment.c
index 7261c3aa..786a7182 100755
--- a/libparc/parc/algol/parc_URISegment.c
+++ b/libparc/parc/algol/parc_URISegment.c
@@ -17,7 +17,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <unistd.h>
 #include <stdio.h>
@@ -93,7 +93,7 @@ _parsePercentEncoded(const char *string, unsigned char *value)
 static PARCBufferComposer *
 _parcURISegment_BuildString(const PARCURISegment *segment, PARCBufferComposer *composer)
 {
-    assertNotNull(composer, "Parameter must be a non-null pointer to a PARCBufferComposer.");
+    parcAssertNotNull(composer, "Parameter must be a non-null pointer to a PARCBufferComposer.");
 
     for (size_t i = 0; i < parcBuffer_Limit(segment->buffer) && composer != NULL; i++) {
         unsigned char c = parcBuffer_GetAtIndex(segment->buffer, i);
@@ -148,10 +148,10 @@ parcURISegment_Create(size_t length, const unsigned char segment[length])
 PARCURISegment *
 parcURISegment_Parse(const char *string, const char **pointer)
 {
-    assertFalse(*string == '/', "Input parameter '%s' must NOT point to an initial '/' character.", string);
+    parcAssertFalse(*string == '/', "Input parameter '%s' must NOT point to an initial '/' character.", string);
 
     unsigned char *segment = parcMemory_AllocateAndClear((strlen(string) + 1) * sizeof(unsigned char));
-    assertNotNull(segment, "parcMemory_AllocateAndClear(%zu) returned NULL", (strlen(string) + 1) * sizeof(unsigned char));
+    parcAssertNotNull(segment, "parcMemory_AllocateAndClear(%zu) returned NULL", (strlen(string) + 1) * sizeof(unsigned char));
     size_t length = 0;
 
     unsigned char *r = segment;
@@ -219,7 +219,7 @@ parcURISegment_Equals(const PARCURISegment *segmentA, const PARCURISegment *segm
 PARCURISegment *
 parcURISegment_Clone(const PARCURISegment *segment)
 {
-    assertNotNull(segment, "Parameter must be a non-null PARC_URISegment pointer.");
+    parcAssertNotNull(segment, "Parameter must be a non-null PARC_URISegment pointer.");
 
     PARCBuffer *copy = parcBuffer_Copy(segment->buffer);
     PARCURISegment *result = parcURISegment_CreateFromBuffer(copy);
diff --git a/libparc/parc/algol/parc_Unsigned.c b/libparc/parc/algol/parc_Unsigned.c
index 839f6b2b..a8fd1053 100644
--- a/libparc/parc/algol/parc_Unsigned.c
+++ b/libparc/parc/algol/parc_Unsigned.c
@@ -52,7 +52,7 @@ parcObject_Override(PARCUnsigned, PARCObject,
 void
 parcUnsigned_AssertValid(const PARCUnsigned *instance)
 {
-    assertTrue(parcUnsigned_IsValid(instance),
+    parcAssertTrue(parcUnsigned_IsValid(instance),
                "PARCUnsigned is not valid.");
 }
 
diff --git a/libparc/parc/algol/parc_Varint.c b/libparc/parc/algol/parc_Varint.c
index 7a593f45..7a1d2698 100755
--- a/libparc/parc/algol/parc_Varint.c
+++ b/libparc/parc/algol/parc_Varint.c
@@ -17,7 +17,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -45,12 +45,12 @@ parcVarint_Create(void)
 PARCVarint *
 parcVarint_DecodeBuffer(PARCBuffer *buffer, size_t length)
 {
-    assertNotNull(buffer, "Parameter must be a non-null PARCBuffer pointer.");
-    assertTrue(length < sizeof(size_t), "Length must be less then or equal to %zd", sizeof(size_t));
-    assertTrue(length <= parcBuffer_Remaining(buffer), "Buffer does not contain at least %zd bytes", length);
+    parcAssertNotNull(buffer, "Parameter must be a non-null PARCBuffer pointer.");
+    parcAssertTrue(length < sizeof(size_t), "Length must be less then or equal to %zd", sizeof(size_t));
+    parcAssertTrue(length <= parcBuffer_Remaining(buffer), "Buffer does not contain at least %zd bytes", length);
 
     PARCVarint *result = parcVarint_Create();
-    assertNotNull(result, "PARCVarint out of memory.");
+    parcAssertNotNull(result, "PARCVarint out of memory.");
 
     for (size_t i = 0; i < length; i++) {
         parcVarint_ShiftLeft(result, 8);
@@ -63,11 +63,11 @@ parcVarint_DecodeBuffer(PARCBuffer *buffer, size_t length)
 PARCVarint *
 parcVarint_DecodeElasticByteBuffer(const PARCBuffer *buffer, size_t length)
 {
-    assertNotNull(buffer, "Parameter must be a non-null PARCBuffer pointer.");
-    assertTrue(length < sizeof(size_t), "Length must be less then or equal to %zd", sizeof(size_t));
+    parcAssertNotNull(buffer, "Parameter must be a non-null PARCBuffer pointer.");
+    parcAssertTrue(length < sizeof(size_t), "Length must be less then or equal to %zd", sizeof(size_t));
 
     PARCVarint *result = parcVarint_Create();
-    assertNotNull(result, "PARCVarint out of memory.");
+    parcAssertNotNull(result, "PARCVarint out of memory.");
 
     for (size_t i = 0; i < length; i++) {
         parcVarint_ShiftLeft(result, 8);
@@ -87,7 +87,7 @@ parcVarint_Set(PARCVarint *varint, uint64_t newValue)
 PARCVarint *
 parcVarint_FromElasticByteBuffer(const PARCBuffer *buffer)
 {
-    assertNotNull(buffer, "Parameter must be a non-null PARCBuffer pointer.");
+    parcAssertNotNull(buffer, "Parameter must be a non-null PARCBuffer pointer.");
     PARCVarint *result = parcVarint_Create();
 
     size_t length = parcBuffer_Remaining(buffer);
@@ -103,7 +103,7 @@ parcVarint_FromElasticByteBuffer(const PARCBuffer *buffer)
 PARCVarint *
 parcVarint_FromUTF8ByteBuffer(const PARCBuffer *buffer)
 {
-    assertNotNull(buffer, "Parameter must not be NULL.");
+    parcAssertNotNull(buffer, "Parameter must not be NULL.");
     PARCVarint *result = parcVarint_Create();
 
     if (result != NULL) {
@@ -121,7 +121,7 @@ parcVarint_FromUTF8ByteBuffer(const PARCBuffer *buffer)
 PARCVarint *
 parcVarint_FromUTF8Buffer(PARCBuffer *buffer)
 {
-    assertNotNull(buffer, "Parameter must be a non-null PARCBuffer pointer.");
+    parcAssertNotNull(buffer, "Parameter must be a non-null PARCBuffer pointer.");
     PARCVarint *result = parcVarint_Create();
 
     if (result != NULL) {
@@ -180,8 +180,8 @@ parcVarint_FromUint64(uint64_t uint)
 void
 parcVarint_Destroy(PARCVarint **varintP)
 {
-    assertNotNull(varintP, "Parameter must be a non-null pointer to a pointer to a PARCVarint");
-    assertNotNull(*varintP, "Parameter must be a non-null pointer to a PARCVarint");
+    parcAssertNotNull(varintP, "Parameter must be a non-null pointer to a pointer to a PARCVarint");
+    parcAssertNotNull(*varintP, "Parameter must be a non-null pointer to a PARCVarint");
 
     parcMemory_Deallocate((void **) varintP);
     *varintP = NULL;
@@ -197,7 +197,7 @@ parcVarint_Destroy(PARCVarint **varintP)
 PARCVarint *
 parcVarint_ShiftLeft(PARCVarint *varint, int bits)
 {
-    assertNotNull(varint, "Parameter must be a non-null pointer to a PARCVarint.");
+    parcAssertNotNull(varint, "Parameter must be a non-null pointer to a PARCVarint.");
     varint->value <<= bits;
 
     return varint;
@@ -206,7 +206,7 @@ parcVarint_ShiftLeft(PARCVarint *varint, int bits)
 PARCVarint *
 parcVarint_Add(PARCVarint *varint, int addend)
 {
-    assertNotNull(varint, "Parameter must be a non-null pointer to a PARCVarint.");
+    parcAssertNotNull(varint, "Parameter must be a non-null pointer to a PARCVarint.");
     varint->value += addend;
 
     return varint;
@@ -215,7 +215,7 @@ parcVarint_Add(PARCVarint *varint, int addend)
 PARCVarint *
 parcVarint_Subtract(PARCVarint *varint, int subtrahend)
 {
-    assertNotNull(varint, "Parameter must be a non-null pointer to a PARCVarint.");
+    parcAssertNotNull(varint, "Parameter must be a non-null pointer to a PARCVarint.");
     varint->value -= subtrahend;
 
     return varint;
@@ -224,7 +224,7 @@ parcVarint_Subtract(PARCVarint *varint, int subtrahend)
 PARCVarint *
 parcVarint_Multiply(PARCVarint *varint, int multiplicand)
 {
-    assertNotNull(varint, "Parameter must be a non-null pointer to a PARCVarint.");
+    parcAssertNotNull(varint, "Parameter must be a non-null pointer to a PARCVarint.");
     varint->value *= multiplicand;
 
     return varint;
@@ -233,7 +233,7 @@ parcVarint_Multiply(PARCVarint *varint, int multiplicand)
 PARCVarint *
 parcVarint_Divide(PARCVarint *varint, int divisor)
 {
-    assertNotNull(varint, "Parameter must be a non-null pointer to a PARCVarint.");
+    parcAssertNotNull(varint, "Parameter must be a non-null pointer to a PARCVarint.");
     varint->value /= divisor;
 
     return varint;
@@ -249,7 +249,7 @@ parcVarint_Divide(PARCVarint *varint, int divisor)
 PARCVarint *
 parcVarint_ShiftRight(PARCVarint *varint, int bits)
 {
-    assertNotNull(varint, "Parameter must be a non-null pointer to a PARCVarint.");
+    parcAssertNotNull(varint, "Parameter must be a non-null pointer to a PARCVarint.");
     varint->value >>= bits;
     return varint;
 }
@@ -265,8 +265,8 @@ parcVarint_ShiftRight(PARCVarint *varint, int bits)
 PARCVarint *
 parcVarint_And(PARCVarint *varint, PARCVarint *operand)
 {
-    assertNotNull(varint, "Parameter varint must not be NULL.");
-    assertNotNull(operand, "Parameter operand must not be NULL.");
+    parcAssertNotNull(varint, "Parameter varint must not be NULL.");
+    parcAssertNotNull(operand, "Parameter operand must not be NULL.");
     varint->value &= operand->value;
     return varint;
 }
@@ -280,7 +280,7 @@ parcVarint_And(PARCVarint *varint, PARCVarint *operand)
 PARCVarint *
 parcVarint_AndUint8(PARCVarint *varint, uint8_t operand)
 {
-    assertNotNull(varint, "Parameter varint must not be NULL.");
+    parcAssertNotNull(varint, "Parameter varint must not be NULL.");
     varint->value &= operand;
     return varint;
 }
@@ -294,7 +294,7 @@ parcVarint_AndUint8(PARCVarint *varint, uint8_t operand)
 PARCVarint *
 parcVarint_AndUint16(PARCVarint *varint, uint16_t operand)
 {
-    assertNotNull(varint, "Parameter varint must not be NULL.");
+    parcAssertNotNull(varint, "Parameter varint must not be NULL.");
     varint->value &= operand;
     return varint;
 }
@@ -308,7 +308,7 @@ parcVarint_AndUint16(PARCVarint *varint, uint16_t operand)
 PARCVarint *
 parcVarint_AndUint32(PARCVarint *varint, uint32_t operand)
 {
-    assertNotNull(varint, "Parameter varint must not be NULL.");
+    parcAssertNotNull(varint, "Parameter varint must not be NULL.");
     varint->value &= operand;
     return varint;
 }
@@ -322,7 +322,7 @@ parcVarint_AndUint32(PARCVarint *varint, uint32_t operand)
 PARCVarint *
 parcVarint_AndUint64(PARCVarint *varint, uint64_t operand)
 {
-    assertNotNull(varint, "Parameter must be a non-null PARCVarint pointer.");
+    parcAssertNotNull(varint, "Parameter must be a non-null PARCVarint pointer.");
     varint->value &= operand;
     return varint;
 }
@@ -336,7 +336,7 @@ parcVarint_AndUint64(PARCVarint *varint, uint64_t operand)
 PARCVarint *
 parcVarint_Or(PARCVarint *varint, PARCVarint *operand)
 {
-    assertNotNull(varint, "Parameter must be a non-null PARCVarint pointer.");
+    parcAssertNotNull(varint, "Parameter must be a non-null PARCVarint pointer.");
     varint->value |= operand->value;
     return varint;
 }
@@ -351,7 +351,7 @@ parcVarint_Or(PARCVarint *varint, PARCVarint *operand)
 PARCVarint *
 parcVarint_OrUint8(PARCVarint *varint, uint8_t operand)
 {
-    assertNotNull(varint, "Parameter varint must not be NULL.");
+    parcAssertNotNull(varint, "Parameter varint must not be NULL.");
     varint->value |= operand;
     return varint;
 }
@@ -366,7 +366,7 @@ parcVarint_OrUint8(PARCVarint *varint, uint8_t operand)
 PARCVarint *
 parcVarint_OrUint16(PARCVarint *varint, uint16_t operand)
 {
-    assertNotNull(varint, "Parameter varint must not be NULL.");
+    parcAssertNotNull(varint, "Parameter varint must not be NULL.");
     varint->value |= operand;
     return varint;
 }
@@ -381,7 +381,7 @@ parcVarint_OrUint16(PARCVarint *varint, uint16_t operand)
 PARCVarint *
 parcVarint_OrUint32(PARCVarint *varint, uint32_t operand)
 {
-    assertNotNull(varint, "Parameter varint must not be NULL.");
+    parcAssertNotNull(varint, "Parameter varint must not be NULL.");
     varint->value |= operand;
     return varint;
 }
@@ -396,7 +396,7 @@ parcVarint_OrUint32(PARCVarint *varint, uint32_t operand)
 PARCVarint *
 parcVarint_OrUint64(PARCVarint *varint, uint64_t operand)
 {
-    assertNotNull(varint, "Parameter varint must not be NULL.");
+    parcAssertNotNull(varint, "Parameter varint must not be NULL.");
     varint->value |= operand;
     return varint;
 }
@@ -411,7 +411,7 @@ parcVarint_OrUint64(PARCVarint *varint, uint64_t operand)
 int
 parcVarint_Equals(PARCVarint *varint, PARCVarint *operand)
 {
-    assertNotNull(varint, "Parameter varint must not be NULL.");
+    parcAssertNotNull(varint, "Parameter varint must not be NULL.");
     return varint->value == operand->value;
 }
 
@@ -424,7 +424,7 @@ parcVarint_Equals(PARCVarint *varint, PARCVarint *operand)
 int
 parcVarint_EqualsUint64(PARCVarint *varint, uint64_t value)
 {
-    assertNotNull(varint, "Parameter varint must not be NULL.");
+    parcAssertNotNull(varint, "Parameter varint must not be NULL.");
     return varint->value == value;
 }
 
@@ -437,7 +437,7 @@ parcVarint_EqualsUint64(PARCVarint *varint, uint64_t value)
 int
 parcVarint_EqualsUint32(PARCVarint *varint, uint32_t value)
 {
-    assertNotNull(varint, "Parameter varint must not be NULL.");
+    parcAssertNotNull(varint, "Parameter varint must not be NULL.");
     return parcVarint_EqualsUint64(varint, (uint64_t) value);
 }
 
@@ -450,7 +450,7 @@ parcVarint_EqualsUint32(PARCVarint *varint, uint32_t value)
 int
 parcVarint_EqualsUint16(PARCVarint *varint, uint16_t value)
 {
-    assertNotNull(varint, "Parameter varint must not be NULL.");
+    parcAssertNotNull(varint, "Parameter varint must not be NULL.");
     return parcVarint_EqualsUint64(varint, (uint64_t) value);
 }
 
@@ -463,7 +463,7 @@ parcVarint_EqualsUint16(PARCVarint *varint, uint16_t value)
 int
 parcVarint_EqualsUint8(PARCVarint *varint, uint8_t value)
 {
-    assertNotNull(varint, "Parameter varint must not be NULL.");
+    parcAssertNotNull(varint, "Parameter varint must not be NULL.");
     return parcVarint_EqualsUint64(varint, (uint64_t) value);
 }
 
@@ -476,7 +476,7 @@ parcVarint_EqualsUint8(PARCVarint *varint, uint8_t value)
 uint8_t
 parcVarint_AsUint8(const PARCVarint *varint)
 {
-    assertNotNull(varint, "Parameter varint must not be NULL.");
+    parcAssertNotNull(varint, "Parameter varint must not be NULL.");
     return (uint8_t) varint->value;
 }
 
@@ -489,7 +489,7 @@ parcVarint_AsUint8(const PARCVarint *varint)
 uint16_t
 parcVarint_AsUint16(const PARCVarint *varint)
 {
-    assertNotNull(varint, "Parameter varint must not be NULL.");
+    parcAssertNotNull(varint, "Parameter varint must not be NULL.");
     return (uint16_t) varint->value;
 }
 
@@ -502,14 +502,14 @@ parcVarint_AsUint16(const PARCVarint *varint)
 uint32_t
 parcVarint_AsUint32(const PARCVarint *varint)
 {
-    assertNotNull(varint, "Parameter varint must not be NULL.");
+    parcAssertNotNull(varint, "Parameter varint must not be NULL.");
     return (uint32_t) varint->value;
 }
 
 uint64_t
 parcVarint_AsUint64(const PARCVarint *varint)
 {
-    assertNotNull(varint, "Parameter varint must not be NULL.");
+    parcAssertNotNull(varint, "Parameter varint must not be NULL.");
     return varint->value;
 }
 
@@ -522,7 +522,7 @@ parcVarint_AsUint64(const PARCVarint *varint)
 size_t
 parcVarint_AsSize(const PARCVarint *varint)
 {
-    assertNotNull(varint, "Parameter varint must not be NULL.");
+    parcAssertNotNull(varint, "Parameter varint must not be NULL.");
     return (size_t) varint->value;
 }
 
@@ -536,8 +536,8 @@ parcVarint_AsSize(const PARCVarint *varint)
 char *
 parcVarint_ToString(char **string, PARCVarint *varint)
 {
-    assertNotNull(varint, "Parameter varint must not be NULL.");
+    parcAssertNotNull(varint, "Parameter varint must not be NULL.");
     int nwritten = asprintf(string, "%" PRIu64, varint->value);
-    assertTrue(nwritten >= 0, "Error calling asprintf");
+    parcAssertTrue(nwritten >= 0, "Error calling asprintf");
     return *string;
 }
diff --git a/libparc/parc/algol/parc_Vector.c b/libparc/parc/algol/parc_Vector.c
index f5380eb7..1d0e9a1d 100755
--- a/libparc/parc/algol/parc_Vector.c
+++ b/libparc/parc/algol/parc_Vector.c
@@ -17,7 +17,7 @@
  */
 #include <config.h>
 
-#include <LongBow/runtime.h>
+#include <parc/assert/parc_Assert.h>
 
 #include <stdio.h>
 #include <stdbool.h>
@@ -46,7 +46,7 @@ parcVector_Create(const void *pointer, const size_t length)
 PARCVector *
 parcVector_Init(PARCVector *vector, const void *pointer, const size_t length)
 {
-    assertNotNull(vector, "Parameter must be a non-null PARCVector pointer");
+    parcAssertNotNull(vector, "Parameter must be a non-null PARCVector pointer");
 
     vector->pointer = pointer;
     vector->length = length;
@@ -56,9 +56,9 @@ parcVector_Init(PARCVector *vector, const void *pointer, const size_t length)
 void
 parcVector_Destroy(PARCVector **vectorPtr)
 {
-    assertNotNull(vectorPtr, "Parameter must be a non-null PARCVector pointer");
+    parcAssertNotNull(vectorPtr, "Parameter must be a non-null PARCVector pointer");
     PARCVector *vector = *vectorPtr;
-    assertNotNull(vector, "Vector is already free or was not set.\n");
+    parcAssertNotNull(vector, "Vector is already free or was not set.\n");
 
     parcMemory_Deallocate((void **) &vector);
     *vectorPtr = NULL;
@@ -67,14 +67,14 @@ parcVector_Destroy(PARCVector **vectorPtr)
 const void *
 parcVector_GetPointer(const PARCVector *vector)
 {
-    assertNotNull(vector, "Parameter must be a non-null PARCVector pointer.");
+    parcAssertNotNull(vector, "Parameter must be a non-null PARCVector pointer.");
     return vector->pointer;
 }
 
 size_t
 parcVector_GetLength(const PARCVector *vector)
 {
-    assertNotNull(vector, "Parameter must be a non-null PARCVector pointer.");
+    parcAssertNotNull(vector, "Parameter must be a non-null PARCVector pointer.");
 
     return vector->length;
 }
diff --git a/libparc/parc/algol/test/test_parc_ArrayList.c b/libparc/parc/algol/test/test_parc_ArrayList.c
index 9e387a28..51e9e11c 100755
--- a/libparc/parc/algol/test/test_parc_ArrayList.c
+++ b/libparc/parc/algol/test/test_parc_ArrayList.c
@@ -641,11 +641,14 @@ LONGBOW_TEST_FIXTURE_TEARDOWN(Errors)
 LONGBOW_TEST_CASE_EXPECTS(Errors, PARC_ArrayList_InsertAtIndex_OutOfCapacity, .event = &LongBowAssertEvent)
 {
     PARCArrayList *array = longBowTestCase_GetClipBoardData(testCase);
-
+    printf("1\n");
     parcArrayList_Add(array, (void *) 1);
+        printf("2\n");
     parcArrayList_Add(array, (void *) 2);
+        printf("3\n");
 
     parcArrayList_InsertAtIndex(array, 200, (void *) 3);
+        printf("4\n");
 }
 
 int