static void
_metisStreamConnection_DestroyOperations(MetisIoOperations **opsPtr)
{
assertNotNull(opsPtr, "Parameter opsPtr must be non-null double pointer");
assertNotNull(*opsPtr, "Parameter opsPtr must dereference to non-null pointer");
MetisIoOperations *ops = *opsPtr;
assertNotNull(metisIoOperations_GetClosure(ops), "ops->context must not be null");
_MetisStreamState *stream = (_MetisStreamState *) metisIoOperations_GetClosure(ops);
parcEventQueue_Destroy(&stream->bufferEventVector);
metisAddressPair_Release(&stream->addressPair);
if (!stream->isClosed) {
stream->isClosed = true;
metisMessenger_Send(metisForwarder_GetMessenger(stream->metis), metisMissive_Create(MetisMissiveType_ConnectionClosed, stream->id));
}
metisMessenger_Send(metisForwarder_GetMessenger(stream->metis), metisMissive_Create(MetisMissiveType_ConnectionDestroyed, stream->id));
if (metisLogger_IsLoggable(stream->logger, MetisLoggerFacility_IO, PARCLogLevel_Info)) {
metisLogger_Log(stream->logger, MetisLoggerFacility_IO, PARCLogLevel_Info, __func__,
"StreamConnection %p destroyed", (void *) stream);
}
metisLogger_Release(&stream->logger);
parcMemory_Deallocate((void **) &stream);
parcMemory_Deallocate((void **) &ops);
*opsPtr = NULL;
}
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_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_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_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());
}
static bool
_MetisLRUContentStore_Destructor(_MetisLRUContentStore **storePtr)
{
_MetisLRUContentStore *store = *storePtr;
_destroyIndexes(store);
metisLogger_Release(&store->logger);
return true;
}
void
metisHopByHopFragmenter_Release(MetisHopByHopFragmenter **fragmenterPtr)
{
MetisHopByHopFragmenter *fragmenter = *fragmenterPtr;
parcEventBuffer_Destroy(&fragmenter->currentReceiveBuffer);
parcRingBuffer1x1_Release(&fragmenter->sendQueue);
parcRingBuffer1x1_Release(&fragmenter->receiveQueue);
metisLogger_Release(&fragmenter->logger);
parcMemory_Deallocate((void **) fragmenterPtr);
}
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_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_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);
}
void
metisDispatcher_Destroy(MetisDispatcher **dispatcherPtr)
{
assertNotNull(dispatcherPtr, "Parameter must be non-null double pointer");
assertNotNull(*dispatcherPtr, "Parameter must dereference to non-null pointer");
MetisDispatcher *dispatcher = *dispatcherPtr;
metisLogger_Release(&dispatcher->logger);
parcEventScheduler_Destroy(&(dispatcher->Base));
parcMemory_Deallocate((void **) &dispatcher);
*dispatcherPtr = NULL;
}
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_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_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_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_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_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_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_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_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_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);
}
void
metisConfiguration_Destroy(MetisConfiguration **configPtr)
{
assertNotNull(configPtr, "Parameter must be non-null double poitner");
assertNotNull(*configPtr, "Parameter must dereference to non-null pointer");
MetisConfiguration *config = *configPtr;
metisLogger_Release(&config->logger);
if (config->cli != NULL) {
metisCommandLineInterface_Destroy(&config->cli);
}
metisSymbolicNameTable_Destroy(&config->symbolicNameTable);
parcMemory_Deallocate((void **) &config);
*configPtr = NULL;
}
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_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_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_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_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);
}
static void
_metisStandardPIT_Destroy(MetisPIT **pitPtr)
{
assertNotNull(pitPtr, "Parameter must be non-null double pointer");
assertNotNull(*pitPtr, "Parameter must dereference to non-null pointer");
MetisStandardPIT *pit = metisPIT_Closure(*pitPtr);
if (metisLogger_IsLoggable(pit->logger, MetisLoggerFacility_Processor, PARCLogLevel_Debug)) {
metisLogger_Log(pit->logger, MetisLoggerFacility_Processor, PARCLogLevel_Debug, __func__,
"PIT %p destroyed",
(void *) pit);
}
metisMatchingRulesTable_Destroy(&pit->table);
metisLogger_Release(&pit->logger);
parcMemory_Deallocate(pitPtr);
}
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;
}
