LONGBOW_TEST_CASE(Global, athenaFIB_CreateEntryList)
{
TestData *data = longBowTestCase_GetClipBoardData(testCase);
athenaFIB_AddRoute(data->testFIB, data->testName1, data->testVector12);
PARCBitVector *result = athenaFIB_Lookup(data->testFIB, data->testName1, NULL);
assertTrue(parcBitVector_Equals(result, data->testVector12), "Expected lookup to equal test vector");
parcBitVector_Release(&result);
PARCList *entryList = athenaFIB_CreateEntryList(data->testFIB);
assertTrue(parcList_Size(entryList) == 2, "Expected the EntryList to have 2 elements");
AthenaFIBListEntry *entry = parcList_GetAtIndex(entryList, 0);
assertNotNull(entry, "Expect entry at 0 to be non-NULL");
assertTrue(ccnxName_Equals(data->testName1, entry->name), "Expect the name at 0 to be testName1");
assertTrue(entry->linkId == 0, "Expect the routeId at 0 to be 0");
entry = parcList_GetAtIndex(entryList, 1);
assertNotNull(entry, "Expect entry at 1 to be non-NULL");
assertTrue(ccnxName_Equals(data->testName1, entry->name), "Expect the name at 1 to be testName1");
assertTrue(entry->linkId == 42, "Expect the routeId at 0 to be 42");
parcList_Release(&entryList);
}
int
reader_writer(CCNxPortalFactory *factory, const char *uri)
{
CCNxPortal *portal = ccnxPortalFactory_GetInstance(factory, ccnxPortalTypeDatagram, ccnxPortalProtocol_TLV, &ccnxPortalAttributes_Blocking);
CCNxName *prefix = ccnxName_CreateFromURI(uri);
CCNxName *bye = ccnxName_CreateFromURI("lci:/Hello/Goodbye%21");
CCNxName *contentname = ccnxName_CreateFromURI("lci:/Hello/World");
if (ccnxPortal_Listen(portal, prefix, 365 * 86400, CCNxStackTimeout_Never)) {
CCNxMetaMessage *msg;
while ((msg = ccnxPortal_Receive(portal, CCNxStackTimeout_Never)) != NULL) {
if (ccnxMetaMessage_IsInterest(msg)) {
CCNxInterest *interest = ccnxMetaMessage_GetInterest(msg);
CCNxName *interestName = ccnxInterest_GetName(interest);
if (ccnxName_Equals(interestName, contentname)) {
const PARCKeyId *publisherKeyId = ccnxPortal_GetKeyId(portal);
char buffer[128];
time_t theTime = time(0);
sprintf(buffer, "Hello World. The time is %s", ctime(&theTime));
PARCBuffer *payload = parcBuffer_CreateFromArray(buffer, 128);
parcBuffer_Flip(payload);
PARCBuffer *b = parcBuffer_Acquire(payload);
CCNxContentObject *uob = ccnxContentObject_CreateWithDataPayload(contentname, b);
// missing NULL check, case 1024
CCNxMetaMessage *message = ccnxMetaMessage_CreateFromContentObject(uob);
if (ccnxPortal_Send(portal, message, CCNxTransportStackTimeCCNxStackTimeout_Neverout_Never) == false) {
fprintf(stderr, "ccnx_write failed\n");
}
// ccnxMessage_Release(message);
} else if (ccnxName_Equals(interestName, bye)) {
break;
}
} else {
ccnxMetaMessage_Display(msg, 0);
}
ccnxMetaMessage_Release(&msg);
}
}
ccnxName_Release(&prefix);
ccnxName_Release(&bye);
ccnxName_Release(&contentname);
ccnxPortal_Release(&portal);
return 0;
}
bool
ccnxManifestHashGroup_Equals(const CCNxManifestHashGroup *objectA, const CCNxManifestHashGroup *objectB)
{
if (objectA == objectB) {
return true;
}
if (objectA == NULL || objectB == NULL) {
return false;
}
if (objectA->dataSize == objectB->dataSize) {
if (objectA->entrySize == objectB->entrySize) {
if (objectA->blockSize == objectB->blockSize) {
if (objectA->treeHeight == objectB->treeHeight) {
if (ccnxName_Equals(objectA->locator, objectB->locator)) {
if (parcBuffer_Equals(objectA->overallDataDigest, objectB->overallDataDigest)) {
if (parcLinkedList_Size(objectA->pointers) == parcLinkedList_Size(objectB->pointers)) {
for (size_t i = 0; i < parcLinkedList_Size(objectA->pointers); i++) {
CCNxManifestHashGroupPointer *ptrA = parcLinkedList_GetAtIndex(objectA->pointers, i);
CCNxManifestHashGroupPointer *ptrB = parcLinkedList_GetAtIndex(objectB->pointers, i);
if (!_CCNxManifestHashGroupPointer_Equals(ptrA, ptrB)) {
return false;
}
}
return true;
}
}
}
}
}
}
}
return false;
}
LONGBOW_TEST_CASE(Global, ccnxInterest_SetGetPayload)
{
CCNxName *name = ccnxName_CreateFromURI("lci:/name");
CCNxInterest *interest = ccnxInterest_CreateSimple(name);
CCNxName *origNameCopy = ccnxName_Copy(name);
CCNxInterestInterface *impl = ccnxInterestInterface_GetInterface(interest);
if (impl->getPayload) {
assertNull(ccnxInterest_GetPayload(interest), "Expected a NULL payload");
}
if (impl->getPayload && impl->setPayload) {
PARCBuffer *payload = parcBuffer_WrapCString("impls have pimples");
ccnxInterest_SetPayload(interest, payload);
PARCBuffer *payloadOut = ccnxInterest_GetPayload(interest);
assertTrue(parcBuffer_Equals(payload, payloadOut), "Expected an equal buffer");
CCNxName *nameAfterPayload = ccnxInterest_GetName(interest);
assertTrue(ccnxName_Equals(nameAfterPayload, origNameCopy), "Expected an unmodified name");
parcBuffer_Release(&payload);
}
ccnxName_Release(&name);
ccnxName_Release(&origNameCopy);
ccnxInterest_Release(&interest);
}
void
testValidationSetV1_KeyId_KeyLocator_KeyId_KeyName(TestData *data,
bool (*set)(CCNxTlvDictionary *message, const PARCBuffer *keyid,
const CCNxKeyLocator *keyLocator),
bool (*test)(const CCNxTlvDictionary *message))
{
CCNxName *name = ccnxName_CreateFromURI("lci:/parc/validation/test");
CCNxTlvDictionary *packetV1 = ccnxContentObject_CreateWithImplAndPayload(&CCNxContentObjectFacadeV1_Implementation,
name,
CCNxPayloadType_DATA,
NULL);
bool success = set(packetV1, data->keyid, data->locatorByName);
assertTrue(success, "Failed to set on V1");
bool testResult = test(packetV1);
assertTrue(testResult, "Test function failed on V1 packet");
PARCBuffer *testKeyId = ccnxValidationFacadeV1_GetKeyId(packetV1);
assertTrue(parcBuffer_Equals(testKeyId, data->keyid), "keyid not equal");
// XXX: TODO: GetKeyName() returns a Link, so it should be GetLink().
// It also creates a new object (the CCNxLink), so... needs thinking about.
// See BugzId: 3322
CCNxLink *testLink = ccnxValidationFacadeV1_GetKeyName(packetV1);
assertTrue(ccnxName_Equals(ccnxLink_GetName(testLink), data->keyname), "Keynames not equal");
ccnxLink_Release(&testLink);
ccnxName_Release(&name);
ccnxTlvDictionary_Release(&packetV1);
}
LONGBOW_TEST_CASE(Global, ccnxInterest_GetName)
{
CCNxName *name = ccnxName_CreateFromURI("lci:/name");
CCNxInterest *interest = ccnxInterest_CreateSimple(name);
CCNxName *actual = ccnxInterest_GetName(interest);
assertTrue(ccnxName_Equals(name, actual), "Expected the same name.");
ccnxName_Release(&name);
ccnxInterest_Release(&interest);
}
LONGBOW_TEST_CASE(Global, ccnxKeyLocator_GetKeyName)
{
CCNxName *keyURIName = ccnxName_CreateFromCString("lci://name/test");
CCNxLink *keyLink = ccnxLink_Create(keyURIName, NULL, NULL);
CCNxKeyLocator *keyLocator = ccnxKeyLocator_CreateFromKeyLink(keyLink);
ccnxKeyLocator_AssertValid(keyLocator);
const CCNxName *actual = ccnxLink_GetName(ccnxKeyLocator_GetKeyLink(keyLocator));
assertTrue(ccnxName_Equals(actual, keyURIName), "Actual keyName did not match the one returned by GetKeyName()");
ccnxKeyLocator_Release(&keyLocator);
ccnxName_Release(&keyURIName);
ccnxLink_Release(&keyLink);
}
LONGBOW_TEST_CASE(Global, cpiCancelFlow_NameFromControlMessage)
{
CCNxName *name = ccnxName_CreateFromURI("lci:/who/doesnt/like/pie");
PARCJSON *cpiRequest = cpiCancelFlow_CreateRequest(name);
CCNxControl *controlRequest = ccnxControl_CreateCPIRequest(cpiRequest);
CCNxName *test_name = cpiCancelFlow_NameFromControlMessage(controlRequest);
assertTrue(ccnxName_Equals(test_name, name),
"Expected %s actual %s",
ccnxName_ToString(name),
ccnxName_ToString(test_name));
ccnxName_Release(&test_name);
ccnxControl_Release(&controlRequest);
parcJSON_Release(&cpiRequest);
ccnxName_Release(&name);
}
LONGBOW_TEST_CASE(Global, ccnxLink_GetName)
{
CCNxName *name = ccnxName_CreateFromCString("lci:/foo/bar/name");
PARCBuffer *keyId = parcBuffer_Allocate(10);
PARCBuffer *contentObjectHash = parcBuffer_Allocate(10);
CCNxLink *object = ccnxLink_Create(name, keyId, contentObjectHash);
const CCNxName *actualName = ccnxLink_GetName(object);
assertNotNull(actualName, "Expected non-null return value.");
assertTrue(ccnxName_Equals(name, actualName), "Expected the same name back");
ccnxLink_Release(&object);
ccnxName_Release(&name);
parcBuffer_Release(&keyId);
parcBuffer_Release(&contentObjectHash);
}
bool
ccnxPortalAnchor_Equals(const CCNxPortalAnchor *x, const CCNxPortalAnchor *y)
{
bool result = false;
if (x == y) {
result = true;
} else if (x == NULL || y == NULL) {
result = false;
} else {
if (ccnxName_Equals(x->prefix, y->prefix)) {
if (x->expireTime == y->expireTime) {
result = true;
}
}
}
return result;
}
LONGBOW_TEST_CASE(Global, ccnxTlvCodecName_Decode_RightType)
{
PARCBuffer *buffer = parcBuffer_WrapCString("brandywine");
CCNxNameSegment *segment = ccnxNameSegment_CreateTypeValue(CCNxNameLabelType_NAME, buffer);
CCNxName *truth = ccnxName_Append(ccnxName_Create(), segment);
ccnxNameSegment_Release(&segment);
parcBuffer_Release(&buffer);
uint8_t decodeBytes[] = { 0x10, 0x20, 0x00, 0x0E, 0x00, CCNxNameLabelType_NAME, 0x00, 0x0A, 'b', 'r', 'a', 'n', 'd', 'y', 'w', 'i', 'n', 'e' };
PARCBuffer *decodeBuffer = parcBuffer_Wrap(decodeBytes, sizeof(decodeBytes), 0, sizeof(decodeBytes));
CCNxCodecTlvDecoder *decoder = ccnxCodecTlvDecoder_Create(decodeBuffer);
CCNxName *test = ccnxCodecSchemaV1NameCodec_Decode(decoder, 0x1020);
assertTrue(ccnxName_Equals(truth, test), "Name segments do not match");
ccnxName_Release(&test);
ccnxCodecTlvDecoder_Destroy(&decoder);
parcBuffer_Release(&decodeBuffer);
ccnxName_Release(&truth);
}
LONGBOW_TEST_CASE(Global, ccnxCodecSchemaV1ManifestDecoder_DecodeHashGroupMetadata)
{
// Re-build the expected metadata from the manifest
CCNxName *groupLocator = ccnxName_CreateFromCString("ccnx:/locator");
PARCBuffer *digest = parcBuffer_Allocate(16);
for (size_t i = 0; i < parcBuffer_Limit(digest); i++) {
parcBuffer_PutUint8(digest, 0);
}
parcBuffer_Flip(digest);
size_t entrySize = 1;
size_t dataSize = 2;
size_t blockSize = 3;
size_t treeHeight = 4;
// Compute the expected size of this metadata group.
size_t metadataSize = 4 * (4 + 8) + 4 + parcBuffer_Limit(digest) + 4 + strlen("ccnx:/locator");
// See test_ccnxCodecSchemaV1_ManifestEncoder.c for the packet construction details.
uint8_t rawMetadata[89] = { 0x00, CCNxCodecSchemaV1Types_CCNxManifestHashGroup_Metadata,
0x00, metadataSize,
0x00, CCNxCodecSchemaV1Types_CCNxManifestHashGroupMetadata_Locator,
0x00, strlen("ccnx:/locator"),
'c', 'c',
'n', 'x',
':', '/',
'l', 'o',
'c', 'a',
't', 'o',
'r',
0x00, CCNxCodecSchemaV1Types_CCNxManifestHashGroupMetadata_DataSize,
0x00, 0x08,
0x00, 0x00,
0x00, 0x00,
0x00, 0x00,
0x00, dataSize,
0x00, CCNxCodecSchemaV1Types_CCNxManifestHashGroupMetadata_BlockSize,
0x00, 0x08,
0x00, 0x00,
0x00, 0x00,
0x00, 0x00,
0x00, blockSize,
0x00, CCNxCodecSchemaV1Types_CCNxManifestHashGroupMetadata_EntrySize,
0x00, 0x08,
0x00, 0x00,
0x00, 0x00,
0x00, 0x00,
0x00, entrySize,
0x00, CCNxCodecSchemaV1Types_CCNxManifestHashGroupMetadata_TreeHeight,
0x00, 0x08,
0x00, 0x00,
0x00, 0x00,
0x00, 0x00,
0x00, treeHeight,
0x00, CCNxCodecSchemaV1Types_CCNxManifestHashGroupMetadata_OverallDataSha256,
0x00, parcBuffer_Remaining(digest),
0x00, 0x00,
0x00, 0x00,
0x00, 0x00,
0x00, 0x00,
0x00, 0x00,
0x00, 0x00,
0x00, 0x00,
0x00, 0x00 };
PARCBuffer *wireFormat = parcBuffer_Flip(parcBuffer_CreateFromArray(rawMetadata, sizeof(rawMetadata)));
// Create the encoder and swallow the top level container
CCNxCodecTlvDecoder *decoder = ccnxCodecTlvDecoder_Create(wireFormat);
ccnxCodecTlvDecoder_GetType(decoder); // swallow type
uint16_t length = ccnxCodecTlvDecoder_GetLength(decoder);
// Decode the metadata
CCNxManifestHashGroup *group = ccnxManifestHashGroup_Create();
bool result = _decodeHashGroupMetadata(decoder, group, length);
assertTrue(result, "Expected hash group metadata to be decoded correctly.");
const CCNxName *actualLocator = ccnxManifestHashGroup_GetLocator(group);
size_t actualEntrySize = ccnxManifestHashGroup_GetEntrySize(group);
size_t actualDataSize = ccnxManifestHashGroup_GetDataSize(group);
size_t actualBlockSize = ccnxManifestHashGroup_GetBlockSize(group);
size_t actualTreeHeight = ccnxManifestHashGroup_GetTreeHeight(group);
const PARCBuffer *actualDigest = ccnxManifestHashGroup_GetOverallDataDigest(group);
assertTrue(ccnxName_Equals(groupLocator, actualLocator), "Expected decoded locator to equal %s, got %s", ccnxName_ToString(groupLocator), ccnxName_ToString(actualLocator));
assertTrue(entrySize == actualEntrySize, "Expected %zu entry size, got %zu", entrySize, actualEntrySize);
assertTrue(dataSize == actualDataSize, "Expected %zu data size, got %zu", dataSize, actualDataSize);
assertTrue(blockSize == actualBlockSize, "Expected %zu block size, got %zu", blockSize, actualBlockSize);
assertTrue(treeHeight == actualTreeHeight, "Expected %zu tree height, got %zu", treeHeight, actualTreeHeight);
assertTrue(parcBuffer_Equals(digest, actualDigest), "Expected %s digest, got %s", parcBuffer_ToHexString(digest), parcBuffer_ToHexString(actualDigest));
parcBuffer_Release(&digest);
ccnxName_Release(&groupLocator);
ccnxManifestHashGroup_Release(&group);
ccnxCodecTlvDecoder_Destroy(&decoder);
parcBuffer_Release(&wireFormat);
}
