Merge "Initial commit: cframework. Longbow and Libparc" into cframework/master

4 files changed, 643 insertions, 0 deletions

diff --git a/libparc/parc/testing/test/.gitignore b/libparc/parc/testing/test/.gitignore
new file mode 100644
index 00000000..3b3dc64d
--- /dev/null
+++ b/libparc/parc/testing/test/.gitignore
@@ -0,0 +1,2 @@
+test_parc_MemoryTesting
+test_parc_ObjectTesting
diff --git a/libparc/parc/testing/test/CMakeLists.txt b/libparc/parc/testing/test/CMakeLists.txt
new file mode 100644
index 00000000..1de2e89d
--- /dev/null
+++ b/libparc/parc/testing/test/CMakeLists.txt
@@ -0,0 +1,12 @@
+set(TestsExpectedToPass
+  test_parc_MemoryTesting
+  test_parc_ObjectTesting
+  )
+
+# Enable gcov output for the tests
+add_definitions(--coverage)
+set(CMAKE_EXE_LINKER_FLAGS ${CMAKE_EXE_LINKER_FLAGS} " --coverage")
+
+foreach(test ${TestsExpectedToPass})
+   AddTest(${test})
+endforeach()
diff --git a/libparc/parc/testing/test/test_parc_MemoryTesting.c b/libparc/parc/testing/test/test_parc_MemoryTesting.c
new file mode 100755
index 00000000..d24e79d4
--- /dev/null
+++ b/libparc/parc/testing/test/test_parc_MemoryTesting.c
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2017 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/** *
+ */
+// Include the file(s) containing the functions to be tested.
+// This permits internal static functions to be visible to this Test Framework.
+#include "../parc_MemoryTesting.c"
+
+#include <LongBow/testing.h>
+#include <LongBow/debugging.h>
+
+#include <parc/algol/parc_Memory.h>
+
+LONGBOW_TEST_RUNNER(test_parc_MemoryTest)
+{
+    // The following Test Fixtures will run their corresponding Test Cases.
+    // Test Fixtures are run in the order specified, but all tests should be idempotent.
+    // Never rely on the execution order of tests or share state between them.
+    LONGBOW_RUN_TEST_FIXTURE(Global);
+}
+
+// The Test Runner calls this function once before any Test Fixtures are run.
+LONGBOW_TEST_RUNNER_SETUP(test_parc_MemoryTest)
+{
+    return LONGBOW_STATUS_SUCCEEDED;
+}
+
+// The Test Runner calls this function once after all the Test Fixtures are run.
+LONGBOW_TEST_RUNNER_TEARDOWN(test_parc_MemoryTest)
+{
+    return LONGBOW_STATUS_SUCCEEDED;
+}
+
+LONGBOW_TEST_FIXTURE(Global)
+{
+    LONGBOW_RUN_TEST_CASE(Global, parcMemoryTesting_ExpectedOutstanding);
+}
+
+LONGBOW_TEST_FIXTURE_SETUP(Global)
+{
+    return LONGBOW_STATUS_SUCCEEDED;
+}
+
+LONGBOW_TEST_FIXTURE_TEARDOWN(Global)
+{
+    return LONGBOW_STATUS_SUCCEEDED;
+}
+
+LONGBOW_TEST_CASE(Global, parcMemoryTesting_ExpectedOutstanding)
+{
+    void *memory = parcMemory_Allocate(4);
+
+    assertTrue(parcMemoryTesting_ExpectedOutstanding(1, "Expected 1 outstanding allocation"),
+               "Failed 1 expected allocation");
+
+    parcMemory_Deallocate(&memory);
+    assertTrue(parcMemoryTesting_ExpectedOutstanding(0, "Expected 0 outstanding allocations"),
+               "Failed 0 expected allocations");
+
+    assertFalse(parcMemoryTesting_ExpectedOutstanding(1, "Expected 1 outstanding allocations"),
+                "Failed 1 expected llocations");
+    assertFalse(parcMemoryTesting_ExpectedOutstanding(-1, "Expected -1 outstanding allocations"),
+                "Failed -1 expected allocations");
+}
+
+int
+main(int argc, char *argv[argc])
+{
+    LongBowRunner *testRunner = LONGBOW_TEST_RUNNER_CREATE(test_parc_MemoryTest);
+    int exitStatus = LONGBOW_TEST_MAIN(argc, argv, testRunner);
+    longBowTestRunner_Destroy(&testRunner);
+    exit(exitStatus);
+}
diff --git a/libparc/parc/testing/test/test_parc_ObjectTesting.c b/libparc/parc/testing/test/test_parc_ObjectTesting.c
new file mode 100755
index 00000000..9d70b68c
--- /dev/null
+++ b/libparc/parc/testing/test/test_parc_ObjectTesting.c
@@ -0,0 +1,543 @@
+/*
+ * Copyright (c) 2017 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ */
+// Include the file(s) containing the functions to be tested.
+// This permits internal static functions to be visible to this Test Framework.
+#include "../parc_ObjectTesting.c"
+#include <LongBow/unit-test.h>
+#include <LongBow/debugging.h>
+
+#include <inttypes.h>
+#include <stdio.h>
+#include <inttypes.h>
+
+#include <parc/algol/parc_SafeMemory.h>
+#include <parc/testing/parc_ObjectTesting.h>
+#include <parc/testing/parc_MemoryTesting.h>
+
+LONGBOW_TEST_RUNNER(test_parc_ObjectTesting)
+{
+    // The following Test Fixtures will run their corresponding Test Cases.
+    // Test Fixtures are run in the order specified, but all tests should be idempotent.
+    // Never rely on the execution order of tests or share state between them.
+    LONGBOW_RUN_TEST_FIXTURE(Static);
+    LONGBOW_RUN_TEST_FIXTURE(CompareTo);
+    LONGBOW_RUN_TEST_FIXTURE(Equals);
+    LONGBOW_RUN_TEST_FIXTURE(AcquireRelease);
+    LONGBOW_RUN_TEST_FIXTURE(Conformance);
+}
+
+// The Test Runner calls this function once before any Test Fixtures are run.
+LONGBOW_TEST_RUNNER_SETUP(test_parc_ObjectTesting)
+{
+    parcMemory_SetInterface(&PARCSafeMemoryAsPARCMemory);
+
+    return LONGBOW_STATUS_SUCCEEDED;
+}
+
+// The Test Runner calls this function once after all the Test Fixtures are run.
+LONGBOW_TEST_RUNNER_TEARDOWN(test_parc_ObjectTesting)
+{
+    uint32_t outstandingAllocations = parcSafeMemory_ReportAllocation(STDERR_FILENO);
+    if (outstandingAllocations != 0) {
+        printf("%s leaks memory by %d allocations\n", longBowTestRunner_GetName(testRunner), outstandingAllocations);
+        return LONGBOW_STATUS_MEMORYLEAK;
+    }
+
+    return LONGBOW_STATUS_SUCCEEDED;
+}
+
+static bool
+_equalsFunction(const void *x, const void *y)
+{
+    if (x == y) {
+        return true;
+    }
+    if (x == NULL || y == NULL) {
+        return false;
+    }
+
+    return (strcmp(x, y) == 0);
+}
+
+static bool
+_equalsFunction_NotReflexive(const void *x, const void *y)
+{
+    if (x == y) {
+        return true;
+    }
+    if (x == NULL || y == NULL) {
+        return false;
+    }
+    if (x < y) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+LONGBOW_TEST_FIXTURE(Equals)
+{
+    LONGBOW_RUN_TEST_CASE(Equals, parcObjectTesting_AssertEquals);
+
+    LONGBOW_RUN_TEST_CASE(Equals, parcObjectTesting_AssertEqualsFunctionImpl);
+    LONGBOW_RUN_TEST_CASE(Equals, parcObjectTesting_AssertEqualsFunctionImpl_FailXYsame);
+    LONGBOW_RUN_TEST_CASE(Equals, parcObjectTesting_AssertEqualsFunctionImpl_FailXZsame);
+    LONGBOW_RUN_TEST_CASE(Equals, parcObjectTesting_AssertEqualsFunctionImpl_FailXnotequalZ);
+    LONGBOW_RUN_TEST_CASE(Equals, parcObjectTesting_AssertEqualsFunctionImpl_FailXnotequalY);
+    LONGBOW_RUN_TEST_CASE(Equals, parcObjectTesting_AssertEqualsFunctionImpl_FailNotSymmetric);
+}
+
+static uint32_t _longBowGlobal_Global_outstanding;
+
+LONGBOW_TEST_FIXTURE_SETUP(Equals)
+{
+    _longBowGlobal_Global_outstanding = parcMemory_Outstanding();
+    return LONGBOW_STATUS_SUCCEEDED;
+}
+
+LONGBOW_TEST_FIXTURE_TEARDOWN(Equals)
+{
+    LongBowStatus result = LONGBOW_STATUS_SUCCEEDED;
+
+    if (parcMemoryTesting_ExpectedOutstanding(_longBowGlobal_Global_outstanding, longBowTestCase_GetName(testCase)) == false) {
+        parcSafeMemory_ReportAllocation(STDERR_FILENO);
+        result = LONGBOW_STATUS_MEMORYLEAK;
+    }
+
+    return result;
+}
+
+LONGBOW_TEST_CASE(Equals, parcObjectTesting_AssertEquals)
+{
+    PARCBuffer *x = parcBuffer_Allocate(sizeof(uint64_t));
+    PARCBuffer *y = parcBuffer_Allocate(sizeof(uint64_t));
+    PARCBuffer *z = parcBuffer_Allocate(sizeof(uint64_t));
+    PARCBuffer *u1 = parcBuffer_Allocate(sizeof(uint64_t));
+    PARCBuffer *u2 = parcBuffer_Allocate(sizeof(uint64_t));
+    parcBuffer_Flip(parcBuffer_PutUint64(x, 1));
+    parcBuffer_Flip(parcBuffer_PutUint64(y, 1));
+    parcBuffer_Flip(parcBuffer_PutUint64(z, 1));
+    parcBuffer_Flip(parcBuffer_PutUint64(u1, 2));
+    parcBuffer_Flip(parcBuffer_PutUint64(u2, 3));
+
+    parcObjectTesting_AssertEquals(x, y, z, u1, u2, NULL);
+    parcBuffer_Release(&x);
+    parcBuffer_Release(&y);
+    parcBuffer_Release(&z);
+    parcBuffer_Release(&u1);
+    parcBuffer_Release(&u2);
+}
+
+LONGBOW_TEST_CASE(Equals, parcObjectTesting_AssertEqualsFunctionImpl)
+{
+    void *x = strdup("1");
+    void *y = strdup("1");
+    void *z = strdup("1");
+    void *u1 = "a";
+    void *u2 = "b";
+
+    parcObjectTesting_AssertEqualsFunctionImpl(_equalsFunction, x, y, z, u1, u2, NULL);
+    free(x);
+    free(y);
+    free(z);
+}
+
+LONGBOW_TEST_CASE_EXPECTS(Equals, parcObjectTesting_AssertEqualsFunctionImpl_FailXYsame, .event = &LongBowAssertEvent)
+{
+    void *x = strdup("1");
+    void *y = x;
+    void *z = strdup("1");
+    void *u1 = "a";
+    void *u2 = "b";
+
+    parcObjectTesting_AssertEqualsFunctionImpl(_equalsFunction, x, y, z, u1, u2, NULL);
+    free(x);
+    free(y);
+    free(z);
+}
+
+LONGBOW_TEST_CASE_EXPECTS(Equals, parcObjectTesting_AssertEqualsFunctionImpl_FailXZsame, .event = &LongBowAssertEvent)
+{
+    void *x = strdup("1");
+    void *y = strdup("1");
+    void *z = x;
+    void *u1 = "a";
+    void *u2 = "b";
+
+    parcObjectTesting_AssertEqualsFunctionImpl(_equalsFunction, x, y, z, u1, u2, NULL);
+    free(x);
+    free(y);
+    free(z);
+}
+
+LONGBOW_TEST_CASE_EXPECTS(Equals, parcObjectTesting_AssertEqualsFunctionImpl_FailXnotequalY, .event = &LongBowAssertEvent)
+{
+    void *x = strdup("1");
+    void *y = strdup("xyzzy");
+    void *z = strdup("1");
+    void *u1 = "a";
+    void *u2 = "b";
+
+    parcObjectTesting_AssertEqualsFunctionImpl(_equalsFunction, x, y, z, u1, u2, NULL);
+    free(x);
+    free(y);
+    free(z);
+}
+
+LONGBOW_TEST_CASE_EXPECTS(Equals, parcObjectTesting_AssertEqualsFunctionImpl_FailXnotequalZ, .event = &LongBowAssertEvent)
+{
+    void *x = strdup("1");
+    void *y = strdup("1");
+    void *z = strdup("xyzzy");
+    void *u1 = "a";
+    void *u2 = "b";
+
+    parcObjectTesting_AssertEqualsFunctionImpl(_equalsFunction, x, y, z, u1, u2, NULL);
+    free(x);
+    free(y);
+    free(z);
+}
+
+LONGBOW_TEST_CASE_EXPECTS(Equals, parcObjectTesting_AssertEqualsFunctionImpl_FailNotSymmetric, .event = &LongBowAssertEvent)
+{
+    void *x = strdup("1");
+    void *y = strdup("1");
+    void *z = strdup("1");
+    void *u1 = "a";
+    void *u2 = "b";
+
+    parcObjectTesting_AssertEqualsFunctionImpl(_equalsFunction_NotReflexive, x, y, z, u1, u2, NULL);
+    free(x);
+    free(y);
+    free(z);
+}
+
+LONGBOW_TEST_FIXTURE(AcquireRelease)
+{
+    LONGBOW_RUN_TEST_CASE(AcquireRelease, parcObjectTesting_AssertAcquire);
+}
+
+LONGBOW_TEST_FIXTURE_SETUP(AcquireRelease)
+{
+    _longBowGlobal_Global_outstanding = parcMemory_Outstanding();
+    return LONGBOW_STATUS_SUCCEEDED;
+}
+
+LONGBOW_TEST_FIXTURE_TEARDOWN(AcquireRelease)
+{
+    LongBowStatus result = LONGBOW_STATUS_SUCCEEDED;
+
+    if (parcMemoryTesting_ExpectedOutstanding(_longBowGlobal_Global_outstanding, longBowTestCase_GetName(testCase)) == false) {
+        parcSafeMemory_ReportAllocation(STDERR_FILENO);
+        result = LONGBOW_STATUS_MEMORYLEAK;
+    }
+
+    return result;
+}
+
+LONGBOW_TEST_CASE(AcquireRelease, parcObjectTesting_AssertAcquire)
+{
+    PARCBuffer *buffer = parcBuffer_Allocate(10);
+    parcObjectTesting_AssertAcquireReleaseImpl(buffer);
+    parcBuffer_Release(&buffer);
+}
+
+
+LONGBOW_TEST_FIXTURE(CompareTo)
+{
+    LONGBOW_RUN_TEST_CASE(CompareTo, parcObjectTesting_AssertCompareTo);
+}
+
+LONGBOW_TEST_FIXTURE_SETUP(CompareTo)
+{
+    _longBowGlobal_Global_outstanding = parcMemory_Outstanding();
+    return LONGBOW_STATUS_SUCCEEDED;
+}
+
+LONGBOW_TEST_FIXTURE_TEARDOWN(CompareTo)
+{
+    LongBowStatus result = LONGBOW_STATUS_SUCCEEDED;
+
+    if (parcMemoryTesting_ExpectedOutstanding(_longBowGlobal_Global_outstanding, longBowTestCase_GetName(testCase)) == false) {
+        parcSafeMemory_ReportAllocation(STDERR_FILENO);
+        result = LONGBOW_STATUS_MEMORYLEAK;
+    }
+
+    return result;
+}
+
+LONGBOW_TEST_CASE(CompareTo, parcObjectTesting_AssertCompareTo)
+{
+    PARCBuffer *x = parcBuffer_Wrap((uint8_t [10]) { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 10, 0, 10);
+    PARCBuffer *y = parcBuffer_Wrap((uint8_t [10]) { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 10, 0, 10);
+
+    PARCBuffer *equivalent[] = {
+        x,
+        y,
+        NULL
+    };
+    PARCBuffer *lesser[] = {
+        parcBuffer_Wrap((uint8_t [10]) { 0, 1, 2, 3, 4, 5, 6, 7, 8, 8 }, 10, 0, 10),
+        parcBuffer_Wrap((uint8_t [9])  { 0, 1, 2, 3, 4, 5, 5, 7, 8,   }, 9,  0, 9),
+        NULL
+    };
+    PARCBuffer *greater[] = {
+        parcBuffer_Wrap((uint8_t [10]) { 0, 1, 2, 3, 4, 5, 6, 7, 8, 10 }, 10, 0, 10),
+        parcBuffer_Wrap((uint8_t [11]) { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 11, 0, 11),
+        NULL
+    };
+
+    parcObjectTesting_AssertCompareTo(parcBuffer_Compare, x, equivalent, lesser, greater);
+
+    parcBuffer_Release(&x);
+    parcBuffer_Release(&y);
+
+    for (int i = 0; lesser[i] != NULL; i++) {
+        parcBuffer_Release(&lesser[i]);
+    }
+    for (int i = 0; greater[i] != NULL; i++) {
+        parcBuffer_Release(&greater[i]);
+    }
+}
+
+LONGBOW_TEST_FIXTURE(Static)
+{
+}
+
+LONGBOW_TEST_FIXTURE_SETUP(Static)
+{
+    _longBowGlobal_Global_outstanding = parcMemory_Outstanding();
+    return LONGBOW_STATUS_SUCCEEDED;
+}
+
+LONGBOW_TEST_FIXTURE_TEARDOWN(Static)
+{
+    LongBowStatus result = LONGBOW_STATUS_SUCCEEDED;
+
+    size_t allocationsLeaked = parcMemory_Outstanding() - _longBowGlobal_Global_outstanding;
+
+    if (allocationsLeaked) {
+        printf("%s leaks memory by %zd allocations\n", longBowTestCase_GetName(testCase), allocationsLeaked);
+        parcSafeMemory_ReportAllocation(STDERR_FILENO);
+        result = LONGBOW_STATUS_MEMORYLEAK;
+    }
+    return result;
+}
+
+LONGBOW_TEST_FIXTURE(Conformance)
+{
+    LONGBOW_RUN_TEST_CASE(Conformance, parcObjectTesting_AssertObjectConformance_succeed);
+
+    LONGBOW_RUN_TEST_CASE(Conformance, parcObjectTesting_AssertObjectConformance_fail_non_object);
+    LONGBOW_RUN_TEST_CASE(Conformance, parcObjectTesting_AssertObjectConformance_fail_object_equals);
+    LONGBOW_RUN_TEST_CASE(Conformance, parcObjectTesting_AssertObjectConformance_fail_object_compare);
+    LONGBOW_RUN_TEST_CASE(Conformance, parcObjectTesting_AssertObjectConformance_fail_object_copy_junk);
+    LONGBOW_RUN_TEST_CASE(Conformance, parcObjectTesting_AssertObjectConformance_fail_object_copy_same);
+    LONGBOW_RUN_TEST_CASE(Conformance, parcObjectTesting_AssertObjectConformance_fail_object_hash);
+    LONGBOW_RUN_TEST_CASE(Conformance, parcObjectTesting_AssertObjectConformance_fail_object_toString);
+    LONGBOW_RUN_TEST_CASE(Conformance, parcObjectTesting_AssertObjectConformance_fail_object_toJSON);
+}
+
+
+typedef struct {
+    PARCBuffer *inst1;
+    PARCBuffer *inst2;
+    PARCBuffer *inst3;
+    PARCBuffer *lesser;
+    PARCBuffer *greater;
+    PARCObjectDescriptor *descriptor;
+} TestData_t;
+
+static const PARCObjectDescriptor *
+_copyDescriptor(const PARCObjectDescriptor *orig)
+{
+    return parcObjectDescriptor_Create("Name",
+                                       orig->objectSize,
+                                       orig->objectAlignment,
+                                       orig->isLockable,
+                                       orig->destructor,
+                                       orig->release, orig->copy,
+                                       orig->toString, orig->equals,
+                                       orig->compare, orig->hashCode,
+                                       orig->toJSON, orig->display,
+                                       orig->super, orig->typeState);
+}
+
+LONGBOW_TEST_FIXTURE_SETUP(Conformance)
+{
+    TestData_t *data = parcMemory_AllocateAndClear(sizeof(TestData_t));
+    assertNotNull(data, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(TestData_t));
+
+    data->inst1 = parcBuffer_Flip(parcBuffer_CreateFromArray((uint8_t [10]) { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 10));
+    data->inst2 = parcBuffer_Flip(parcBuffer_CreateFromArray((uint8_t [10]) { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 10));
+    data->inst3 = parcBuffer_Flip(parcBuffer_CreateFromArray((uint8_t [10]) { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 10));
+    data->lesser = parcBuffer_Flip(parcBuffer_CreateFromArray((uint8_t [10]) { 0, 1, 2, 3, 4, 5, 6, 7, 8, 8 }, 10));
+    data->greater = parcBuffer_Flip(parcBuffer_CreateFromArray((uint8_t [10]) { 0, 1, 2, 3, 4, 5, 6, 7, 8, 10 }, 10));
+
+    PARCObjectDescriptor *d = (PARCObjectDescriptor *) parcObject_GetDescriptor(data->inst1);
+    data->descriptor = (PARCObjectDescriptor *) _copyDescriptor(d);
+
+    longBowTestCase_SetClipBoardData(testCase, data);
+
+    return LONGBOW_STATUS_SUCCEEDED;
+}
+
+LONGBOW_TEST_FIXTURE_TEARDOWN(Conformance)
+{
+    TestData_t *data = longBowTestCase_GetClipBoardData(testCase);
+
+    parcBuffer_Release(&data->inst1);
+    parcBuffer_Release(&data->inst2);
+    parcBuffer_Release(&data->inst3);
+    parcBuffer_Release(&data->lesser);
+    parcBuffer_Release(&data->greater);
+
+    parcObjectDescriptor_Destroy(&data->descriptor);
+
+    parcMemory_Deallocate(&data);
+
+    uint32_t outstandingAllocations = parcSafeMemory_ReportAllocation(STDERR_FILENO);
+    if (outstandingAllocations != 0) {
+        printf("%s leaks memory by %d allocations\n", longBowTestCase_GetName(testCase), outstandingAllocations);
+        return LONGBOW_STATUS_MEMORYLEAK;
+    }
+    return LONGBOW_STATUS_SUCCEEDED;
+}
+
+LONGBOW_TEST_CASE(Conformance, parcObjectTesting_AssertObjectConformance_succeed)
+{
+    TestData_t *data = longBowTestCase_GetClipBoardData(testCase);
+
+    parcObjectTesting_AssertObjectConformance(data->inst1, data->inst2, data->inst3, data->lesser, data->greater);
+}
+
+LONGBOW_TEST_CASE_EXPECTS(Conformance, parcObjectTesting_AssertObjectConformance_fail_non_object, .event = &LongBowAssertEvent)
+{
+    char *inst1 = "not an object";
+    char *inst2 = "not an object";
+    char *inst3 = "not an object";
+
+    parcObjectTesting_AssertObjectConformance(inst1, inst2, inst3, NULL, NULL);
+}
+
+LONGBOW_TEST_CASE_EXPECTS(Conformance, parcObjectTesting_AssertObjectConformance_fail_object_equals, .event = &LongBowAssertEvent)
+{
+    TestData_t *data = longBowTestCase_GetClipBoardData(testCase);
+    PARCBuffer *inst1 = data->inst1;
+    PARCBuffer *inst2 = inst1;
+    PARCBuffer *inst3 = inst1;
+
+    parcObjectTesting_AssertObjectConformance(inst1, inst2, inst3, data->lesser, data->greater);
+}
+
+LONGBOW_TEST_CASE_EXPECTS(Conformance, parcObjectTesting_AssertObjectConformance_fail_object_compare, .event = &LongBowAssertEvent)
+{
+    TestData_t *data = longBowTestCase_GetClipBoardData(testCase);
+
+    parcObjectTesting_AssertObjectConformance(data->inst1, data->inst2, data->inst3, data->greater, data->lesser);
+}
+
+__attribute__ ((noinline))
+static PARCObject *
+badCopyJunk(const PARCObject *instance)
+{
+    return parcBuffer_Allocate(10);
+}
+
+LONGBOW_TEST_CASE_EXPECTS(Conformance, parcObjectTesting_AssertObjectConformance_fail_object_copy_junk, .event = &LongBowAssertEvent)
+{
+    TestData_t *data = longBowTestCase_GetClipBoardData(testCase);
+
+    data->descriptor->copy = badCopyJunk;
+    parcObject_SetDescriptor(data->inst1, data->descriptor);
+
+    parcObjectTesting_AssertObjectConformance(data->inst1, data->inst2, data->inst3, data->greater, data->lesser);
+}
+
+static PARCObject *
+badCopySame(const PARCObject *instance)
+{
+    return parcObject_Acquire(instance);
+}
+
+LONGBOW_TEST_CASE_EXPECTS(Conformance, parcObjectTesting_AssertObjectConformance_fail_object_copy_same, .event = &LongBowAssertEvent)
+{
+    TestData_t *data = longBowTestCase_GetClipBoardData(testCase);
+
+    data->descriptor->copy = badCopySame;
+    parcObject_SetDescriptor(data->inst1, data->descriptor);
+
+    parcObjectTesting_AssertObjectConformance(data->inst1, data->inst2, data->inst3, data->greater, data->lesser);
+}
+
+static PARCHashCode
+badHash(const PARCObject *instance)
+{
+    return (PARCHashCode) instance;
+}
+
+LONGBOW_TEST_CASE_EXPECTS(Conformance, parcObjectTesting_AssertObjectConformance_fail_object_hash, .event = &LongBowAssertEvent)
+{
+    TestData_t *data = longBowTestCase_GetClipBoardData(testCase);
+
+    data->descriptor->hashCode = badHash;
+    parcObject_SetDescriptor(data->inst1, data->descriptor);
+
+    parcObjectTesting_AssertObjectConformance(data->inst1, data->inst2, data->inst3, data->greater, data->lesser);
+}
+
+static PARCJSON *
+badToJSON(const PARCObject *instance)
+{
+    return NULL;
+}
+
+LONGBOW_TEST_CASE_EXPECTS(Conformance, parcObjectTesting_AssertObjectConformance_fail_object_toJSON, .event = &LongBowAssertEvent)
+{
+    TestData_t *data = longBowTestCase_GetClipBoardData(testCase);
+
+    data->descriptor->toJSON = badToJSON;
+    parcObject_SetDescriptor(data->inst1, data->descriptor);
+
+    parcObjectTesting_AssertObjectConformance(data->inst1, data->inst2, data->inst3, data->greater, data->lesser);
+}
+
+static char *
+badToString(const PARCObject *instance)
+{
+    return NULL;
+}
+
+LONGBOW_TEST_CASE_EXPECTS(Conformance, parcObjectTesting_AssertObjectConformance_fail_object_toString, .event = &LongBowAssertEvent)
+{
+    TestData_t *data = longBowTestCase_GetClipBoardData(testCase);
+
+    data->descriptor->toString = badToString;
+    parcObject_SetDescriptor(data->inst1, data->descriptor);
+
+    parcObjectTesting_AssertObjectConformance(data->inst1, data->inst2, data->inst3, data->greater, data->lesser);
+}
+
+int
+main(int argc, char *argv[argc])
+{
+    LongBowRunner *testRunner = LONGBOW_TEST_RUNNER_CREATE(test_parc_ObjectTesting);
+    int exitStatus = LONGBOW_TEST_MAIN(argc, argv, testRunner);
+    longBowTestRunner_Destroy(&testRunner);
+    exit(exitStatus);
+}