LONGBOW_TEST_CASE(Global, getMatchByName)
{
AthenaLRUContentStoreConfig config;
config.capacityInMB = 10;
AthenaContentStore *store = athenaContentStore_Create(&AthenaContentStore_LRUImplementation, &config);
char *lci = "lci:/cakes/and/pies";
PARCClock *clock = parcClock_Wallclock();
CCNxName *truthName = ccnxName_CreateFromCString(lci);
CCNxContentObject *truthObject = ccnxContentObject_CreateWithNameAndPayload(truthName, NULL);
ccnxContentObject_SetExpiryTime(truthObject, parcClock_GetTime(clock) + 100);
ccnxName_Release(&truthName);
athenaContentStore_PutContentObject(store, truthObject);
CCNxName *testName = ccnxName_CreateFromCString(lci);
CCNxInterest *interest = ccnxInterest_CreateSimple(testName);
ccnxName_Release(&testName);
//athena_EncodeMessage(interest);
CCNxContentObject *testObject = athenaContentStore_GetMatch(store, interest);
ccnxInterest_Release(&interest);
// TODO: match on other than name!
assertTrue(ccnxContentObject_Equals(truthObject, testObject), "Expected to get the same ContentObject back");
assertTrue(truthObject == testObject, "Expected the same pointer back");
athenaContentStore_Release(&store);
ccnxContentObject_Release(&truthObject);
parcClock_Release(&clock);
}
LONGBOW_TEST_CASE(Global, removeMatch)
{
AthenaLRUContentStoreConfig config;
config.capacityInMB = 10;
AthenaContentStore *store = athenaContentStore_Create(&AthenaContentStore_LRUImplementation, &config);
PARCClock *clock = parcClock_Wallclock();
char *lci = "lci:/cakes/and/pies";
CCNxName *origName = ccnxName_CreateFromCString(lci);
CCNxContentObject *contentObject = ccnxContentObject_CreateWithNameAndPayload(origName, NULL);
ccnxContentObject_SetExpiryTime(contentObject, parcClock_GetTime(clock) + 100);
ccnxName_Release(&origName);
athenaContentStore_PutContentObject(store, contentObject);
ccnxContentObject_Release(&contentObject);
CCNxName *testName = ccnxName_CreateFromCString(lci);
bool status = athenaContentStore_RemoveMatch(store, testName, NULL, NULL);
// TODO: match on other than name!
assertTrue(status, "Expected to remove the contentobject we had");
ccnxName_Release(&testName);
parcClock_Release(&clock);
athenaContentStore_Release(&store);
}
LONGBOW_TEST_CASE(Global, athena_ProcessContentObject)
{
PARCURI *connectionURI;
Athena *athena = athena_Create(100);
CCNxName *name = ccnxName_CreateFromCString("lci:/cakes/and/pies");
uint64_t chunkNum = 0;
CCNxNameSegment *chunkSegment = ccnxNameSegmentNumber_Create(CCNxNameLabelType_CHUNK, chunkNum);
ccnxName_Append(name, chunkSegment);
ccnxNameSegment_Release(&chunkSegment);
PARCBuffer *payload = parcBuffer_WrapCString("this is a payload");
CCNxContentObject *contentObject = ccnxContentObject_CreateWithNameAndPayload(name, payload);
ccnxName_Release(&name);
parcBuffer_Release(&payload);
connectionURI = parcURI_Parse("tcp://localhost:50100/listener/name=TCPListener");
const char *result = athenaTransportLinkAdapter_Open(athena->athenaTransportLinkAdapter, connectionURI);
assertTrue(result != NULL, "athenaTransportLinkAdapter_Open failed (%s)", strerror(errno));
parcURI_Release(&connectionURI);
connectionURI = parcURI_Parse("tcp://localhost:50100/name=TCP_0");
result = athenaTransportLinkAdapter_Open(athena->athenaTransportLinkAdapter, connectionURI);
assertTrue(result != NULL, "athenaTransportLinkAdapter_Open failed (%s)", strerror(errno));
parcURI_Release(&connectionURI);
int linkId = athenaTransportLinkAdapter_LinkNameToId(athena->athenaTransportLinkAdapter, "TCP_0");
PARCBitVector *ingressVector = parcBitVector_Create();
parcBitVector_Set(ingressVector, linkId);
athena_EncodeMessage(contentObject);
athena_ProcessMessage(athena, contentObject, ingressVector);
parcBitVector_Release(&ingressVector);
// Make sure we recover processing a "nameless" content object
payload = parcBuffer_WrapCString("Hello World");
CCNxContentObject *reply = ccnxContentObject_CreateWithPayload(payload);
parcBuffer_Release(&payload);
CCNxMetaMessage *response = ccnxMetaMessage_CreateFromContentObject(reply);
ccnxContentObject_Release(&reply);
athena_EncodeMessage(response);
athena_ProcessMessage(athena, response, ingressVector);
assertNull(ingressVector, "Processing nameless content object didn't fail.");
ccnxInterest_Release(&contentObject);
ccnxInterest_Release(&response);
athena_Release(&athena);
}
LONGBOW_TEST_CASE(Global, ccnxMetaMessage_CreateFromContentObject)
{
CCNxName *name = ccnxName_CreateFromCString("lci:/foo/bar");
PARCBuffer *payload = parcBuffer_WrapCString("This is some data. It's not good data, but it is data.");
CCNxContentObject *contentObject = ccnxContentObject_CreateWithNameAndPayload(name, payload);
CCNxMetaMessage *portalMessage = ccnxMetaMessage_CreateFromContentObject(contentObject);
assertNotNull(portalMessage, "Expected a non-null portal message");
ccnxMetaMessage_Release(&portalMessage);
ccnxContentObject_Release(&contentObject);
parcBuffer_Release(&payload);
ccnxName_Release(&name);
}
static CCNxMetaMessage *
_mockRead(void *privateData, const uint64_t *microSeconds)
{
CCNxName *name = ccnxName_Create();
PARCBuffer *payload = parcBuffer_Allocate(10);
CCNxContentObject *object = ccnxContentObject_CreateWithNameAndPayload(name, payload);
ccnxName_Release(&name);
parcBuffer_Release(&payload);
CCNxMetaMessage *result = ccnxMetaMessage_CreateFromContentObject(object);
ccnxContentObject_Release(&object);
return result;
}
/**
* Create a CCNxContentObject with the given LCI name, chunknumber, and payload.
*/
static CCNxContentObject *
_createContentObject(char *lci, uint64_t chunkNum, PARCBuffer *payload)
{
CCNxName *name = ccnxName_CreateFromCString(lci);
CCNxNameSegment *chunkSegment = ccnxNameSegmentNumber_Create(CCNxNameLabelType_CHUNK, chunkNum);
ccnxName_Append(name, chunkSegment);
CCNxContentObject *result = ccnxContentObject_CreateWithNameAndPayload(name, payload);
ccnxName_Release(&name);
ccnxNameSegment_Release(&chunkSegment);
return result;
}
static CCNxMetaMessage *
_athenaLRUContentStore_ProcessMessage(AthenaContentStoreImplementation *store, const CCNxMetaMessage *message)
{
CCNxMetaMessage *result = NULL;
AthenaLRUContentStore *impl = (AthenaLRUContentStore *) store;
if (ccnxMetaMessage_IsInterest(message)) {
CCNxInterest *interest = ccnxMetaMessage_GetInterest(message);
CCNxName *queryName = ccnxInterest_GetName(interest);
uint64_t chunkNumber = 0;
bool hasChunkNumber = false;
_getChunkNumberFromName(queryName, &chunkNumber, &hasChunkNumber);
assertFalse(hasChunkNumber, "LRUContentStore queries don't yet support more than 1 chunk.");
PARCBuffer *responsePayload = NULL;
// Find the arguments to our query.
size_t argSegmentIndex = 0;
if (_getSegmentIndexOfQueryArgs(queryName, AthenaModule_ContentStore, &argSegmentIndex)) {
CCNxNameSegment *queryTypeSegment = ccnxName_GetSegment(queryName, argSegmentIndex);
char *queryTypeString = ccnxNameSegment_ToString(queryTypeSegment); // e.g. "stat"
char *statString = "stat";
if (strncasecmp(queryTypeString, statString, strlen(statString)) == 0) {
responsePayload = _processStatQuery(impl, queryName, argSegmentIndex + 1, chunkNumber);
}
parcMemory_Deallocate(&queryTypeString);
}
if (responsePayload != NULL) {
CCNxContentObject *contentObjectResponse = ccnxContentObject_CreateWithNameAndPayload(
ccnxInterest_GetName(interest), responsePayload);
result = ccnxMetaMessage_CreateFromContentObject(contentObjectResponse);
ccnxContentObject_SetExpiryTime(contentObjectResponse,
parcClock_GetTime(impl->wallClock) +
100); // this response is good for 100 millis
ccnxContentObject_Release(&contentObjectResponse);
parcBuffer_Release(&responsePayload);
}
}
return result; // could be NULL
}
LONGBOW_TEST_CASE(Global, ccnxMetaMessage_IsContentObject)
{
CCNxName *name = ccnxName_CreateFromCString("lci:/foo/bar");
PARCBuffer *payload = parcBuffer_WrapCString("This is some data. It's not good data, but it is data.");
CCNxContentObject *contentObject = ccnxContentObject_CreateWithNameAndPayload(name, payload);
CCNxMetaMessage *portalMessage = ccnxMetaMessage_CreateFromContentObject(contentObject);
assertTrue(ccnxMetaMessage_IsContentObject(portalMessage), "Expected portal message to be an ContentObject");
assertFalse(ccnxMetaMessage_IsInterest(portalMessage), "Did not expect portal message to be an Interest");
assertFalse(ccnxMetaMessage_IsControl(portalMessage), "Did not expect portal message to be a Control message");
ccnxMetaMessage_Release(&portalMessage);
ccnxContentObject_Release(&contentObject);
parcBuffer_Release(&payload);
ccnxName_Release(&name);
}
static CCNxMetaMessage *
_create_response(Athena *athena, CCNxName *ccnxName, const char *format, ...)
{
va_list ap;
va_start(ap, format);
char responseBuffer[MAXPATHLEN];
vsprintf(responseBuffer, format, ap);
PARCBuffer *responsePayload = parcBuffer_AllocateCString(responseBuffer);
parcLog_Info(athena->log, responseBuffer);
CCNxContentObject *responseContent = ccnxContentObject_CreateWithNameAndPayload(ccnxName, responsePayload);
CCNxMetaMessage *responseMessage = ccnxMetaMessage_CreateFromContentObject(responseContent);
ccnxContentObject_Release(&responseContent);
parcBuffer_Release(&responsePayload);
athena_EncodeMessage(responseMessage);
return responseMessage;
}
static CCNxMetaMessage *
_create_stats_response(Athena *athena, CCNxName *ccnxName)
{
PARCJSON *json = parcJSON_Create();
struct timeval tv;
gettimeofday(&tv, NULL);
uint64_t nowInMillis = (tv.tv_sec * 1000) + (tv.tv_usec / 1000);
parcJSON_AddString(json, "moduleName", athenaAbout_Name());
parcJSON_AddInteger(json, "time", nowInMillis);
parcJSON_AddInteger(json, "numProcessedInterests",
athena->stats.numProcessedInterests);
parcJSON_AddInteger(json, "numProcessedContentObjects",
athena->stats.numProcessedContentObjects);
parcJSON_AddInteger(json, "numProcessedControlMessages",
athena->stats.numProcessedControlMessages);
parcJSON_AddInteger(json, "numProcessedInterestReturns",
athena->stats.numProcessedInterestReturns);
char *jsonString = parcJSON_ToString(json);
parcJSON_Release(&json);
PARCBuffer *payload = parcBuffer_CreateFromArray(jsonString, strlen(jsonString));
parcMemory_Deallocate(&jsonString);
CCNxContentObject *contentObject =
ccnxContentObject_CreateWithNameAndPayload(ccnxName, parcBuffer_Flip(payload));
ccnxContentObject_SetExpiryTime(contentObject, nowInMillis + 100); // this response is good for 100 millis
CCNxMetaMessage *result = ccnxMetaMessage_CreateFromContentObject(contentObject);
ccnxContentObject_Release(&contentObject);
parcBuffer_Release(&payload);
return result;
}
LONGBOW_TEST_CASE(Global, ccnxWireFormatMessage_CreateContentObjectHash)
{
// >1234<
const char string[] = "Hello dev null\n";
PARCBuffer *buffer = parcBuffer_Wrap((void *) string, sizeof(string), 0, sizeof(string));
CCNxWireFormatMessage *message = ccnxWireFormatMessage_FromContentObjectPacketType(CCNxTlvDictionary_SchemaVersion_V1, buffer);
PARCCryptoHash *hash = ccnxWireFormatMessage_CreateContentObjectHash(message);
ccnxWireFormatMessage_Release(&message);
assertNull(hash, "Expect NULL for hash as it hasn't been encoded yet");
// We need to create a content object that is hashable
CCNxName *name = ccnxName_CreateFromCString("lci:/test/content");
CCNxContentObject *contentObject = ccnxContentObject_CreateWithNameAndPayload(name, buffer);
ccnxName_Release(&name);
// This next stuff is to force an encode/decode to setup hash extents
CCNxCodecNetworkBufferIoVec *iovec = ccnxCodecTlvPacket_DictionaryEncode(contentObject, NULL);
ccnxContentObject_Release(&contentObject);
PARCBuffer *encodedMessage = _iovecToParcBuffer(iovec);
ccnxCodecNetworkBufferIoVec_Release(&iovec);
// Decode
message = ccnxWireFormatMessage_Create(encodedMessage);
CCNxTlvDictionary *dictionary = ccnxWireFormatMessage_GetDictionary(message);
bool success = ccnxCodecTlvPacket_BufferDecode(encodedMessage, dictionary);
assertTrue(success, "Failed to decode buffer");
parcBuffer_Release(&encodedMessage);
hash = ccnxWireFormatMessage_CreateContentObjectHash(message);
// the correctness of the hash is tested in _ccnxWireFormatFacadeV1_ComputeHash
assertNotNull(hash, "Got null hash from a good packet");
ccnxWireFormatMessage_Release(&message);
parcCryptoHash_Release(&hash);
parcBuffer_Release(&buffer);
}
LONGBOW_TEST_CASE(Global, ccnxMetaMessage_GetContentObject)
{
CCNxName *name = ccnxName_CreateFromCString("lci:/foo/bar");
PARCBuffer *payload = parcBuffer_WrapCString("This is some data. It's not good data, but it is data.");
CCNxContentObject *contentObject = ccnxContentObject_CreateWithNameAndPayload(name, payload);
CCNxMetaMessage *portalMessage = ccnxMetaMessage_CreateFromContentObject(contentObject);
CCNxContentObject *reference = ccnxMetaMessage_GetContentObject(portalMessage);
#ifndef BUGZID_712
// TODO: We need a ccnxContentObject_Equals()!
// assertTrue(ccnxContentObject_Equals(contentObject, reference), "Expected reference to equal original contentObject");
#endif // !BUGZID_712
ccnxContentObject_AssertValid(reference);
ccnxMetaMessage_Release(&portalMessage);
ccnxContentObject_Release(&contentObject);
parcBuffer_Release(&payload);
ccnxName_Release(&name);
}
static CCNxMetaMessage *
_create_FIBList_response(Athena *athena, CCNxName *ccnxName, PARCList *fibEntryList)
{
PARCJSON *jsonPayload = parcJSON_Create();
PARCJSONArray *jsonEntryList = parcJSONArray_Create();
parcJSON_AddArray(jsonPayload, JSON_KEY_RESULT, jsonEntryList);
for (size_t i = 0; i < parcList_Size(fibEntryList); ++i) {
AthenaFIBListEntry *entry = parcList_GetAtIndex(fibEntryList, i);
if (entry != NULL) {
CCNxName *prefixName = athenaFIBListEntry_GetName(entry);
if (prefixName) {
char *prefix = ccnxName_ToString(prefixName);
int linkId = athenaFIBListEntry_GetLinkId(entry);
const char *linkName = athenaTransportLinkAdapter_LinkIdToName(athena->athenaTransportLinkAdapter, linkId);
parcLog_Debug(athena->log, " Route: %s->%s", prefix, linkName);
PARCJSON *jsonItem = parcJSON_Create();
parcJSON_AddString(jsonItem, JSON_KEY_NAME, prefix);
parcJSON_AddString(jsonItem, JSON_KEY_LINK, linkName);
PARCJSONValue *jsonItemValue = parcJSONValue_CreateFromJSON(jsonItem);
parcJSON_Release(&jsonItem);
parcJSONArray_AddValue(jsonEntryList, jsonItemValue);
parcJSONValue_Release(&jsonItemValue);
parcMemory_Deallocate(&prefix);
} else {
int linkId = athenaFIBListEntry_GetLinkId(entry);
const char *linkName = athenaTransportLinkAdapter_LinkIdToName(athena->athenaTransportLinkAdapter, linkId);
parcLog_Debug(athena->log, " Route: <empty>->%s", linkName);
PARCJSON *jsonItem = parcJSON_Create();
parcJSON_AddString(jsonItem, JSON_KEY_NAME, "");
parcJSON_AddString(jsonItem, JSON_KEY_LINK, linkName);
PARCJSONValue *jsonItemValue = parcJSONValue_CreateFromJSON(jsonItem);
parcJSON_Release(&jsonItem);
parcJSONArray_AddValue(jsonEntryList, jsonItemValue);
parcJSONValue_Release(&jsonItemValue);
}
}
}
char *jsonString = parcJSON_ToString(jsonPayload);
parcJSONArray_Release(&jsonEntryList);
parcJSON_Release(&jsonPayload);
PARCBuffer *payload = parcBuffer_CreateFromArray(jsonString, strlen(jsonString));
CCNxContentObject *contentObject =
ccnxContentObject_CreateWithNameAndPayload(ccnxName, parcBuffer_Flip(payload));
struct timeval tv;
gettimeofday(&tv, NULL);
uint64_t nowInMillis = (tv.tv_sec * 1000) + (tv.tv_usec / 1000);
ccnxContentObject_SetExpiryTime(contentObject, nowInMillis + 100); // this response is good for 100 millis
CCNxMetaMessage *result = ccnxMetaMessage_CreateFromContentObject(contentObject);
ccnxContentObject_Release(&contentObject);
parcBuffer_Release(&payload);
parcMemory_Deallocate(&jsonString);
athena_EncodeMessage(result);
return result;
}
static CCNxMetaMessage *
_create_linkList_response(AthenaTransportLinkAdapter *athenaTransportLinkAdapter, CCNxName *ccnxName)
{
PARCJSONArray *jsonLinkList = parcJSONArray_Create();
for (int index = 0; index < parcArrayList_Size(athenaTransportLinkAdapter->listenerList); index++) {
AthenaTransportLink *athenaTransportLink = parcArrayList_Get(athenaTransportLinkAdapter->listenerList, index);
const char *linkName = athenaTransportLink_GetName(athenaTransportLink);
bool notLocal = athenaTransportLink_IsNotLocal(athenaTransportLink);
bool localForced = athenaTransportLink_IsForceLocal(athenaTransportLink);
PARCJSON *jsonItem = parcJSON_Create();
parcJSON_AddString(jsonItem, "linkName", linkName);
parcJSON_AddInteger(jsonItem, "index", -1);
parcJSON_AddBoolean(jsonItem, "notLocal", notLocal);
parcJSON_AddBoolean(jsonItem, "localForced", localForced);
PARCJSONValue *jsonItemValue = parcJSONValue_CreateFromJSON(jsonItem);
parcJSON_Release(&jsonItem);
parcJSONArray_AddValue(jsonLinkList, jsonItemValue);
parcJSONValue_Release(&jsonItemValue);
if (notLocal) {
parcLog_Debug(athenaTransportLinkAdapter->log, "\n Link listener%s: %s", localForced ? " (forced remote)" : "", linkName);
} else {
parcLog_Debug(athenaTransportLinkAdapter->log, "\n Link listener%s: %s", localForced ? " (forced local)" : "", linkName);
}
}
for (int index = 0; index < parcArrayList_Size(athenaTransportLinkAdapter->instanceList); index++) {
AthenaTransportLink *athenaTransportLink = parcArrayList_Get(athenaTransportLinkAdapter->instanceList, index);
if (athenaTransportLink) {
const char *linkName = athenaTransportLink_GetName(athenaTransportLink);
bool notLocal = athenaTransportLink_IsNotLocal(athenaTransportLink);
bool localForced = athenaTransportLink_IsForceLocal(athenaTransportLink);
PARCJSON *jsonItem = parcJSON_Create();
parcJSON_AddString(jsonItem, "linkName", linkName);
parcJSON_AddInteger(jsonItem, "index", index);
parcJSON_AddBoolean(jsonItem, "notLocal", notLocal);
parcJSON_AddBoolean(jsonItem, "localForced", localForced);
PARCJSONValue *jsonItemValue = parcJSONValue_CreateFromJSON(jsonItem);
parcJSON_Release(&jsonItem);
parcJSONArray_AddValue(jsonLinkList, jsonItemValue);
parcJSONValue_Release(&jsonItemValue);
if (notLocal) {
parcLog_Debug(athenaTransportLinkAdapter->log, "\n Link instance [%d] %s: %s", index, localForced ? "(forced remote)" : "(remote)", linkName);
} else {
parcLog_Debug(athenaTransportLinkAdapter->log, "\n Link instance [%d] %s: %s", index, localForced ? "(forced local)" : "(local)", linkName);
}
}
}
char *jsonString = parcJSONArray_ToString(jsonLinkList);
parcJSONArray_Release(&jsonLinkList);
PARCBuffer *payload = parcBuffer_CreateFromArray(jsonString, strlen(jsonString));
CCNxContentObject *contentObject =
ccnxContentObject_CreateWithNameAndPayload(ccnxName, parcBuffer_Flip(payload));
struct timeval tv;
gettimeofday(&tv, NULL);
uint64_t nowInMillis = (tv.tv_sec * 1000) + (tv.tv_usec / 1000);
ccnxContentObject_SetExpiryTime(contentObject, nowInMillis + 100); // this response is good for 100 millis
CCNxMetaMessage *result = ccnxMetaMessage_CreateFromContentObject(contentObject);
ccnxContentObject_Release(&contentObject);
parcBuffer_Release(&payload);
parcMemory_Deallocate(&jsonString);
athena_EncodeMessage(result);
return result;
}
LONGBOW_TEST_CASE(Global, athena_ProcessInterest)
{
PARCURI *connectionURI;
Athena *athena = athena_Create(100);
CCNxName *name = ccnxName_CreateFromCString("lci:/foo/bar/baz");
CCNxInterest *interest = ccnxInterest_CreateSimple(name);
uint64_t chunkNum = 0;
CCNxNameSegment *chunkSegment = ccnxNameSegmentNumber_Create(CCNxNameLabelType_CHUNK, chunkNum);
ccnxName_Append(name, chunkSegment);
ccnxNameSegment_Release(&chunkSegment);
PARCBuffer *payload = parcBuffer_WrapCString("this is a payload");
CCNxContentObject *contentObject = ccnxContentObject_CreateWithNameAndPayload(name, payload);
parcBuffer_Release(&payload);
struct timeval tv;
gettimeofday(&tv, NULL);
uint64_t nowInMillis = (tv.tv_sec * 1000) + (tv.tv_usec / 1000);
ccnxContentObject_SetExpiryTime(contentObject, nowInMillis + 100000); // expire in 100 seconds
connectionURI = parcURI_Parse("tcp://localhost:50100/listener/name=TCPListener");
const char *result = athenaTransportLinkAdapter_Open(athena->athenaTransportLinkAdapter, connectionURI);
assertTrue(result != NULL, "athenaTransportLinkAdapter_Open failed(%s)", strerror(errno));
parcURI_Release(&connectionURI);
connectionURI = parcURI_Parse("tcp://localhost:50100/name=TCP_0/local=false");
result = athenaTransportLinkAdapter_Open(athena->athenaTransportLinkAdapter, connectionURI);
assertTrue(result != NULL, "athenaTransportLinkAdapter_Open failed (%s)", strerror(errno));
parcURI_Release(&connectionURI);
connectionURI = parcURI_Parse("tcp://localhost:50100/name=TCP_1/local=false");
result = athenaTransportLinkAdapter_Open(athena->athenaTransportLinkAdapter, connectionURI);
assertTrue(result != NULL, "athenaTransportLinkAdapter_Open failed (%s)", strerror(errno));
parcURI_Release(&connectionURI);
int linkId = athenaTransportLinkAdapter_LinkNameToId(athena->athenaTransportLinkAdapter, "TCP_0");
PARCBitVector *interestIngressVector = parcBitVector_Create();
parcBitVector_Set(interestIngressVector, linkId);
linkId = athenaTransportLinkAdapter_LinkNameToId(athena->athenaTransportLinkAdapter, "TCP_1");
PARCBitVector *contentObjectIngressVector = parcBitVector_Create();
parcBitVector_Set(contentObjectIngressVector, linkId);
athena_EncodeMessage(interest);
athena_EncodeMessage(contentObject);
// Before FIB entry interest should not be forwarded
athena_ProcessMessage(athena, interest, interestIngressVector);
// Add route for interest, it should now be forwarded
athenaFIB_AddRoute(athena->athenaFIB, name, contentObjectIngressVector);
CCNxName *defaultName = ccnxName_CreateFromCString("lci:/");
athenaFIB_AddRoute(athena->athenaFIB, defaultName, contentObjectIngressVector);
ccnxName_Release(&defaultName);
// Process exact interest match
athena_ProcessMessage(athena, interest, interestIngressVector);
// Process a super-interest match
CCNxName *superName = ccnxName_CreateFromCString("lci:/foo/bar/baz/unmatched");
CCNxInterest *superInterest = ccnxInterest_CreateSimple(superName);
athena_EncodeMessage(superInterest);
athena_ProcessMessage(athena, superInterest, interestIngressVector);
ccnxName_Release(&superName);
ccnxInterest_Release(&superInterest);
// Process no-match/default route interest
CCNxName *noMatchName = ccnxName_CreateFromCString("lci:/buggs/bunny");
CCNxInterest *noMatchInterest = ccnxInterest_CreateSimple(noMatchName);
athena_EncodeMessage(noMatchInterest);
athena_ProcessMessage(athena, noMatchInterest, interestIngressVector);
ccnxName_Release(&noMatchName);
ccnxInterest_Release(&noMatchInterest);
// Create a matching content object that the store should retain and reply to the following interest with
athena_ProcessMessage(athena, contentObject, contentObjectIngressVector);
athena_ProcessMessage(athena, interest, interestIngressVector);
parcBitVector_Release(&interestIngressVector);
parcBitVector_Release(&contentObjectIngressVector);
ccnxName_Release(&name);
ccnxInterest_Release(&interest);
ccnxInterest_Release(&contentObject);
athena_Release(&athena);
}
