1 files changed, 354 insertions, 0 deletions
diff --git a/metis/ccnx/forwarder/metis/content_store/test/test_metis_ContentStoreEntry.c b/metis/ccnx/forwarder/metis/content_store/test/test_metis_ContentStoreEntry.c
new file mode 100644
index 00000000..87d154b7
--- /dev/null
+++ b/metis/ccnx/forwarder/metis/content_store/test/test_metis_ContentStoreEntry.c
@@ -0,0 +1,354 @@
+/*
+ * Copyright (c) 2017 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include <config.h>
+
+#include "../metis_ContentStoreEntry.c"
+#include <LongBow/unit-test.h>
+
+#include <parc/algol/parc_SafeMemory.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_ContentStoreEntry)
+{
+    // 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_ContentStoreEntry)
+{
+    return LONGBOW_STATUS_SUCCEEDED;
+}
+
+// The Test Runner calls this function once after all the Test Fixtures are run.
+LONGBOW_TEST_RUNNER_TEARDOWN(metis_ContentStoreEntry)
+{
+    return LONGBOW_STATUS_SUCCEEDED;
+}
+
+// ============================================================================
+
+LONGBOW_TEST_FIXTURE(Global)
+{
+    LONGBOW_RUN_TEST_CASE(Global, metisContentStoreEntry_Create_Destroy_Memory);
+    LONGBOW_RUN_TEST_CASE(Global, metisContentStoreEntry_Create_Destroy_State);
+    LONGBOW_RUN_TEST_CASE(Global, metisContentStoreEntry_Acquire);
+    LONGBOW_RUN_TEST_CASE(Global, metisContentStoreEntry_GetMessage);
+    LONGBOW_RUN_TEST_CASE(Global, metisContentStoreEntry_MoveToHead);
+
+    LONGBOW_RUN_TEST_CASE(Global, metisContentStoreEntry_GetExpiryTimeInTicks);
+    LONGBOW_RUN_TEST_CASE(Global, metisContentStoreEntry_GetRecommendedCacheTimeInTicks);
+
+    LONGBOW_RUN_TEST_CASE(Global, metisContentStoreEntry_CompareRecommendedCacheTime);
+    LONGBOW_RUN_TEST_CASE(Global, metisContentStoreEntry_CompareExpiryTime);
+}
+
+LONGBOW_TEST_FIXTURE_SETUP(Global)
+{
+    return LONGBOW_STATUS_SUCCEEDED;
+}
+
+LONGBOW_TEST_FIXTURE_TEARDOWN(Global)
+{
+    if (parcSafeMemory_ReportAllocation(STDOUT_FILENO) != 0) {
+        return LONGBOW_STATUS_MEMORYLEAK;
+    }
+    return LONGBOW_STATUS_SUCCEEDED;
+}
+static MetisLogger *
+_createLogger()
+{
+    PARCLogReporter *reporter = parcLogReporterTextStdout_Create();
+    MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock());
+    metisLogger_SetLogLevel(logger, MetisLoggerFacility_Processor, PARCLogLevel_Debug);
+    parcLogReporter_Release(&reporter);
+
+    return logger;
+}
+LONGBOW_TEST_CASE(Global, metisContentStoreEntry_Create_Destroy_Memory)
+{
+    MetisLruList *lruList = metisLruList_Create();
+    PARCLogReporter *reporter = parcLogReporterTextStdout_Create();
+    MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock());
+    parcLogReporter_Release(&reporter);
+    MetisMessage *object = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger);
+    metisLogger_Release(&logger);
+
+    size_t beforeMemory = parcMemory_Outstanding();
+    MetisContentStoreEntry *storeEntry = metisContentStoreEntry_Create(object, lruList);
+    metisContentStoreEntry_Release(&storeEntry);
+    size_t afterMemory = parcMemory_Outstanding();
+
+    metisLruList_Destroy(&lruList);
+    metisMessage_Release(&object);
+
+    assertTrue(afterMemory == beforeMemory, "Imbalance on create/destroy, expected %zu got %zu", beforeMemory, afterMemory);
+}
+
+LONGBOW_TEST_CASE(Global, metisContentStoreEntry_Create_Destroy_State)
+{
+    MetisLogger *logger = _createLogger();
+
+    MetisLruList *lruList = metisLruList_Create();
+    MetisMessage *object = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger);
+
+    MetisContentStoreEntry *storeEntry = metisContentStoreEntry_Create(object, lruList);
+
+    assertTrue(storeEntry->refcount == 1, "lruEntry has wrong refcount, expected %u got %u", 1, storeEntry->refcount);
+
+    metisContentStoreEntry_Release(&storeEntry);
+    metisLruList_Destroy(&lruList);
+    metisMessage_Release(&object);
+    metisLogger_Release(&logger);
+}
+
+LONGBOW_TEST_CASE(Global, metisContentStoreEntry_Acquire)
+{
+    MetisLogger *logger = _createLogger();
+    MetisLruList *lruList = metisLruList_Create();
+    MetisMessage *object = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger);
+
+    MetisContentStoreEntry *storeEntry = metisContentStoreEntry_Create(object, lruList);
+    MetisContentStoreEntry *copy = metisContentStoreEntry_Acquire(storeEntry);
+
+    assertTrue(copy->refcount == 2, "incorrect refcount after copy, expected %u got %u", 2, copy->refcount);
+    metisContentStoreEntry_Release(&storeEntry);
+    assertTrue(copy->refcount == 1, "incorrect refcount after destroy, expected %u got %u", 1, copy->refcount);
+
+    metisContentStoreEntry_Release(&copy);
+    metisLruList_Destroy(&lruList);
+    metisMessage_Release(&object);
+    metisLogger_Release(&logger);
+}
+
+LONGBOW_TEST_CASE(Global, metisContentStoreEntry_GetMessage)
+{
+    MetisLogger *logger = _createLogger();
+
+    MetisLruList *lruList = metisLruList_Create();
+    MetisMessage *object = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger);
+
+    MetisContentStoreEntry *storeEntry = metisContentStoreEntry_Create(object, lruList);
+
+    MetisMessage *copy = metisContentStoreEntry_GetMessage(storeEntry);
+    assertTrue(copy == object, "Incorrect mesage, expected %p got %p", (void *) object, (void *) copy);
+
+    metisContentStoreEntry_Release(&storeEntry);
+
+    metisLruList_Destroy(&lruList);
+    metisMessage_Release(&object);
+    metisLogger_Release(&logger);
+}
+
+LONGBOW_TEST_CASE(Global, metisContentStoreEntry_MoveToHead)
+{
+    MetisLogger *logger = _createLogger();
+    MetisLruList *lruList = metisLruList_Create();
+
+    MetisMessage *object[3];
+    MetisContentStoreEntry *storeEntry[3];
+
+    for (int i = 0; i < 3; i++) {
+        object[i] = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), i, 2, logger);
+        storeEntry[i] = metisContentStoreEntry_Create(object[i], lruList);
+    }
+
+    // object 2 is at top of list and object 0 is at bottom.  move 0 to top and 1 should be at bottom
+    metisContentStoreEntry_MoveToHead(storeEntry[0]);
+
+    MetisLruListEntry *bottom = metisLruList_PopTail(lruList);
+
+    assertTrue(bottom == storeEntry[1]->lruEntry, "Incorrect mesage, expected %p got %p", (void *) storeEntry[1]->lruEntry, (void *) bottom);
+    for (int i = 0; i < 3; i++) {
+        metisContentStoreEntry_Release(&storeEntry[i]);
+        metisMessage_Release(&object[i]);
+    }
+
+    metisLogger_Release(&logger);
+    metisLruList_Destroy(&lruList);
+}
+
+LONGBOW_TEST_CASE(Global, metisContentStoreEntry_GetExpiryTimeInTicks)
+{
+    MetisLogger *logger = _createLogger();
+
+    MetisMessage *object = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject,
+                                                        sizeof(metisTestDataV0_EncodedObject), 1, 2, logger);
+
+    uint64_t expiryTime = 101l;
+    metisMessage_SetExpiryTimeTicks(object, expiryTime);
+
+    MetisContentStoreEntry *storeEntry = metisContentStoreEntry_Create(object, NULL);
+
+    assertTrue(metisContentStoreEntry_HasExpiryTimeTicks(storeEntry), "Expected entry to have expiry time");
+    assertTrue(metisContentStoreEntry_GetExpiryTimeTicks(storeEntry) == expiryTime, "Got unexpected expiry time");
+
+    metisContentStoreEntry_Release(&storeEntry);
+    metisMessage_Release(&object);
+    metisLogger_Release(&logger);
+}
+
+LONGBOW_TEST_CASE(Global, metisContentStoreEntry_GetRecommendedCacheTimeInTicks)
+{
+    MetisLogger *logger = _createLogger();
+
+    MetisMessage *object = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject,
+                                                        sizeof(metisTestDataV0_EncodedObject), 1, 2, logger);
+
+    uint64_t rct = 202l;
+    metisMessage_SetRecommendedCacheTimeTicks(object, rct);
+
+    MetisContentStoreEntry *storeEntry = metisContentStoreEntry_Create(object, NULL);
+
+    assertTrue(metisContentStoreEntry_HasRecommendedCacheTimeTicks(storeEntry), "Expected entry to have expiry time");
+    assertTrue(metisContentStoreEntry_GetRecommendedCacheTimeTicks(storeEntry) == rct, "Got unexpected cache time");
+
+    metisContentStoreEntry_Release(&storeEntry);
+    metisMessage_Release(&object);
+    metisLogger_Release(&logger);
+}
+
+LONGBOW_TEST_CASE(Global, metisContentStoreEntry_CompareExpiryTime)
+{
+    MetisLogger *logger = _createLogger();
+
+    MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger);
+    MetisMessage *message2 = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 3, 4, logger);
+
+    metisMessage_SetExpiryTimeTicks(message, 100);
+    MetisContentStoreEntry *entry1 = metisContentStoreEntry_Create(message, NULL);
+
+    metisMessage_SetExpiryTimeTicks(message, 200);
+    MetisContentStoreEntry *entry2 = metisContentStoreEntry_Create(message, NULL);
+
+    // Different message, same times as entry1
+    metisMessage_SetExpiryTimeTicks(message2, 100);
+    MetisContentStoreEntry *entry3 = metisContentStoreEntry_Create(message2, NULL);
+
+    // Same message, same times as entry2
+    metisMessage_SetExpiryTimeTicks(message, 200);
+    MetisContentStoreEntry *entry4 = metisContentStoreEntry_Create(message, NULL);
+
+    assertTrue(metisContentStoreEntry_CompareExpiryTime(entry1, entry2) == -1, "Expected -1");
+    assertTrue(metisContentStoreEntry_CompareExpiryTime(entry2, entry1) == 1, "Expected +1");
+    assertTrue(metisContentStoreEntry_CompareExpiryTime(entry1, entry1) == 0, "Expected 0");
+
+    //  Compare same expiry time, but different Message addressed.
+    if (message < message2) {
+        assertTrue(metisContentStoreEntry_CompareExpiryTime(entry1, entry3) == -1, "Expected -1");
+        assertTrue(metisContentStoreEntry_CompareExpiryTime(entry3, entry1) == 1, "Expected +1");
+    } else {
+        assertTrue(metisContentStoreEntry_CompareExpiryTime(entry1, entry3) == 1, "Expected 1");
+        assertTrue(metisContentStoreEntry_CompareExpiryTime(entry3, entry1) == -1, "Expected -1");
+    }
+
+    assertTrue(metisContentStoreEntry_CompareExpiryTime(entry2, entry4) == 0, "Expected 0");
+
+    metisContentStoreEntry_Release(&entry1);
+    metisContentStoreEntry_Release(&entry2);
+    metisContentStoreEntry_Release(&entry3);
+    metisContentStoreEntry_Release(&entry4);
+
+    metisMessage_Release(&message);
+    metisMessage_Release(&message2);
+
+    metisLogger_Release(&logger);
+}
+
+LONGBOW_TEST_CASE(Global, metisContentStoreEntry_CompareRecommendedCacheTime)
+{
+    MetisLogger *logger = _createLogger();
+
+    MetisMessage *message = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger);
+    MetisMessage *message2 = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 3, 4, logger);
+
+    metisMessage_SetRecommendedCacheTimeTicks(message, 200);
+    MetisContentStoreEntry *entry1 = metisContentStoreEntry_Create(message, NULL);
+
+    metisMessage_SetRecommendedCacheTimeTicks(message, 100);
+    MetisContentStoreEntry *entry2 = metisContentStoreEntry_Create(message, NULL);
+
+    // Different message, same times as entry1
+    metisMessage_SetRecommendedCacheTimeTicks(message2, 200);
+    MetisContentStoreEntry *entry3 = metisContentStoreEntry_Create(message2, NULL);
+
+    // Same message, same times as entry2
+    metisMessage_SetRecommendedCacheTimeTicks(message, 100);
+    MetisContentStoreEntry *entry4 = metisContentStoreEntry_Create(message, NULL);
+
+    assertTrue(metisContentStoreEntry_CompareRecommendedCacheTime(entry1, entry2) == 1, "Expected 1");
+    assertTrue(metisContentStoreEntry_CompareRecommendedCacheTime(entry2, entry1) == -1, "Expected -1");
+    assertTrue(metisContentStoreEntry_CompareRecommendedCacheTime(entry1, entry1) == 0, "Expected 0");
+
+    //  Compare same RCT, but different Message addressed.
+    if (message < message2) {
+        assertTrue(metisContentStoreEntry_CompareRecommendedCacheTime(entry1, entry3) == -1, "Expected -1");
+        assertTrue(metisContentStoreEntry_CompareRecommendedCacheTime(entry3, entry1) == 1, "Expected +1");
+    } else {
+        assertTrue(metisContentStoreEntry_CompareRecommendedCacheTime(entry1, entry3) == 1, "Expected 1");
+        assertTrue(metisContentStoreEntry_CompareRecommendedCacheTime(entry3, entry1) == -1, "Expected -1");
+    }
+
+    assertTrue(metisContentStoreEntry_CompareRecommendedCacheTime(entry2, entry4) == 0, "Expected 0");
+
+    metisContentStoreEntry_Release(&entry1);
+    metisContentStoreEntry_Release(&entry2);
+    metisContentStoreEntry_Release(&entry3);
+    metisContentStoreEntry_Release(&entry4);
+
+    metisMessage_Release(&message);
+    metisMessage_Release(&message2);
+
+    metisLogger_Release(&logger);
+}
+
+// ============================================================================
+
+LONGBOW_TEST_FIXTURE(Local)
+{
+}
+
+LONGBOW_TEST_FIXTURE_SETUP(Local)
+{
+    return LONGBOW_STATUS_SUCCEEDED;
+}
+
+LONGBOW_TEST_FIXTURE_TEARDOWN(Local)
+{
+    if (parcSafeMemory_ReportAllocation(STDOUT_FILENO) != 0) {
+        return LONGBOW_STATUS_MEMORYLEAK;
+    }
+    return LONGBOW_STATUS_SUCCEEDED;
+}
+
+// ============================================================================
+
+int
+main(int argc, char *argv[])
+{
+    LongBowRunner *testRunner = LONGBOW_TEST_RUNNER_CREATE(metis_ContentStoreEntry);
+    int exitStatus = longBowMain(argc, argv, testRunner, NULL);
+    longBowTestRunner_Destroy(&testRunner);
+    exit(exitStatus);
+}