diff options
Diffstat (limited to 'metis/ccnx/forwarder/metis/content_store/test')
6 files changed, 1844 insertions, 0 deletions
diff --git a/metis/ccnx/forwarder/metis/content_store/test/CMakeLists.txt b/metis/ccnx/forwarder/metis/content_store/test/CMakeLists.txt new file mode 100644 index 00000000..0542732d --- /dev/null +++ b/metis/ccnx/forwarder/metis/content_store/test/CMakeLists.txt @@ -0,0 +1,17 @@ +# Enable gcov output for the tests +add_definitions(--coverage) +set(CMAKE_EXE_LINKER_FLAGS ${CMAKE_EXE_LINKER_FLAGS} " --coverage") + +set(TestsExpectedToPass + test_metis_LruList + test_metis_ContentStoreEntry + test_metis_ContentStoreInterface + test_metis_TimeOrderedList + test_metis_LRUContentStore +) + + +foreach(test ${TestsExpectedToPass}) + AddTest(${test}) +endforeach() + 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(©); + 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); +} diff --git a/metis/ccnx/forwarder/metis/content_store/test/test_metis_ContentStoreInterface.c b/metis/ccnx/forwarder/metis/content_store/test/test_metis_ContentStoreInterface.c new file mode 100644 index 00000000..1a32308a --- /dev/null +++ b/metis/ccnx/forwarder/metis/content_store/test/test_metis_ContentStoreInterface.c @@ -0,0 +1,222 @@ +/* + * 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_ContentStoreInterface.c" + +#include <LongBow/unit-test.h> + +#include <parc/logging/parc_LogReporterTextStdout.h> + +#include <parc/algol/parc_SafeMemory.h> + +#include <ccnx/forwarder/metis/content_store/metis_LRUContentStore.h> +#include <ccnx/forwarder/metis/testdata/metis_TestDataV0.h> + +LONGBOW_TEST_RUNNER(metis_ContentStoreInterface) +{ + parcMemory_SetInterface(&PARCSafeMemoryAsPARCMemory); + + LONGBOW_RUN_TEST_FIXTURE(Global); +} + +// The Test Runner calls this function once before any Test Fixtures are run. +LONGBOW_TEST_RUNNER_SETUP(metis_ContentStoreInterface) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +// The Test Runner calls this function once after all the Test Fixtures are run. +LONGBOW_TEST_RUNNER_TEARDOWN(metis_ContentStoreInterface) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_FIXTURE(Global) +{ + LONGBOW_RUN_TEST_CASE(Global, metisContentStoreInterface_CreateRelease); + LONGBOW_RUN_TEST_CASE(Global, metisContentStoreInterface_PutContent); + LONGBOW_RUN_TEST_CASE(Global, metisContentStoreInterface_RemoveContent); + LONGBOW_RUN_TEST_CASE(Global, metisContentStoreInterface_MatchInterest); + LONGBOW_RUN_TEST_CASE(Global, metisContentStoreInterface_GetObjectCount); + LONGBOW_RUN_TEST_CASE(Global, metisContentStoreInterface_GetObjectCapacity); + LONGBOW_RUN_TEST_CASE(Global, metisContentStoreInterface_Log); +} + +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; +} + +static MetisLogger * +_createLogger(void) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *result = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + metisLogger_SetLogLevel(result, MetisLoggerFacility_Processor, PARCLogLevel_Debug); + + return result; +} +static MetisContentStoreInterface * +_createContentStore(MetisLogger *logger) +{ + MetisContentStoreConfig config = { + .objectCapacity = 1000, + }; + + MetisContentStoreInterface *result = metisLRUContentStore_Create(&config, logger); + assertNotNull(result, "Expected to allocate a MetisContentStoreInterface"); + + return result; +} + +LONGBOW_TEST_CASE(Global, metisContentStoreInterface_CreateRelease) +{ + MetisLogger *logger = _createLogger(); + MetisContentStoreInterface *store = _createContentStore(logger); + + assertNotNull(store, "Expected to allocate a MetisContentStoreInterface"); + + metisContentStoreInterface_Release(&store); + metisLogger_Release(&logger); +} + +LONGBOW_TEST_CASE(Global, metisContentStoreInterface_PutContent) +{ + MetisLogger *logger = _createLogger(); + MetisContentStoreInterface *store = _createContentStore(logger); + + MetisMessage *content = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + metisContentStoreInterface_PutContent(store, content, 1000); + + metisMessage_Release(&content); + metisContentStoreInterface_Release(&store); + metisLogger_Release(&logger); +} + +LONGBOW_TEST_CASE(Global, metisContentStoreInterface_RemoveContent) +{ + MetisLogger *logger = _createLogger(); + MetisContentStoreInterface *store = _createContentStore(logger); + + MetisMessage *content = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + metisContentStoreInterface_PutContent(store, content, 1000); + + bool wasRemoved = metisContentStoreInterface_RemoveContent(store, content); + assertTrue(wasRemoved, "Expected to remove the previously stored MetisMessage"); + + metisMessage_Release(&content); + metisContentStoreInterface_Release(&store); + metisLogger_Release(&logger); +} + +LONGBOW_TEST_CASE(Global, metisContentStoreInterface_MatchInterest) +{ + MetisLogger *logger = _createLogger(); + MetisContentStoreInterface *store = _createContentStore(logger); + + MetisMessage *content = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + metisContentStoreInterface_PutContent(store, content, 1000); + + MetisMessage *interest = metisMessage_CreateFromArray(metisTestDataV0_InterestWithName, sizeof(metisTestDataV0_InterestWithName), 1, 2, logger); + MetisMessage *match = metisContentStoreInterface_MatchInterest(store, interest); + + assertTrue(match == content, "Expected to retrieve the stored MetisMessage"); + + metisMessage_Release(&interest); + metisMessage_Release(&content); + metisContentStoreInterface_Release(&store); + metisLogger_Release(&logger); +} + +static MetisMessage * +_createUniqueMetisMessage(MetisLogger *logger, int tweakNumber, uint8_t *template, size_t templateSize, int nameOffset) +{ + PARCBuffer *buffer = parcBuffer_Allocate(templateSize); + memcpy(parcBuffer_Overlay(buffer, 0), template, templateSize); // Copy the template to new memory + + // Tweak the encoded object's name so the name hash varies each time. + uint8_t *bufPtr = parcBuffer_Overlay(buffer, 0); + bufPtr[nameOffset] = 'a' + tweakNumber; + + MetisMessage *result = metisMessage_CreateFromArray(bufPtr, templateSize, 1, 2, logger); + parcBuffer_Release(&buffer); + + return result; +} + +LONGBOW_TEST_CASE(Global, metisContentStoreInterface_GetObjectCount) +{ + MetisLogger *logger = _createLogger(); + MetisContentStoreInterface *store = _createContentStore(logger); + + for (int i = 1; i < 100; i++) { + MetisMessage *content = _createUniqueMetisMessage(logger, i, metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), + metisTestDataV0_EncodedObject_name.offset + 4); + metisContentStoreInterface_PutContent(store, content, 1000 + i); + metisMessage_Release(&content); + + size_t count = metisContentStoreInterface_GetObjectCount(store); + assertTrue(count == i, "Expected a count of %d items, got %zu", i, count); + } + + metisContentStoreInterface_Release(&store); + metisLogger_Release(&logger); +} + +LONGBOW_TEST_CASE(Global, metisContentStoreInterface_GetObjectCapacity) +{ + MetisLogger *logger = _createLogger(); + MetisContentStoreConfig config = { + .objectCapacity = 1000, + }; + + MetisContentStoreInterface *store = metisLRUContentStore_Create(&config, logger); + assertTrue(metisContentStoreInterface_GetObjectCapacity(store) == config.objectCapacity, "Expected to get back the capacity we set"); + metisContentStoreInterface_Release(&store); + metisLogger_Release(&logger); +} + +LONGBOW_TEST_CASE(Global, metisContentStoreInterface_Log) +{ + MetisLogger *logger = _createLogger(); + MetisContentStoreInterface *store = _createContentStore(logger); + + metisContentStoreInterface_Log(store); + + metisContentStoreInterface_Release(&store); + metisLogger_Release(&logger); +} + +int +main(int argc, char *argv[]) +{ + LongBowRunner *testRunner = LONGBOW_TEST_RUNNER_CREATE(metis_ContentStoreInterface); + int exitStatus = longBowMain(argc, argv, testRunner, NULL); + longBowTestRunner_Destroy(&testRunner); + exit(exitStatus); +} diff --git a/metis/ccnx/forwarder/metis/content_store/test/test_metis_LRUContentStore.c b/metis/ccnx/forwarder/metis/content_store/test/test_metis_LRUContentStore.c new file mode 100644 index 00000000..ea55b361 --- /dev/null +++ b/metis/ccnx/forwarder/metis/content_store/test/test_metis_LRUContentStore.c @@ -0,0 +1,788 @@ +/* + * 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_LRUContentStore.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_LRUContentStore) +{ + parcMemory_SetInterface(&PARCSafeMemoryAsPARCMemory); + + 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_LRUContentStore) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +// The Test Runner calls this function once after all the Test Fixtures are run. +LONGBOW_TEST_RUNNER_TEARDOWN(metis_LRUContentStore) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +// ============================================================================ + +LONGBOW_TEST_FIXTURE(Global) +{ + LONGBOW_RUN_TEST_CASE(Global, metisLRUContentStore_Create_Destroy); + LONGBOW_RUN_TEST_CASE(Global, metisLRUContentStore_Log); + + LONGBOW_RUN_TEST_CASE(Global, metisLRUContentStore_Create_ZeroCapacity); + LONGBOW_RUN_TEST_CASE(Global, metisLRUContentStore_Fetch_ByName); + LONGBOW_RUN_TEST_CASE(Global, metisLRUContentStore_Fetch_ByNameAndKeyId); + LONGBOW_RUN_TEST_CASE(Global, metisLRUContentStore_Fetch_ByNameAndObjectHash); + + LONGBOW_RUN_TEST_CASE(Global, metisLRUContentStore_Remove_Content); + LONGBOW_RUN_TEST_CASE(Global, metisLRUContentStore_Remove_NonExistentContent); + + LONGBOW_RUN_TEST_CASE(Global, metisLRUContentStore_Fetch_Lru); + + LONGBOW_RUN_TEST_CASE(Global, metisLRUContentStore_Save_ZeroCapacity); + LONGBOW_RUN_TEST_CASE(Global, metisLRUContentStore_Save_CapacityLimit); + LONGBOW_RUN_TEST_CASE(Global, metisLRUContentStore_Save_WithoutEviction); + LONGBOW_RUN_TEST_CASE(Global, metisLRUContentStore_Save_WithEviction); + + LONGBOW_RUN_TEST_CASE(Global, metisLRUContentStore_Save_WithEvictionByExpiryTime); + LONGBOW_RUN_TEST_CASE(Global, metisLRUContentStore_Save_WithEvictionByRCT); + + LONGBOW_RUN_TEST_CASE(Global, metisLRUContentStore_Save_ExpiredContent); + + LONGBOW_RUN_TEST_CASE(Global, metisLRUContentStore_Save_DuplicateHash); +} + +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; +} + +static MetisContentStoreInterface * +_createLRUContentStore(size_t capacity) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + + metisLogger_SetLogLevel(logger, MetisLoggerFacility_Processor, PARCLogLevel_Debug); + + MetisContentStoreConfig config = { + .objectCapacity = capacity, + }; + + MetisContentStoreInterface *store = metisLRUContentStore_Create(&config, logger); + + metisLogger_Release(&logger); + + return store; +} + +static MetisMessage * +_createUniqueMetisMessage(MetisLogger *logger, int tweakNumber, uint8_t *template, size_t templateSize, int nameOffset) +{ + PARCBuffer *buffer = parcBuffer_Allocate(templateSize); + memcpy(parcBuffer_Overlay(buffer, 0), template, templateSize); // Copy the template to new memory + + // Tweak the encoded object's name so the name hash varies each time. + uint8_t *bufPtr = parcBuffer_Overlay(buffer, 0); + bufPtr[nameOffset] = 'a' + tweakNumber; + + MetisMessage *result = metisMessage_CreateFromArray(bufPtr, templateSize, 1, 2, logger); + parcBuffer_Release(&buffer); + + return result; +} + +LONGBOW_TEST_CASE(Global, metisLRUContentStore_Create_Destroy) +{ + MetisContentStoreInterface *store = _createLRUContentStore(10); + assertNotNull(store, "Expected to init a content store"); + metisContentStoreInterface_Release(&store); +} + +LONGBOW_TEST_CASE(Global, metisLRUContentStore_Log) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + + size_t capacity = 20; + MetisContentStoreInterface *store = _createLRUContentStore(capacity); + + for (int i = 1; i <= capacity; i++) { + int offsetOfNameInEncodedObject = metisTestDataV0_EncodedObject_name.offset + 4; + + MetisMessage *object = _createUniqueMetisMessage(logger, i, + metisTestDataV0_EncodedObject, + sizeof(metisTestDataV0_EncodedObject), + offsetOfNameInEncodedObject); + + bool success = metisContentStoreInterface_PutContent(store, object, 1); + metisMessage_Release(&object); + + assertTrue(success, "Unexpectedly failed to add entry to ContentStore"); + } + + metisContentStoreInterface_Log(store); + + metisLogger_Release(&logger); + metisContentStoreInterface_Release(&store); +} + +LONGBOW_TEST_CASE(Global, metisLRUContentStore_Create_ZeroCapacity) +{ + size_t capacity = 10; + MetisContentStoreInterface *store = _createLRUContentStore(capacity); + + assertTrue(metisContentStoreInterface_GetObjectCapacity(store) == capacity, "Wrong capacity, expected %zu got %zu", + capacity, metisContentStoreInterface_GetObjectCapacity(store)); + + assertTrue(metisContentStoreInterface_GetObjectCount(store) == 0, "Wrong initial count, expected %u got %zu", 0, + metisContentStoreInterface_GetObjectCount(store)); + metisContentStoreInterface_Release(&store); +} + +LONGBOW_TEST_CASE(Global, metisLRUContentStore_Fetch_ByName) +{ + size_t capacity = 10; + MetisContentStoreInterface *store = _createLRUContentStore(capacity); + + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + + uint64_t expiryTime = 300l; + uint64_t rct = 200; + uint64_t now = 100; + + MetisMessage *object_1 = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, + sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + + metisMessage_SetExpiryTimeTicks(object_1, expiryTime); + metisMessage_SetRecommendedCacheTimeTicks(object_1, rct); + + MetisMessage *object_2 = metisMessage_CreateFromArray(metisTestDataV0_SecondObject, + sizeof(metisTestDataV0_SecondObject), 1, 2, logger); + metisMessage_SetExpiryTimeTicks(object_2, expiryTime); + metisMessage_SetRecommendedCacheTimeTicks(object_2, rct); + + metisMessage_SetExpiryTimeTicks(object_1, expiryTime); + metisMessage_SetRecommendedCacheTimeTicks(object_1, rct); + + metisContentStoreInterface_PutContent(store, object_1, now); + metisContentStoreInterface_PutContent(store, object_2, now); + + MetisMessage *interestByName = metisMessage_CreateFromArray(metisTestDataV0_InterestWithName, + sizeof(metisTestDataV0_InterestWithName), 3, 5, logger); + + + MetisMessage *testObject = metisContentStoreInterface_MatchInterest(store, interestByName); + assertNotNull(testObject, "Fetch did not find match when it should have"); + + uint64_t expiryTimeOut = metisMessage_GetExpiryTimeTicks(testObject); + uint64_t rctOut = metisMessage_GetRecommendedCacheTimeTicks(testObject); + bool hasExpiryTime = metisMessage_HasExpiryTime(testObject); + bool hasRCT = metisMessage_HasRecommendedCacheTime(testObject); + + assertTrue(hasRCT, "Expected object to have an RCT"); + assertTrue(hasExpiryTime, "Expected object to have an ExpiryTime"); + assertTrue(expiryTime == expiryTimeOut, "Expected the same expiryTime to be retrieved"); + assertTrue(rct == rctOut, "Expected the same RCT to be retrieved"); + + // two objects with same name, 1st one will win + assertTrue(testObject == object_1, "Fetch returned wrong object, expecting %p got %p", + (void *) object_1, (void *) testObject); + + metisContentStoreInterface_Release(&store); + metisLogger_Release(&logger); + metisMessage_Release(&object_1); + metisMessage_Release(&object_2); + metisMessage_Release(&interestByName); +} + + +LONGBOW_TEST_CASE(Global, metisLRUContentStore_Fetch_ByNameAndKeyId) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + + size_t capacity = 10; + MetisContentStoreInterface *store = _createLRUContentStore(capacity); + + MetisMessage *object_1 = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, + sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + MetisMessage *object_2 = metisMessage_CreateFromArray(metisTestDataV0_SecondObject, + sizeof(metisTestDataV0_SecondObject), 1, 2, logger); + + metisContentStoreInterface_PutContent(store, object_1, 1); + metisContentStoreInterface_PutContent(store, object_2, 1); + + MetisMessage *interestByNameKeyId = metisMessage_CreateFromArray(metisTestDataV0_InterestWithName_keyid, + sizeof(metisTestDataV0_InterestWithName_keyid), + 3, 5, logger); + + MetisMessage *testObject = metisContentStoreInterface_MatchInterest(store, interestByNameKeyId); + assertNotNull(testObject, "Fetch did not find match when it should have"); + + // two objects with same name, 1st one will win + assertTrue(testObject == object_1, "Fetch returned wrong object, expecting %p got %p", + (void *) object_1, (void *) testObject); + + metisContentStoreInterface_Release(&store); + metisLogger_Release(&logger); + metisMessage_Release(&object_1); + metisMessage_Release(&object_2); + metisMessage_Release(&interestByNameKeyId); +} + +LONGBOW_TEST_CASE(Global, metisLRUContentStore_Fetch_ByNameAndObjectHash) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + + size_t capacity = 10; + MetisContentStoreInterface *store = _createLRUContentStore(capacity); + + MetisMessage *object_1 = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, + sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + MetisMessage *object_2 = metisMessage_CreateFromArray(metisTestDataV0_SecondObject, + sizeof(metisTestDataV0_SecondObject), 1, 2, logger); + + uint64_t expiryTime = 300l; + uint64_t rct = 200l; + uint64_t now = 100l; + + metisMessage_SetExpiryTimeTicks(object_1, expiryTime); + metisMessage_SetRecommendedCacheTimeTicks(object_1, rct); + + metisContentStoreInterface_PutContent(store, object_1, now); + metisContentStoreInterface_PutContent(store, object_2, now); + + MetisMessage *interestByNameObjectHash = + metisMessage_CreateFromArray(metisTestDataV0_InterestWithName_objecthash, + sizeof(metisTestDataV0_InterestWithName_objecthash), 3, 5, logger); + + // this should retrieve object_1 because that is the one whose + // content object hash matches the interest + + MetisMessage *testObject = metisContentStoreInterface_MatchInterest(store, interestByNameObjectHash); + + assertTrue(expiryTime == metisMessage_GetExpiryTimeTicks(testObject), "Expected the same expiryTime to be retrieved"); + assertTrue(rct == metisMessage_GetRecommendedCacheTimeTicks(testObject), "Expected the same RCT to be retrieved"); + + assertNotNull(testObject, "Fetch did not find match when it should have"); + + // two objects with same name, 1st one will win + assertTrue(testObject == object_1, "Fetch returned wrong object, expecting %p got %p", (void *) object_1, (void *) testObject); + + metisContentStoreInterface_Release(&store); + metisLogger_Release(&logger); + metisMessage_Release(&object_1); + metisMessage_Release(&object_2); + metisMessage_Release(&interestByNameObjectHash); +} + +LONGBOW_TEST_CASE(Global, metisLRUContentStore_Remove_Content) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + + size_t capacity = 10; + MetisContentStoreInterface *store = _createLRUContentStore(capacity); + + MetisMessage *object_1 = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, + sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + MetisMessage *object_2 = metisMessage_CreateFromArray(metisTestDataV0_SecondObject, + sizeof(metisTestDataV0_SecondObject), 1, 2, logger); + + metisMessage_SetExpiryTimeTicks(object_1, 200); + metisMessage_SetRecommendedCacheTimeTicks(object_1, 100); + + metisContentStoreInterface_PutContent(store, object_1, 10); + metisContentStoreInterface_PutContent(store, object_2, 10); + + assertTrue(metisContentStoreInterface_GetObjectCount(store) == 2, "Expected 2 objects in the metisContentStoreInterface_"); + + MetisMessage *interestByNameObjectHash = + metisMessage_CreateFromArray(metisTestDataV0_InterestWithName_objecthash, + sizeof(metisTestDataV0_InterestWithName_objecthash), 3, 5, logger); + + // this should retrieve object_1 because that is the one whose + // content object hash matches the interest + MetisMessage *testObject = metisContentStoreInterface_MatchInterest(store, interestByNameObjectHash); + + + assertNotNull(testObject, "Fetch did not find match when it should have"); + + // two objects with same name, 1st one will win + assertTrue(testObject == object_1, "Fetch returned wrong object, expecting %p got %p", + (void *) object_1, (void *) testObject); + + // Now remove it. + metisContentStoreInterface_RemoveContent(store, object_1); // Releases the contained Message + + assertTrue(metisContentStoreInterface_GetObjectCount(store) == 1, "Expected 1 object in the store, got %zu", + metisContentStoreInterface_GetObjectCount(store)); + + MetisMessage *nullObject = metisContentStoreInterface_MatchInterest(store, interestByNameObjectHash); + + assertNull(nullObject, "Fetch found a match when it should not have"); + + metisContentStoreInterface_Release(&store); + metisLogger_Release(&logger); + metisMessage_Release(&object_1); + metisMessage_Release(&object_2); + metisMessage_Release(&interestByNameObjectHash); +} + +LONGBOW_TEST_CASE(Global, metisLRUContentStore_Remove_NonExistentContent) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + + size_t capacity = 10; + MetisContentStoreInterface *store = _createLRUContentStore(capacity); + + MetisMessage *object_1 = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, + sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + MetisMessage *object_2 = metisMessage_CreateFromArray(metisTestDataV0_SecondObject, + sizeof(metisTestDataV0_SecondObject), 1, 2, logger); + + metisContentStoreInterface_PutContent(store, object_1, 1); + + assertTrue(metisContentStoreInterface_GetObjectCount(store) == 1, "Expected 1 object in the metisContentStoreInterface_"); + + // Try to remove one that is not in the store. + bool result = metisContentStoreInterface_RemoveContent(store, object_2); // Releases the contained Message + assertFalse(result, "Expected to NOT remove object_2"); + + assertTrue(metisContentStoreInterface_GetObjectCount(store) == 1, "Expected 1 object in the metisContentStoreInterface_"); + + result = metisContentStoreInterface_RemoveContent(store, object_1); // Releases the contained Message + assertTrue(result, "Expected to remove object_1"); + + assertTrue(metisContentStoreInterface_GetObjectCount(store) == 0, "Expected 0 objects in the metisContentStoreInterface_"); + + metisContentStoreInterface_Release(&store); + metisLogger_Release(&logger); + metisMessage_Release(&object_1); + metisMessage_Release(&object_2); +} + +/* + * Create an cache and access objects to make sure the LRU is evicting the right way + */ +LONGBOW_TEST_CASE(Global, metisLRUContentStore_Fetch_Lru) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + metisLogger_SetLogLevel(logger, MetisLoggerFacility_Processor, PARCLogLevel_Debug); + parcLogReporter_Release(&reporter); + + size_t capacity = 2; + MetisContentStoreInterface *store = _createLRUContentStore(capacity); + + MetisMessage *object1 = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, + sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + MetisMessage *object2 = metisMessage_CreateFromArray(metisTestDataV0_object_with_othername, + sizeof(metisTestDataV0_object_with_othername), 2, 2, logger); + + metisContentStoreInterface_PutContent(store, object1, 1); + metisContentStoreInterface_PutContent(store, object2, 1); + + // object 2 sould be at top of LRU (was saved last). Fetch object 1, then evict object 2. + + // interest_with_name will match the name in object1. + MetisMessage *interestByName = metisMessage_CreateFromArray(metisTestDataV0_InterestWithName, + sizeof(metisTestDataV0_InterestWithName), 3, 5, logger); + + MetisMessage *testObject = metisContentStoreInterface_MatchInterest(store, interestByName); + + assertTrue(testObject == object1, "Fetch returned wrong object, expecting %p got %p", (void *) object1, (void *) testObject); + + // objectcapacity = 2, so object 3 will evict bottom of LRU + MetisMessage *object3 = metisMessage_CreateFromArray(metisTestDataV0_SecondObject, + sizeof(metisTestDataV0_SecondObject), 4, 2, logger); + metisContentStoreInterface_PutContent(store, object3, 1); + + // object 2 should be evicted + MetisMessage *interestOtherName = metisMessage_CreateFromArray(metisTestDataV0_InterestWithOtherName, + sizeof(metisTestDataV0_InterestWithOtherName), 5, 5, logger); + MetisMessage *testEvictedObject = metisContentStoreInterface_MatchInterest(store, interestOtherName); + + + assertNull(testEvictedObject, "object with othername should have been evicted"); + + // as final sanity check, make sure object 1 is still in the list + MetisMessage *testObject1Again = metisContentStoreInterface_MatchInterest(store, interestByName); + + assertNotNull(testObject1Again, "Did not retrieve object1 from the content store"); + + metisContentStoreInterface_Release(&store); + metisLogger_Release(&logger); + metisMessage_Release(&object1); + metisMessage_Release(&object2); + metisMessage_Release(&object3); + metisMessage_Release(&interestByName); + metisMessage_Release(&interestOtherName); +} + + +LONGBOW_TEST_CASE(Global, metisLRUContentStore_Save_WithoutEviction) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + + size_t capacity = 10; + MetisContentStoreInterface *store = _createLRUContentStore(capacity); + + MetisMessage *object_1 = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, + sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + MetisMessage *object_2 = metisMessage_CreateFromArray(metisTestDataV0_SecondObject, + sizeof(metisTestDataV0_SecondObject), 1, 2, logger); + + metisContentStoreInterface_PutContent(store, object_1, 10); + metisContentStoreInterface_PutContent(store, object_2, 10); + + _MetisLRUContentStore *internalStore = ( _MetisLRUContentStore *) metisContentStoreInterface_GetPrivateData(store); + _MetisLRUContentStoreStats *stats = &internalStore->stats; + + assertTrue(stats->countAdds == 2, "Wrong countAdds, expected %u got %" PRIu64, 2, stats->countAdds); + assertTrue(stats->countLruEvictions == 0, "Wrong countLruEvictions, expected %u got %" PRIu64, 0, stats->countLruEvictions); + assertTrue(metisLruList_Length(internalStore->lru) == 2, "Wrong metisLruList_Length, expected %u got %zu", 2, + metisLruList_Length(internalStore->lru)); + + metisContentStoreInterface_Release(&store); + metisLogger_Release(&logger); + metisMessage_Release(&object_1); + metisMessage_Release(&object_2); +} + +LONGBOW_TEST_CASE(Global, metisLRUContentStore_Save_WithEviction) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + + size_t capacity = 1; + MetisContentStoreInterface *store = _createLRUContentStore(capacity); + + MetisMessage *content_1 = _createUniqueMetisMessage(logger, 1, metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), + metisTestDataV0_EncodedObject_name.offset + 4); + + MetisMessage *content_2 = _createUniqueMetisMessage(logger, 2, metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), + metisTestDataV0_EncodedObject_name.offset + 4); + + MetisMessage *content_3 = _createUniqueMetisMessage(logger, 3, metisTestDataV0_EncodedObject, sizeof(metisTestDataV0_EncodedObject), + metisTestDataV0_EncodedObject_name.offset + 4); + + + metisContentStoreInterface_PutContent(store, content_1, 1); + + assertTrue(metisContentStoreInterface_GetObjectCount(store) == 1, "Wrong objectCount. Expected %u, got %zu", 1, metisContentStoreInterface_GetObjectCount(store)); + + metisContentStoreInterface_PutContent(store, content_2, 1); + metisContentStoreInterface_PutContent(store, content_3, 1); + + _MetisLRUContentStore *internalStore = (_MetisLRUContentStore *) metisContentStoreInterface_GetPrivateData(store); + _MetisLRUContentStoreStats *stats = &internalStore->stats; + + // Capacity is 1, so we should never grow bigger than that. + assertTrue(metisContentStoreInterface_GetObjectCount(store) == 1, "Wrong objectCount. Expected %u, got %zu", 1, metisContentStoreInterface_GetObjectCount(store)); + + assertTrue(stats->countAdds == 3, "Wrong countAdds, expected %u got %" PRIu64, 2, + stats->countAdds); + assertTrue(stats->countLruEvictions == 2, "Wrong countLruEvictions, expected %u got %" PRIu64, 1, stats->countLruEvictions); + assertTrue(metisLruList_Length(internalStore->lru) == 1, "Wrong metisLruList_Length, expected %u got %zu", 1, + metisLruList_Length(internalStore->lru)); + + metisContentStoreInterface_Release(&store); + metisLogger_Release(&logger); + metisMessage_Release(&content_1); + metisMessage_Release(&content_2); + metisMessage_Release(&content_3); +} + +LONGBOW_TEST_CASE(Global, metisLRUContentStore_Save_ExpiredContent) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + + size_t capacity = 1; + MetisContentStoreInterface *store = _createLRUContentStore(capacity); + + MetisMessage *object_1 = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, + sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + MetisMessage *object_2 = metisMessage_CreateFromArray(metisTestDataV0_SecondObject, + sizeof(metisTestDataV0_SecondObject), 1, 2, logger); + + metisMessage_SetRecommendedCacheTimeTicks(object_1, 50); + + assertFalse(metisContentStoreInterface_PutContent(store, object_1, 51), "Should not be able to insert content past its recommended cache time"); + assertTrue(metisContentStoreInterface_GetObjectCount(store) == 0, "Wrong objectCount. Expected 0, got %zu", metisContentStoreInterface_GetObjectCount(store)); + + metisMessage_SetExpiryTimeTicks(object_2, 100); + + assertFalse(metisContentStoreInterface_PutContent(store, object_2, 101), "Should not be able to insert content past its expiry time"); + assertTrue(metisContentStoreInterface_GetObjectCount(store) == 0, "Wrong objectCount. Expected 0, got %zu", metisContentStoreInterface_GetObjectCount(store)); + + metisContentStoreInterface_Release(&store); + metisLogger_Release(&logger); + metisMessage_Release(&object_1); + metisMessage_Release(&object_2); +} + + +LONGBOW_TEST_CASE(Global, metisLRUContentStore_Save_WithEvictionByExpiryTime) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + + size_t capacity = 1; + MetisContentStoreInterface *store = _createLRUContentStore(capacity); + + MetisMessage *object_1 = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, + sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + MetisMessage *object_2 = metisMessage_CreateFromArray(metisTestDataV0_SecondObject, + sizeof(metisTestDataV0_SecondObject), 1, 2, logger); + + uint64_t currentMetisTime = 150; + uint64_t expiryTime = 200; + + metisMessage_SetExpiryTimeTicks(object_1, expiryTime); + + // This should add the object, as currentMetisTime is less than expiry or RCT. + metisContentStoreInterface_PutContent(store, object_1, currentMetisTime); + assertTrue(metisContentStoreInterface_GetObjectCount(store) == 1, "Wrong objectCount. Expected 1, got %zu", metisContentStoreInterface_GetObjectCount(store)); + + // No expiry time. + metisContentStoreInterface_PutContent(store, object_2, expiryTime + 10); // Add this one after expiration of first one. + + _MetisLRUContentStore *internalStore = (_MetisLRUContentStore *) metisContentStoreInterface_GetPrivateData(store); + _MetisLRUContentStoreStats *stats = &internalStore->stats; + + // Capacity is 1, so we should never grow bigger than that. + assertTrue(metisContentStoreInterface_GetObjectCount(store) == 1, "Wrong objectCount. Expected 1, got %zu", metisContentStoreInterface_GetObjectCount(store)); + + assertTrue(stats->countAdds == 2, "Wrong countAdds, expected %u got %" PRIu64, 2, + stats->countAdds); + assertTrue(stats->countExpiryEvictions == 1, "Wrong countLruEvictions, expected %u got %" PRIu64, 1, stats->countLruEvictions); + assertTrue(metisLruList_Length(internalStore->lru) == 1, "Wrong metisLruList_Length, expected 1 got %zu", + metisLruList_Length(internalStore->lru)); + assertTrue(metisContentStoreInterface_GetObjectCount(store) == 1, "Expected a store count of 1"); + + metisContentStoreInterface_Release(&store); + metisLogger_Release(&logger); + metisMessage_Release(&object_1); + metisMessage_Release(&object_2); +} + +LONGBOW_TEST_CASE(Global, metisLRUContentStore_Save_WithEvictionByRCT) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + + size_t capacity = 1; + MetisContentStoreInterface *store = _createLRUContentStore(capacity); + + MetisMessage *object_1 = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, + sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + MetisMessage *object_2 = metisMessage_CreateFromArray(metisTestDataV0_SecondObject, + sizeof(metisTestDataV0_SecondObject), 1, 2, logger); + + + uint64_t recommendedCacheTime = 1000; + + metisMessage_SetRecommendedCacheTimeTicks(object_1, recommendedCacheTime); + metisContentStoreInterface_PutContent(store, object_1, recommendedCacheTime - 100); // Add it. + + assertTrue(metisContentStoreInterface_GetObjectCount(store) == 1, "Wrong objectCount. Expected 1, got %zu", + metisContentStoreInterface_GetObjectCount(store)); + + metisContentStoreInterface_PutContent(store, object_2, recommendedCacheTime + 1); // Add this one after the first one's RCT. + + _MetisLRUContentStore *internalStore = (_MetisLRUContentStore *) metisContentStoreInterface_GetPrivateData(store); + _MetisLRUContentStoreStats *stats = &internalStore->stats; + + // Capacity is 1, so we should never grow bigger than that. + assertTrue(metisContentStoreInterface_GetObjectCount(store) == 1, "Wrong objectCount. Expected 1, got %zu", + metisContentStoreInterface_GetObjectCount(store)); + + assertTrue(stats->countAdds == 2, "Wrong countAdds, expected %u got %" PRIu64, 2, + stats->countAdds); + assertTrue(stats->countExpiryEvictions == 0, "Wrong countLruEvictions, expected 1got %" PRIu64, stats->countLruEvictions); + assertTrue(stats->countRCTEvictions == 1, "Wrong countLruEvictions, expected 1 got %" PRIu64, stats->countLruEvictions); + + assertTrue(metisLruList_Length(internalStore->lru) == 1, "Wrong metisLruList_Length, expected 1 got %zu", metisLruList_Length(internalStore->lru)); + assertTrue(metisContentStoreInterface_GetObjectCount(store) == 1, "Expected a store count of 1"); + + metisContentStoreInterface_Release(&store); + metisLogger_Release(&logger); + metisMessage_Release(&object_1); + metisMessage_Release(&object_2); +} + +LONGBOW_TEST_CASE(Global, metisLRUContentStore_Save_ZeroCapacity) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + + size_t capacity = 0; + MetisContentStoreInterface *store = _createLRUContentStore(capacity); + + MetisMessage *object_1 = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, + sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + bool success = metisContentStoreInterface_PutContent(store, object_1, 1); + assertFalse(success, "Should have returned failure with 0 capacity object store saving something"); + + metisMessage_Release(&object_1); + metisContentStoreInterface_Release(&store); + metisLogger_Release(&logger); +} + + +LONGBOW_TEST_CASE(Global, metisLRUContentStore_Save_CapacityLimit) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + + size_t capacity = 5; + MetisContentStoreInterface *store = _createLRUContentStore(capacity); + + for (int i = 1; i < capacity * 2; i++) { + int offsetOfNameInEncodedObject = metisTestDataV0_EncodedObject_name.offset + 4; + + MetisMessage *object = _createUniqueMetisMessage(logger, i, + metisTestDataV0_EncodedObject, + sizeof(metisTestDataV0_EncodedObject), + offsetOfNameInEncodedObject); + + bool success = metisContentStoreInterface_PutContent(store, object, 1); + + assertTrue(success, "Unexpectedly failed to add entry to ContentStore"); + + if (i < metisContentStoreInterface_GetObjectCapacity(store)) { + assertTrue(metisContentStoreInterface_GetObjectCount(store) == i, "Unexpected value for metisContentStoreInterface_objectCount"); + } else { + assertTrue(metisContentStoreInterface_GetObjectCount(store) == metisContentStoreInterface_GetObjectCapacity(store), + "Unexpected value (%zu) for metisContentStoreInterface_objectCount (%zu)", + metisContentStoreInterface_GetObjectCount(store), metisContentStoreInterface_GetObjectCapacity(store)); + } + + if (success) { + metisMessage_Release(&object); + } + } + metisLogger_Release(&logger); + metisContentStoreInterface_Release(&store); +} + +LONGBOW_TEST_CASE(Global, metisLRUContentStore_Save_DuplicateHash) +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + + size_t capacity = 5; + MetisContentStoreInterface *store = _createLRUContentStore(capacity); + + MetisMessage *object_1 = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, + sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + + + bool success = metisContentStoreInterface_PutContent(store, object_1, 1); + assertTrue(success, "Expected to add object_1 to store"); + + for (int i = 0; i < 10; i++) { + MetisMessage *object_1_dup = metisMessage_CreateFromArray(metisTestDataV0_EncodedObject, + sizeof(metisTestDataV0_EncodedObject), 1, 2, logger); + + success = metisContentStoreInterface_PutContent(store, object_1_dup, 1l); + + assertFalse(success, "Unexpectedly added duplicated entry to ContentStore"); + + assertTrue(metisContentStoreInterface_GetObjectCount(store) == 1, "ObjectCount should be 1"); + + metisMessage_Release(&object_1_dup); + } + + metisMessage_Release(&object_1); + metisContentStoreInterface_Release(&store); + metisLogger_Release(&logger); +} + +// ============================================================================ + +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_LRUContentStore); + int exitStatus = longBowMain(argc, argv, testRunner, NULL); + longBowTestRunner_Destroy(&testRunner); + exit(exitStatus); +} diff --git a/metis/ccnx/forwarder/metis/content_store/test/test_metis_LruList.c b/metis/ccnx/forwarder/metis/content_store/test/test_metis_LruList.c new file mode 100644 index 00000000..ef01b532 --- /dev/null +++ b/metis/ccnx/forwarder/metis/content_store/test/test_metis_LruList.c @@ -0,0 +1,204 @@ +/* + * 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_LruList.c" +#include <LongBow/unit-test.h> +#include <parc/algol/parc_SafeMemory.h> + +LONGBOW_TEST_RUNNER(metis_LruList) +{ + // 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(metis_LruList) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +// The Test Runner calls this function once after all the Test Fixtures are run. +LONGBOW_TEST_RUNNER_TEARDOWN(metis_LruList) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +// ============================================================================ + +LONGBOW_TEST_FIXTURE(Global) +{ + LONGBOW_RUN_TEST_CASE(Global, metisLruList_Create_Destroy); + + LONGBOW_RUN_TEST_CASE(Global, MetisLruListEntry_Destroy); + LONGBOW_RUN_TEST_CASE(Global, metisLruEntry_GetData); + LONGBOW_RUN_TEST_CASE(Global, metisLruEntry_MoveToHead); + + LONGBOW_RUN_TEST_CASE(Global, metisLruList_NewHeadEntry); + LONGBOW_RUN_TEST_CASE(Global, metisLruList_PopTail); + LONGBOW_RUN_TEST_CASE(Global, MetisLruList_Length); +} + +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; +} + +LONGBOW_TEST_CASE(Global, MetisLruListEntry_Destroy) +{ + MetisLruList *lru = metisLruList_Create(); + + size_t beforeMemory = parcMemory_Outstanding(); + MetisLruListEntry *entry = (MetisLruListEntry *) metisLruList_NewHeadEntry(lru, (void *) 0x02); + metisLruList_PopTail(lru); + metisLruList_EntryDestroy(&entry); + size_t afterMemory = parcMemory_Outstanding(); + + metisLruList_Destroy(&lru); + + assertTrue(afterMemory == beforeMemory, "Memory imbalance for LruEntry_Destroy, expected %zu got %zu", beforeMemory, afterMemory); +} + +LONGBOW_TEST_CASE(Global, metisLruEntry_GetData) +{ + void *data = (void *) 99; + MetisLruList *lru = metisLruList_Create(); + MetisLruListEntry *entry = (MetisLruListEntry *) metisLruList_NewHeadEntry(lru, data); + void *p = metisLruList_EntryGetData(entry); + + assertTrue(p == data, "Data did not match, expected %p, got %p", data, p); + metisLruList_Destroy(&lru); +} + +LONGBOW_TEST_CASE(Global, metisLruEntry_MoveToHead) +{ + int loops = 10; + + MetisLruList *lru = metisLruList_Create(); + + for (size_t i = 1; i <= loops; i++) { + metisLruList_NewHeadEntry(lru, (void *) i); + } + + MetisLruListEntry *tail = metisLruList_PopTail(lru); + metisLruList_EntryMoveToHead(tail); + + MetisLruListEntry *test = TAILQ_FIRST(&lru->head); + assertTrue(test == tail, "Head element not moved, expected %p got %p", (void *) tail, (void *) test); + + metisLruList_Destroy(&lru); +} + +LONGBOW_TEST_CASE(Global, metisLruList_Create_Destroy) +{ + size_t baselineMemory = parcMemory_Outstanding(); + + MetisLruList *lru = metisLruList_Create(); + metisLruList_Destroy(&lru); + + assertTrue(parcMemory_Outstanding() == baselineMemory, "Memory imbalance on create/destroy: %u", parcMemory_Outstanding()); +} + +LONGBOW_TEST_CASE(Global, metisLruList_Length) +{ + int loops = 10; + + MetisLruList *lru = metisLruList_Create(); + + for (size_t i = 1; i <= loops; i++) { + MetisLruListEntry *entry = (MetisLruListEntry *) metisLruList_NewHeadEntry(lru, (void *) i); + assertTrue(lru->itemsInList == i, "Incorrect list length element %zu, expected %zu got %zu", i, i, lru->itemsInList); + assertTrue(metisLruList_Length(lru) == i, "Incorrect length encountered"); + + MetisLruListEntry *test = TAILQ_FIRST(&lru->head); + assertTrue(test == entry, "Head element not new entry, expected %p got %p", (void *) entry, (void *) test); + } + metisLruList_Destroy(&lru); +} + +LONGBOW_TEST_CASE(Global, metisLruList_NewHeadEntry) +{ + int loops = 10; + + MetisLruList *lru = metisLruList_Create(); + + for (size_t i = 1; i <= loops; i++) { + MetisLruListEntry *entry = (MetisLruListEntry *) metisLruList_NewHeadEntry(lru, (void *) i); + assertTrue(lru->itemsInList == i, "Incorrect list length element %zu, expected %zu got %zu", i, i, lru->itemsInList); + + MetisLruListEntry *test = TAILQ_FIRST(&lru->head); + assertTrue(test == entry, "Head element not new entry, expected %p got %p", (void *) entry, (void *) test); + } + metisLruList_Destroy(&lru); +} + +LONGBOW_TEST_CASE(Global, metisLruList_PopTail) +{ + int loops = 10; + + MetisLruList *lru = metisLruList_Create(); + + for (size_t i = 1; i <= loops; i++) { + metisLruList_NewHeadEntry(lru, (void *) i); + } + + for (size_t i = 1; i <= loops; i++) { + MetisLruListEntry *entry = metisLruList_PopTail(lru); + void *data = metisLruList_EntryGetData(entry); + assertTrue(data == (void *) i, "Got wrong data, expected %p got %p", (void *) i, (void *) data); + + metisLruList_EntryDestroy(&entry); + } + + metisLruList_Destroy(&lru); +} + + +LONGBOW_TEST_CASE(Global, MetisLruList_Length) +{ + int loops = 10; + + MetisLruList *lru = metisLruList_Create(); + + for (size_t i = 1; i <= loops; i++) { + metisLruList_NewHeadEntry(lru, (void *) i); + assertTrue(metisLruList_Length(lru) == i, "Unexpected LruList length"); + } + + metisLruList_Destroy(&lru); +} + +// ============================================================================ + +int +main(int argc, char *argv[]) +{ + LongBowRunner *testRunner = LONGBOW_TEST_RUNNER_CREATE(metis_LruList); + int exitStatus = longBowMain(argc, argv, testRunner, NULL); + longBowTestRunner_Destroy(&testRunner); + exit(exitStatus); +} diff --git a/metis/ccnx/forwarder/metis/content_store/test/test_metis_TimeOrderedList.c b/metis/ccnx/forwarder/metis/content_store/test/test_metis_TimeOrderedList.c new file mode 100644 index 00000000..c3a7a530 --- /dev/null +++ b/metis/ccnx/forwarder/metis/content_store/test/test_metis_TimeOrderedList.c @@ -0,0 +1,259 @@ +/* + * 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 Runner. + +#include <config.h> +#include <stdlib.h> // for rand() + +#include "../metis_TimeOrderedList.c" + +#include <LongBow/unit-test.h> + +#include <parc/algol/parc_SafeMemory.h> +#include <parc/logging/parc_LogReporterTextStdout.h> + +LONGBOW_TEST_RUNNER(metis_TimeOrderedList) +{ + srand(5150); // A fixed seed for the RNG for consistency. + parcMemory_SetInterface(&PARCSafeMemoryAsPARCMemory); + + LONGBOW_RUN_TEST_FIXTURE(Global); + LONGBOW_RUN_TEST_FIXTURE(Static); +} + +// The Test Runner calls this function once before any Test Fixtures are run. +LONGBOW_TEST_RUNNER_SETUP(metis_TimeOrderedList) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +// The Test Runner calls this function once after all the Test Fixtures are run. +LONGBOW_TEST_RUNNER_TEARDOWN(metis_TimeOrderedList) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_FIXTURE(Global) +{ + LONGBOW_RUN_TEST_CASE(Global, metisTimeOrderedList_CreateRelease); + LONGBOW_RUN_TEST_CASE(Global, metisTimeOrderedList_AcquireRelease); + LONGBOW_RUN_TEST_CASE(Global, metisTimeOrderedList_AddRemove); + LONGBOW_RUN_TEST_CASE(Global, metisTimeOrderedList_GetOldest); + LONGBOW_RUN_TEST_CASE(Global, metisTimeOrderedList_Length); +} + +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; +} + +static MetisLogger * +_createLogger() +{ + PARCLogReporter *reporter = parcLogReporterTextStdout_Create(); + MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock()); + parcLogReporter_Release(&reporter); + return logger; +} + +LONGBOW_TEST_CASE(Global, metisTimeOrderedList_CreateRelease) +{ + MetisLogger *logger = _createLogger(); + + MetisTimeOrderedList *list = metisTimeOrderedList_Create((MetisTimeOrderList_KeyCompare *) metisContentStoreEntry_CompareExpiryTime); + MetisLruList *lruList = metisLruList_Create(); + MetisMessage *message = metisMessage_CreateFromArray((uint8_t *) "\x00" "ehlo", 5, 111, 2, logger); + + metisMessage_SetRecommendedCacheTimeTicks(message, 100); + metisMessage_SetExpiryTimeTicks(message, 200); + MetisContentStoreEntry *entry = metisContentStoreEntry_Create(message, lruList); + + metisTimeOrderedList_Add(list, entry); + + metisTimeOrderedList_Release(&list); + + metisContentStoreEntry_Release(&entry); + metisMessage_Release(&message); // We must release the message, as it's not acquired by the TimeOrderedList. + metisLruList_Destroy(&lruList); + metisLogger_Release(&logger); +} + +LONGBOW_TEST_CASE(Global, metisTimeOrderedList_AcquireRelease) +{ + MetisTimeOrderedList *list = metisTimeOrderedList_Create((MetisTimeOrderList_KeyCompare *) metisContentStoreEntry_CompareExpiryTime); + MetisTimeOrderedList *ref = metisTimeOrderedList_Acquire(list); + + assertTrue(ref == list, "Expected ref and original to be the same"); + + metisTimeOrderedList_Release(&list); + metisTimeOrderedList_Release(&ref); +} + +LONGBOW_TEST_CASE(Global, metisTimeOrderedList_AddRemove) +{ + MetisLogger *logger = _createLogger(); + MetisTimeOrderedList *list = metisTimeOrderedList_Create((MetisTimeOrderList_KeyCompare *) metisContentStoreEntry_CompareExpiryTime); + MetisLruList *lruList = metisLruList_Create(); + + size_t numEntries = 100; + MetisContentStoreEntry **contentEntryList = parcMemory_AllocateAndClear(numEntries * sizeof(MetisContentStoreEntry *)); + + for (int i = 1; i <= numEntries; i++) { + MetisMessage *message = metisMessage_CreateFromArray((uint8_t *) "\x00" "ehlo", 5, 111, i, logger); + + metisMessage_SetRecommendedCacheTimeTicks(message, i % 10); // i % 10 will ensure that there are duplicate time entries. + metisMessage_SetExpiryTimeTicks(message, i % 10); + + contentEntryList[i - 1] = metisContentStoreEntry_Create(message, lruList); + metisTimeOrderedList_Add(list, contentEntryList[i - 1]); + + assertTrue(metisTimeOrderedList_Length(list) == i, "Got wrong TimeOrderedList object count"); + } + + for (int i = 1; i <= numEntries; i++) { + MetisContentStoreEntry *contentEntry = contentEntryList[i - 1]; + metisTimeOrderedList_Remove(list, contentEntry); + MetisMessage *message = metisContentStoreEntry_GetMessage(contentEntry); + metisMessage_Release(&message); + + size_t count = metisTimeOrderedList_Length(list); + assertTrue(count == numEntries - i, "Got wrong TimeOrderedList object count"); + metisContentStoreEntry_Release(&contentEntry); + } + + parcMemory_Deallocate((void **) &contentEntryList); + metisTimeOrderedList_Release(&list); + metisLruList_Destroy(&lruList); + metisLogger_Release(&logger); +} + +LONGBOW_TEST_CASE(Global, metisTimeOrderedList_GetOldest) +{ + MetisLogger *logger = _createLogger(); + + // We're going to use the ExpiryTime as the sorting comparison for GetOldest(). + MetisTimeOrderedList *list = metisTimeOrderedList_Create((MetisTimeOrderList_KeyCompare *) metisContentStoreEntry_CompareExpiryTime); + + // Add some entries, with randomly ordered ExpiryTimes. + for (int i = 0; i < 100; i++) { + uint64_t time = (uint64_t) rand() + 1; + + MetisMessage *message = metisMessage_CreateFromArray((uint8_t *) "\x00" "ehlo", 5, 111, i, logger); + + metisMessage_SetRecommendedCacheTimeTicks(message, 100); // constant RCT + metisMessage_SetExpiryTimeTicks(message, time); // random expiry time. + + MetisContentStoreEntry *entry = metisContentStoreEntry_Create(message, NULL); + + metisTimeOrderedList_Add(list, entry); + + assertTrue(metisTimeOrderedList_Length(list) == i + 1, "Got wrong TimeOrderedList object count"); + } + + // Ensure that GetOldest() always returns the oldest. + + uint64_t lastTime = 0; + MetisContentStoreEntry *entry = NULL; + while ((entry = metisTimeOrderedList_GetOldest(list)) != NULL) { + MetisMessage *message = metisContentStoreEntry_GetMessage(entry); + uint64_t messageTime = metisMessage_GetExpiryTimeTicks(message); + + // We should always retrieve a time later than the previous time we retrieved. + assertTrue(messageTime > lastTime, "Received out of order message"); + + lastTime = messageTime; + metisTimeOrderedList_Remove(list, entry); + metisMessage_Release(&message); + metisContentStoreEntry_Release(&entry); + } + + metisTimeOrderedList_Release(&list); + metisLogger_Release(&logger); +} + +LONGBOW_TEST_CASE(Global, metisTimeOrderedList_Length) +{ + MetisLogger *logger = _createLogger(); + + MetisTimeOrderedList *list = metisTimeOrderedList_Create((MetisTimeOrderList_KeyCompare *) metisContentStoreEntry_CompareExpiryTime); + + // Add some entries with duplicate times to make sure that duplicate time stamps work. + uint64_t times[] = { 1, 2, 3, 100, 100, 100, 4, 4, 3, 2, 1, 5, 6, 7, 8, 9 }; + size_t numEntriesToMake = sizeof(times) / sizeof(uint64_t); + + for (int i = 0; i < numEntriesToMake; i++) { + MetisMessage *message = metisMessage_CreateFromArray((uint8_t *) "\x00" "ehlo", 5, 111, times[i], logger); + metisMessage_SetExpiryTimeTicks(message, times[i]); + MetisContentStoreEntry *entry = metisContentStoreEntry_Create(message, NULL); + metisTimeOrderedList_Add(list, entry); + assertTrue(metisTimeOrderedList_Length(list) == i + 1, "Got wrong TimeOrderedList object count"); + } + + // Clean up the messages we allocated. + int i = 0; + MetisContentStoreEntry *entry = NULL; + while ((entry = metisTimeOrderedList_GetOldest(list)) != NULL) { + assertTrue(metisTimeOrderedList_Length(list) == numEntriesToMake - i, "Got wrong TimeOrderedList object count"); + + MetisMessage *message = metisContentStoreEntry_GetMessage(entry); + metisTimeOrderedList_Remove(list, entry); + metisMessage_Release(&message); + metisContentStoreEntry_Release(&entry); + i++; + } + + metisTimeOrderedList_Release(&list); + metisLogger_Release(&logger); +} + +LONGBOW_TEST_FIXTURE(Static) +{ +} + +LONGBOW_TEST_FIXTURE_SETUP(Static) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_FIXTURE_TEARDOWN(Static) +{ + 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_TimeOrderedList); + int exitStatus = longBowMain(argc, argv, testRunner, NULL); + longBowTestRunner_Destroy(&testRunner); + exit(exitStatus); +} + |