diff options
Diffstat (limited to 'metis/ccnx/forwarder/metis/core/test/test_metis_Message.c')
| -rw-r--r-- | metis/ccnx/forwarder/metis/core/test/test_metis_Message.c | 946 |
1 files changed, 946 insertions, 0 deletions
diff --git a/metis/ccnx/forwarder/metis/core/test/test_metis_Message.c b/metis/ccnx/forwarder/metis/core/test/test_metis_Message.c new file mode 100644 index 00000000..345a1440 --- /dev/null +++ b/metis/ccnx/forwarder/metis/core/test/test_metis_Message.c @@ -0,0 +1,946 @@ +/* + * 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 "../metis_Message.c" +#include <LongBow/unit-test.h> +#include <parc/algol/parc_SafeMemory.h> +#include <parc/logging/parc_LogReporterTextStdout.h> + +#include <parc/logging/parc_LogReporterTextStdout.h> +#include <ccnx/forwarder/metis/testdata/metis_TestDataV0.h> +#include <ccnx/forwarder/metis/testdata/metis_TestDataV1.h> + +LONGBOW_TEST_RUNNER(metis_Message) +{ + // The following Test Fixtures will run their corresponding Test Cases. + // Test Fixtures are run in the order specified, but all tests should be idempotent. + // Never rely on the execution order of tests or share state between them. + LONGBOW_RUN_TEST_FIXTURE(Global); + LONGBOW_RUN_TEST_FIXTURE(Local); +} + +// The Test Runner calls this function once before any Test Fixtures are run. +LONGBOW_TEST_RUNNER_SETUP(metis_Message) +{ + 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(metis_Message) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_FIXTURE(Global) +{ + LONGBOW_RUN_TEST_CASE(Global, metisMessage_Create_InterestV0); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_Create_ObjectV0); + + LONGBOW_RUN_TEST_CASE(Global, metisMessage_Create_InterestV1); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_Create_ObjectV1); + + LONGBOW_RUN_TEST_CASE(Global, metisMessage_CreateFromBuffer); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_CreateFromArray); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_CreateFromElasticBuffer); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_CreateFromBuffer_BadMessage); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_CreateFromArray_BadMessage); + + LONGBOW_RUN_TEST_CASE(Global, metisMessage_Length); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_Append); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_Write); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_GetConnectionId); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_GetReceiveTime); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_ReadFromBuffer); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_Copy); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_GetMessageType); + + LONGBOW_RUN_TEST_CASE(Global, metisMessage_GetName); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_HasName_True); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_HasName_False); + + LONGBOW_RUN_TEST_CASE(Global, metisMessage_GetKeyIdHash); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_HasKeyId_True); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_HasKeyId_False); + + LONGBOW_RUN_TEST_CASE(Global, metisMessage_KeyIdEquals_IsEqual); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_KeyIdEquals_DifferentLength); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_KeyIdEquals_DifferentValue); + + LONGBOW_RUN_TEST_CASE(Global, metisMessage_ObjectHashEquals_IsEqual_Precomputed); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_ObjectHashEquals_IsEqual_Lazy); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_ObjectHashEquals_IsNotEqual); + + LONGBOW_RUN_TEST_CASE(Global, metisMessage_ObjectHashHashCode_Precomputed); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_ObjectHashHashCode_Lazy); + + LONGBOW_RUN_TEST_CASE(Global, metisMessage_HasContentObjectHash_True); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_HasContentObjectHash_False); + + LONGBOW_RUN_TEST_CASE(Global, metisMessage_HasHopLimit_True); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_HasHopLimit_False); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_GetHopLimit); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_SetHopLimit); + + LONGBOW_RUN_TEST_CASE(Global, metisMessage_HasInterestLifetime); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_GetInterestLifetimeTicks); + + LONGBOW_RUN_TEST_CASE(Global, metisMessage_HasExpirationTime); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_HasRecommendedCacheTime); + + LONGBOW_RUN_TEST_CASE(Global, metisMessage_SetGetExpirationTime); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_SetGetRecommendedCacheTime); + + LONGBOW_RUN_TEST_CASE(Global, metisMessage_HasGetPublicKey); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_IsPublicKeyVerified_True); + LONGBOW_RUN_TEST_CASE(Global, metisMessage_IsPublicKeyVerified_False); + + LONGBOW_RUN_TEST_CASE(Global, metisMessage_HasGetCertificate); +} + +LONGBOW_TEST_FIXTURE_SETUP(Global) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_FIXTURE_TEARDOWN(Global) +{ + uint32_t outstandingAllocations = parcSafeMemory_ReportAllocation(STDERR_FILENO); + if (outstandingAllocations != 0) { + printf("%s leaks memory by %d allocations\n", longBowTestCase_GetName(testCase), outstandingAllocations); + return LONGBOW_STATUS_MEMORYLEAK; + } + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_CASE(Global, metisMessage_Create_InterestV0) +{ + PARCEventBuffer *buff = parcEventBuffer_Create(); + parcEventBuffer_Append(buff, metisTestDataV0_EncodedInterest, sizeof(metisTestDataV0_EncodedInterest)); + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromBuffer(1, 2, buff, logger); + metisLogger_Release(&logger); + + assertNotNull(message, "Got null from metisMessage_CreateFromBuffer"); + assertTrue(message->ingressConnectionId == 1, "IngressConnectionId wrong, expected %d got %u", 1, message->ingressConnectionId); + assertTrue(message->receiveTime == 2, "receiveTime wrong, expected %u got %" PRIu64, 2, message->receiveTime); + + metisMessage_Release(&message); +} + +LONGBOW_TEST_CASE(Global, metisMessage_Create_ObjectV0) +{ + PARCEventBuffer *buff = parcEventBuffer_Create(); + parcEventBuffer_Append(buff, metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject)); + + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromBuffer(1, 2, buff, logger); + metisLogger_Release(&logger); + + assertNotNull(message, "Got null from metisMessage_CreateFromBuffer"); + assertTrue(message->ingressConnectionId == 1, "IngressConnectionId wrong, expected %d got %u", 1, message->ingressConnectionId); + assertTrue(message->receiveTime == 2, "receiveTime wrong, expected %u got %" PRIu64, 2, message->receiveTime); + + metisMessage_Release(&message); +} + +LONGBOW_TEST_CASE(Global, metisMessage_Create_InterestV1) +{ + PARCEventBuffer *buff = parcEventBuffer_Create(); + parcEventBuffer_Append(buff, metisTestDataV1_Interest_AllFields, sizeof(metisTestDataV1_Interest_AllFields)); + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromBuffer(1, 2, buff, logger); + metisLogger_Release(&logger); + + assertNotNull(message, "Got null from metisMessage_CreateFromBuffer"); + assertTrue(message->ingressConnectionId == 1, "IngressConnectionId wrong, expected %d got %u", 1, message->ingressConnectionId); + assertTrue(message->receiveTime == 2, "receiveTime wrong, expected %u got %" PRIu64, 2, message->receiveTime); + + metisMessage_Release(&message); +} + +LONGBOW_TEST_CASE(Global, metisMessage_Create_ObjectV1) +{ + PARCEventBuffer *buff = parcEventBuffer_Create(); + parcEventBuffer_Append(buff, metisTestDataV1_ContentObject_NameA_Crc32c, sizeof(metisTestDataV1_ContentObject_NameA_Crc32c)); + + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromBuffer(1, 2, buff, logger); + metisLogger_Release(&logger); + + assertNotNull(message, "Got null from metisMessage_CreateFromBuffer"); + assertTrue(message->ingressConnectionId == 1, "IngressConnectionId wrong, expected %d got %u", 1, message->ingressConnectionId); + assertTrue(message->receiveTime == 2, "receiveTime wrong, expected %u got %" PRIu64, 2, message->receiveTime); + + metisMessage_Release(&message); +} + + +LONGBOW_TEST_CASE(Global, metisMessage_CreateFromArray) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + metisLogger_Release(&logger); + + + assertNotNull(message, "Got null from metisMessage_CreateFromArray"); + assertTrue(message->ingressConnectionId == 1, "IngressConnectionId wrong, expected %d got %u", 1, message->ingressConnectionId); + assertTrue(message->receiveTime == 2, "receiveTime wrong, expected %u got %" PRIu64, 2, message->receiveTime); + + metisMessage_Release(&message); +} + +LONGBOW_TEST_CASE(Global, metisMessage_CreateFromArray_BadMessage) +{ + // Invalid version + char message_str[] = "\xFFOnce upon a time, in a stack far away, a dangling pointer found its way to the top of the heap."; + printf("metisMessage_CreateFromArray_BadMessage attempting to process a bad message which should report an error:\n"); + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromArray((uint8_t *) message_str, sizeof(message_str), 1, 2, logger); + metisLogger_Release(&logger); + + assertNull(message, "Got null from metisMessage_CreateFromArray"); +} + +LONGBOW_TEST_CASE(Global, metisMessage_CreateFromBuffer) +{ + char message_str[] = "\x00Once upon a time, in a stack far away, a dangling pointer found its way to the top of the heap."; + + PARCEventBuffer *buff = parcEventBuffer_Create(); + parcEventBuffer_Append(buff, message_str, sizeof(message_str)); + + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromBuffer(1, 2, buff, logger); + metisLogger_Release(&logger); + + assertNotNull(message, "Got null from metisMessage_CreateFromBuffer"); + assertTrue(message->ingressConnectionId == 1, "IngressConnectionId wrong, expected %d got %u", 1, message->ingressConnectionId); + assertTrue(message->receiveTime == 2, "receiveTime wrong, expected %u got %" PRIu64, 2, message->receiveTime); + + metisMessage_Release(&message); +} + +LONGBOW_TEST_CASE(Global, metisMessage_CreateFromElasticBuffer) +{ + char message_str[] = "\0x00Once upon a time, in a stack far away, a dangling pointer found its way to the top of the heap."; + + PARCBuffer *buff = parcBuffer_Wrap(message_str, sizeof(message_str), 0, sizeof(message_str)); + + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromParcBuffer(buff, 1, 2, logger); + metisLogger_Release(&logger); + + assertNotNull(message, "Got null from metisMessage_CreateFromBuffer"); + assertTrue(message->ingressConnectionId == 1, "IngressConnectionId wrong, expected %d got %u", 1, message->ingressConnectionId); + assertTrue(message->receiveTime == 2, "receiveTime wrong, expected %u got %" PRIu64, 2, message->receiveTime); + + metisMessage_Release(&message); + parcBuffer_Release(&buff); +} + +LONGBOW_TEST_CASE(Global, metisMessage_CreateFromBuffer_BadMessage) +{ + // Bad version + char message_str[] = "\xFFOnce upon a time, in a stack far away, a dangling pointer found its way to the top of the heap."; + + printf("metisMessage_CreateFromBuffer_BadMessage attempting to process a bad message which should report an error:\n"); + PARCEventBuffer *buff = parcEventBuffer_Create(); + parcEventBuffer_Append(buff, message_str, sizeof(message_str)); + + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromBuffer(1, 2, buff, logger); + metisLogger_Release(&logger); + + assertNull(message, "Got null from metisMessage_CreateFromBuffer"); +} + +LONGBOW_TEST_CASE(Global, metisMessage_ReadFromBuffer) +{ + char message_str[] = "\x00Once upon a time, in a stack far away, a dangling pointer found its way to the top of the heap."; + + PARCEventBuffer *buff = parcEventBuffer_Create(); + parcEventBuffer_Append(buff, message_str, sizeof(message_str)); + + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_ReadFromBuffer(1, 2, buff, sizeof(message_str), logger); + metisLogger_Release(&logger); + + assertNotNull(message, "Got null from metisMessage_CreateFromBuffer"); + + assertTrue(parcEventBuffer_GetLength(message->messageBytes) == sizeof(message_str), + "Length of internal buffer wrong, expected %zu got %zu", + sizeof(message_str), + parcEventBuffer_GetLength(message->messageBytes)); + + uint8_t *p = parcEventBuffer_Pullup(message->messageBytes, sizeof(message_str)); + assertTrue(memcmp(p, message_str, sizeof(message_str)) == 0, "Internal buffer contents does not match test"); + assertTrue(message->ingressConnectionId == 1, "IngressConnectionId wrong, expected %d got %u", 1, message->ingressConnectionId); + assertTrue(message->receiveTime == 2, "receiveTime wrong, expected %u got %" PRIu64, 2, message->receiveTime); + assertTrue(parcEventBuffer_GetLength(buff) == 0, "Origin buffer not drained, expected 0, got %zu", parcEventBuffer_GetLength(buff)); + + metisMessage_Release(&message); + parcEventBuffer_Destroy(&buff); +} + +LONGBOW_TEST_CASE(Global, metisMessage_Append) +{ + char message_str[] = "\x00Once upon a time ..."; + + PARCEventBuffer *buffer = parcEventBuffer_Create(); + PARCEventBuffer *buff = parcEventBuffer_Create(); + parcEventBuffer_Append(buff, message_str, sizeof(message_str)); + + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromBuffer(1, 2, buff, logger); + int result = metisMessage_Append(buffer, message); + + assertTrue(result == 0, "Got error from metisMessage_Append"); + metisLogger_Release(&logger); + metisMessage_Release(&message); + parcEventBuffer_Destroy(&buffer); +} + +LONGBOW_TEST_CASE(Global, metisMessage_Write) +{ + char message_str[] = "\x00Once upon a time ..."; + + PARCEventScheduler *scheduler = parcEventScheduler_Create(); + PARCEventQueue *queue = parcEventQueue_Create(scheduler, -1, PARCEventQueueOption_CloseOnFree); + + PARCEventBuffer *buff = parcEventBuffer_Create(); + parcEventBuffer_Append(buff, message_str, sizeof(message_str)); + + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromBuffer(1, 2, buff, logger); + int result = metisMessage_Write(queue, message); + + assertTrue(result == 0, "Got error from metisMessage_Write"); + + // buff is deallocated by metisMessage_Release + metisLogger_Release(&logger); + metisMessage_Release(&message); + parcEventQueue_Destroy(&queue); + parcEventScheduler_Destroy(&scheduler); +} + +LONGBOW_TEST_CASE(Global, metisMessage_Length) +{ + char message_str[] = "\x00Once upon a time, in a stack far away, a dangling pointer found its way to the top of the heap."; + + PARCEventBuffer *buff = parcEventBuffer_Create(); + parcEventBuffer_Append(buff, message_str, sizeof(message_str)); + + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromBuffer(1, 2, buff, logger); + metisLogger_Release(&logger); + + assertNotNull(message, "Got null from metisMessage_CreateFromBuffer"); + size_t length = metisMessage_Length(message); + assertTrue(length == sizeof(message_str), "Wrong length, expected %zu got %zu", sizeof(message_str), length); + metisMessage_Release(&message); +} + +LONGBOW_TEST_CASE(Global, metisMessage_GetConnectionId) +{ + char message_str[] = "\x00Once upon a time, in a stack far away, a dangling pointer found its way to the top of the heap."; + + PARCEventBuffer *buff = parcEventBuffer_Create(); + parcEventBuffer_Append(buff, message_str, sizeof(message_str)); + + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromBuffer(1, 2, buff, logger); + metisLogger_Release(&logger); + + assertNotNull(message, "Got null from metisMessage_CreateFromBuffer"); + unsigned connid = metisMessage_GetIngressConnectionId(message); + + assertTrue(connid == 1, "Wrong length, expected %u got %u", 1, connid); + metisMessage_Release(&message); +} + +LONGBOW_TEST_CASE(Global, metisMessage_GetReceiveTime) +{ + char message_str[] = "\x00Once upon a time, in a stack far away, a dangling pointer found its way to the top of the heap."; + + PARCEventBuffer *buff = parcEventBuffer_Create(); + parcEventBuffer_Append(buff, message_str, sizeof(message_str)); + + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromBuffer(1, 2, buff, logger); + metisLogger_Release(&logger); + + assertNotNull(message, "Got null from metisMessage_CreateFromBuffer"); + MetisTicks time = metisMessage_GetReceiveTime(message); + + assertTrue(time == 2, "Wrong receive time, expected %u got %" PRIu64, 2, time); + metisMessage_Release(&message); +} + +LONGBOW_TEST_CASE(Global, metisMessage_Copy) +{ + char message_str[] = "\x00Once upon a time, in a stack far away, a dangling pointer found its way to the top of the heap."; + + PARCEventBuffer *buff = parcEventBuffer_Create(); + parcEventBuffer_Append(buff, message_str, sizeof(message_str)); + + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromBuffer(1, 2, buff, logger); + metisLogger_Release(&logger); + + assertNotNull(message, "Got null from metisMessage_CreateFromBuffer"); + assertTrue(message->refcount == 1, "Incorrect refcount, expected %u got %u", 1, message->refcount); + + MetisMessage *copy = metisMessage_Acquire(message); + assertTrue(message->refcount == 2, "Incorrect refcount, expected %u got %u", 2, message->refcount); + + metisMessage_Release(&message); + assertTrue(copy->refcount == 1, "Incorrect refcount, expected %u got %u", 1, message->refcount); + + metisMessage_Release(©); + + assertTrue(parcMemory_Outstanding() == 0, "Memory balance should be zero after destroying last copy, got %u", parcMemory_Outstanding()); +} + +LONGBOW_TEST_CASE(Global, metisMessage_GetMessageType) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + metisLogger_Release(&logger); + MetisMessagePacketType type = metisMessage_GetType(message); + + assertTrue(type == MetisMessagePacketType_ContentObject, "wrong type, expected %u got %u", MetisMessagePacketType_ContentObject, type); + + metisMessage_Release(&message); +} + +LONGBOW_TEST_CASE(Global, metisMessage_GetName) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + metisLogger_Release(&logger); + MetisTlvName *name = metisMessage_GetName(message); + MetisTlvName *truth = metisTlvName_Create(&metisTestDataV0_EncodedObject[metisTestDataV0_EncodedObject_name.offset], metisTestDataV0_EncodedObject_name.length); + + assertTrue(metisTlvName_Equals(truth, name), "Did not get back the right name"); + + metisTlvName_Release(&truth); + metisMessage_Release(&message); +} + +LONGBOW_TEST_CASE(Global, metisMessage_HasName_True) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + metisLogger_Release(&logger); + bool hasName = metisMessage_HasName(message); + assertTrue(hasName, "Message with a name says it does not"); + metisMessage_Release(&message); +} + +LONGBOW_TEST_CASE(Global, metisMessage_HasName_False) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_CPIMessage, sizeof(metisTestDataV0_CPIMessage), 1, 2, logger); + metisLogger_Release(&logger); + bool hasName = metisMessage_HasName(message); + assertFalse(hasName, "Message without a name says it does"); + metisMessage_Release(&message); +} + +LONGBOW_TEST_CASE(Global, metisMessage_HasContentObjectHash_True) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + metisLogger_Release(&logger); + bool hasHash = metisMessage_HasContentObjectHash(message); + assertTrue(hasHash, "Message with a content object hash says it does not"); + metisMessage_Release(&message); +} + +LONGBOW_TEST_CASE(Global, metisMessage_HasContentObjectHash_False) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_EncodedInterest, sizeof(metisTestDataV0_EncodedInterest), 1, 2, logger); + metisLogger_Release(&logger); + bool hasHash = metisMessage_HasContentObjectHash(message); + assertTrue(hasHash, "Message without a content object hash says it does"); + metisMessage_Release(&message); +} + +LONGBOW_TEST_CASE(Global, metisMessage_GetKeyIdHash) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + metisLogger_Release(&logger); + + uint32_t truthhash = parcHash32_Data(&metisTestDataV0_EncodedObject[metisTestDataV0_EncodedObject_keyid.offset], metisTestDataV0_EncodedObject_keyid.length); + uint32_t testhash; + bool success = metisMessage_GetKeyIdHash(message, &testhash); + + assertTrue(success, "Failed metisMessage_GetKeyIdHash, returned false"); + assertTrue(truthhash == testhash, "Hash compared wrong, expected %08X, got %08X", truthhash, testhash); + + metisMessage_Release(&message); +} + +LONGBOW_TEST_CASE(Global, metisMessage_HasKeyId_True) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + metisLogger_Release(&logger); + bool hasKeyId = metisMessage_HasKeyId(message); + assertTrue(hasKeyId, "Message with a keyid says it does not"); + metisMessage_Release(&message); +} + +LONGBOW_TEST_CASE(Global, metisMessage_HasKeyId_False) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_InterestWithName, sizeof(metisTestDataV0_InterestWithName), 1, 2, logger); + metisLogger_Release(&logger); + bool hasKeyId = metisMessage_HasKeyId(message); + assertFalse(hasKeyId, "Message without a keyid says it does"); + metisMessage_Release(&message); +} + +LONGBOW_TEST_CASE(Global, metisMessage_KeyIdEquals_IsEqual) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *a = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + MetisMessage *b = metisMessage_CreateFromArray(metisTestDataV0_EncodedInterest, sizeof(metisTestDataV0_EncodedInterest), 1, 2, logger); + metisLogger_Release(&logger); + + assertTrue(metisMessage_KeyIdEquals(a, b), "Messages with equal keyids did not compare"); + metisMessage_Release(&a); + metisMessage_Release(&b); +} + +LONGBOW_TEST_CASE(Global, metisMessage_KeyIdEquals_DifferentLength) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *a = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + MetisMessage *b = metisMessage_CreateFromArray(metisTestDataV0_SecondObject, sizeof(metisTestDataV0_SecondObject), 1, 2, logger); + metisLogger_Release(&logger); + + assertFalse(metisMessage_KeyIdEquals(a, b), "Messages with differnt length keyids did compared equal"); + metisMessage_Release(&a); + metisMessage_Release(&b); +} + +LONGBOW_TEST_CASE(Global, metisMessage_KeyIdEquals_DifferentValue) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *a = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + MetisMessage *b = metisMessage_CreateFromArray(metisTestDataV0_SecondInterest, sizeof(metisTestDataV0_SecondInterest), 1, 2, logger); + metisLogger_Release(&logger); + + assertFalse(metisMessage_KeyIdEquals(a, b), "Messages with differnt keyids did compared equal"); + metisMessage_Release(&a); + metisMessage_Release(&b); +} + +LONGBOW_TEST_CASE(Global, metisMessage_ObjectHashEquals_IsEqual_Precomputed) +{ + // create messages from Interests, as those are precomputed + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *a = metisMessage_CreateFromArray(metisTestDataV0_EncodedInterest, sizeof(metisTestDataV0_EncodedInterest), 1, 2, logger); + MetisMessage *b = metisMessage_CreateFromArray(metisTestDataV0_EncodedInterest, sizeof(metisTestDataV0_EncodedInterest), 1, 2, logger); + metisLogger_Release(&logger); + + assertTrue(metisMessage_ObjectHashEquals(a, b), "Messages with equal ContentObjectHash did not compare"); + metisMessage_Release(&a); + metisMessage_Release(&b); +} + +LONGBOW_TEST_CASE(Global, metisMessage_ObjectHashEquals_IsEqual_Lazy) +{ + // create messages from content objects, as those are lazy computed + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *a = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + MetisMessage *b = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + metisLogger_Release(&logger); + + assertTrue(metisMessage_ObjectHashEquals(a, b), "Messages with equal ContentObjectHash did not compare"); + metisMessage_Release(&a); + metisMessage_Release(&b); +} + +LONGBOW_TEST_CASE(Global, metisMessage_ObjectHashEquals_IsNotEqual) +{ + // create messages from different content objects + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *a = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + MetisMessage *b = metisMessage_CreateFromArray(metisTestDataV0_SecondObject, sizeof(metisTestDataV0_SecondObject), 1, 2, logger); + metisLogger_Release(&logger); + + assertFalse(metisMessage_ObjectHashEquals(a, b), "Messages with unequal ContentObjectHash compared as equal"); + metisMessage_Release(&a); + metisMessage_Release(&b); +} + +LONGBOW_TEST_CASE(Global, metisMessage_ObjectHashHashCode_Precomputed) +{ + // create messages from Interests, as those are precomputed + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *a = metisMessage_CreateFromArray(metisTestDataV0_EncodedInterest, sizeof(metisTestDataV0_EncodedInterest), 1, 2, logger); + metisLogger_Release(&logger); + + uint32_t hashcode; + bool success = metisMessage_GetContentObjectHashHash(a, &hashcode); + assertTrue(success, "Returned false trying to get hash of contentobject hash"); + + metisMessage_Release(&a); +} + +LONGBOW_TEST_CASE(Global, metisMessage_ObjectHashHashCode_Lazy) +{ + // create messages from content object, as those are precomputed + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *a = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + metisLogger_Release(&logger); + + uint32_t hashcode; + bool success = metisMessage_GetContentObjectHashHash(a, &hashcode); + assertTrue(success, "Returned false trying to get hash of contentobject hash"); + + metisMessage_Release(&a); +} + +LONGBOW_TEST_CASE(Global, metisMessage_HasHopLimit_True) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_EncodedInterest, sizeof(metisTestDataV0_EncodedInterest), 1, 2, logger); + metisLogger_Release(&logger); + + bool hasHopLimit = metisMessage_HasHopLimit(message); + assertTrue(hasHopLimit, "Message with a hop limit says it does not."); + + metisMessage_Release(&message); +} + +LONGBOW_TEST_CASE(Global, metisMessage_HasHopLimit_False) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_EncodedInterest_no_hoplimit, sizeof(metisTestDataV0_EncodedInterest_no_hoplimit), 1, 2, logger); + metisLogger_Release(&logger); + + bool hasHopLimit = metisMessage_HasHopLimit(message); + assertFalse(hasHopLimit, "Message without a hop limit says it does."); + + metisMessage_Release(&message); +} + +LONGBOW_TEST_CASE(Global, metisMessage_GetHopLimit) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_EncodedInterest, sizeof(metisTestDataV0_EncodedInterest), 1, 2, logger); + metisLogger_Release(&logger); + + uint8_t hoplimit = metisMessage_GetHopLimit(message); + assertTrue(hoplimit == 32, "Wrong hop limit, got %u expected %u.", hoplimit, 32); + + metisMessage_Release(&message); +} + +LONGBOW_TEST_CASE(Global, metisMessage_SetHopLimit) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_EncodedInterest, sizeof(metisTestDataV0_EncodedInterest), 1, 2, logger); + metisLogger_Release(&logger); + + metisMessage_SetHopLimit(message, 99); + uint8_t hoplimit = metisMessage_GetHopLimit(message); + assertTrue(hoplimit == 99, "Wrong hop limit, got %u expected %u.", hoplimit, 99); + + metisMessage_Release(&message); +} + +LONGBOW_TEST_CASE(Global, metisMessage_HasInterestLifetime) +{ + PARCEventBuffer *buff = parcEventBuffer_Create(); + parcEventBuffer_Append(buff, metisTestDataV1_Interest_AllFields, sizeof(metisTestDataV1_Interest_AllFields)); + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromBuffer(1, 2, buff, logger); + metisLogger_Release(&logger); + + assertTrue(metisMessage_HasInterestLifetime(message), "Should have returned true for interest lifetime"); + + metisMessage_Release(&message); +} + +LONGBOW_TEST_CASE(Global, metisMessage_GetInterestLifetimeTicks) +{ + PARCEventBuffer *buff = parcEventBuffer_Create(); + parcEventBuffer_Append(buff, metisTestDataV1_Interest_AllFields, sizeof(metisTestDataV1_Interest_AllFields)); + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + MetisMessage *message = metisMessage_CreateFromBuffer(1, 2, buff, logger); + metisLogger_Release(&logger); + + // don't check actual value. It will vary based on METISHZ and rouding errors due to integer math + MetisTicks ticks = metisMessage_GetInterestLifetimeTicks(message); + assertTrue(ticks > 0, "Should have gotten positive value for interest lifetime ticks"); + + metisMessage_Release(&message); +} + +LONGBOW_TEST_CASE(Global, metisMessage_HasExpirationTime) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + + // Note: Assumes metisTestDataV0_EncodedObject doesn't have ExpiryTime. + MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + metisLogger_Release(&logger); + + bool hasExpiryTime = metisMessage_HasExpiryTime(message); + assertFalse(hasExpiryTime, "Message without ExpiryTime says it has one."); + + metisMessage_SetExpiryTimeTicks(message, 10000); + hasExpiryTime = metisMessage_HasExpiryTime(message); + assertTrue(hasExpiryTime, "Message with ExpiryTime says it doesn't have one."); + + metisMessage_Release(&message); +} + +LONGBOW_TEST_CASE(Global, metisMessage_HasRecommendedCacheTime) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + + // Note: Assumes metisTestDataV0_EncodedObject doesn't have RCT. + MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + metisLogger_Release(&logger); + + bool hasRCT = metisMessage_HasRecommendedCacheTime(message); + assertFalse(hasRCT, "Message without hasRCT says it has one."); + + metisMessage_SetRecommendedCacheTimeTicks(message, 10000); + hasRCT = metisMessage_HasRecommendedCacheTime(message); + assertTrue(hasRCT, "Message with hasRCT says it doesn't have one."); + + metisMessage_Release(&message); +} + +LONGBOW_TEST_CASE(Global, metisMessage_SetGetExpirationTime) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + + // Note: Assumes metisTestDataV0_EncodedObject doesn't have RCT. + MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + metisLogger_Release(&logger); + + uint64_t time = 12345; + metisMessage_SetExpiryTimeTicks(message, time); + assertTrue(time == metisMessage_GetExpiryTimeTicks(message), "Retrieved unexpected ExpiryTime"); + + metisMessage_Release(&message); +} + +LONGBOW_TEST_CASE(Global, metisMessage_SetGetRecommendedCacheTime) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + + // Note: Assumes metisTestDataV0_EncodedObject doesn't have RCT. + MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + metisLogger_Release(&logger); + + uint64_t time = 12345; + metisMessage_SetRecommendedCacheTimeTicks(message, time); + assertTrue(time == metisMessage_GetRecommendedCacheTimeTicks(message), "Retrieved unexpected RCT"); + + metisMessage_Release(&message); +} + +LONGBOW_TEST_CASE(Global, metisMessage_HasGetPublicKey) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + + MetisMessage *contentWithKey = + metisMessage_CreateFromArray(metisTestDataV1_ContentObject_NameA_KeyId1_RsaSha256, + sizeof(metisTestDataV1_ContentObject_NameA_KeyId1_RsaSha256), 1, 2, logger); + + MetisMessage *interestWithKeyIdRestriction = + metisMessage_CreateFromArray(metisTestDataV1_Interest_NameAAndKeyId, + sizeof(metisTestDataV1_Interest_NameAAndKeyId), 1, 2, logger); + + metisLogger_Release(&logger); + + assertTrue(metisMessage_HasPublicKey(contentWithKey), "Expected to see a public key"); + assertFalse(metisMessage_HasPublicKey(interestWithKeyIdRestriction), "Expected to not see a public key"); + + PARCBuffer *key = metisMessage_GetPublicKey(contentWithKey); + + assertNotNull(key, "Expected to retrieve the public key"); + + metisMessage_Release(&contentWithKey); + metisMessage_Release(&interestWithKeyIdRestriction); +} + +LONGBOW_TEST_CASE(Global, metisMessage_IsPublicKeyVerified_False) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + + MetisMessage *contentWithKey = + metisMessage_CreateFromArray(metisTestDataV1_ContentObject_NameA_KeyId1_RsaSha256, + sizeof(metisTestDataV1_ContentObject_NameA_KeyId1_RsaSha256), 1, 2, logger); + + MetisMessage *interestWithKeyIdRestriction = + metisMessage_CreateFromArray(metisTestDataV1_Interest_NameAAndKeyId, + sizeof(metisTestDataV1_Interest_NameAAndKeyId), 1, 2, logger); + + metisLogger_Release(&logger); + + assertFalse(metisMessage_IsKeyIdVerified(contentWithKey), "Expected key to not be verified."); + + // This is an interest. The keyId is actually a KeyId restriction, so will never be verified. + assertFalse(metisMessage_IsKeyIdVerified(interestWithKeyIdRestriction), "Expected key to not be verified."); + + PARCBuffer *key = metisMessage_GetPublicKey(contentWithKey); + + assertNotNull(key, "Expected to retrieve the public key"); + + metisMessage_Release(&contentWithKey); + metisMessage_Release(&interestWithKeyIdRestriction); +} + +LONGBOW_TEST_CASE(Global, metisMessage_IsPublicKeyVerified_True) +{ + testUnimplemented("Verification of KeyIds in ContentObjects is not yet implemented."); +} + +LONGBOW_TEST_CASE(Global, metisMessage_HasGetCertificate) +{ + testUnimplemented("Need test data with an encoded certificate."); +} + +// =================================================== + +LONGBOW_TEST_FIXTURE(Local) +{ +} + +LONGBOW_TEST_FIXTURE_SETUP(Local) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_FIXTURE_TEARDOWN(Local) +{ + 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; +} + +int +main(int argc, char *argv[]) +{ + LongBowRunner *testRunner = LONGBOW_TEST_RUNNER_CREATE(metis_Message); + int exitStatus = longBowMain(argc, argv, testRunner, NULL); + longBowTestRunner_Destroy(&testRunner); + exit(exitStatus); +} |