LONGBOW_TEST_CASE(CreateAcquireRelease, CreateCompare)
{
PARCSortedList *instance = parcSortedList_CreateCompare(_compareTwoBuffersByLength);
PARCBuffer *buf1 = parcBuffer_WrapCString("medium long");
PARCBuffer *buf2 = parcBuffer_WrapCString("somewhat longer");
PARCBuffer *buf3 = parcBuffer_WrapCString("short");
parcSortedList_Add(instance, buf1);
parcSortedList_Add(instance, buf2);
parcSortedList_Add(instance, buf3);
PARCBuffer *test = parcSortedList_GetAtIndex(instance, 0);
assertTrue(test == buf3, "Expected the shortes buffer first");
test = parcSortedList_GetAtIndex(instance, 1);
assertTrue(test == buf1, "Expected the medium length buffer second");
test = parcSortedList_GetAtIndex(instance, 2);
assertTrue(test == buf2, "Expected the longest buffer last");
parcBuffer_Release(&buf1);
parcBuffer_Release(&buf2);
parcBuffer_Release(&buf3);
parcSortedList_Release(&instance);
}
LONGBOW_TEST_CASE(Global, ccnxContentObject_GetKeyId)
{
CCNxName *name = ccnxName_CreateFromCString("lci:/hello/dolly");
PARCBuffer *payload = parcBuffer_WrapCString("hello");
CCNxContentObject *contentObject = ccnxContentObject_CreateWithDataPayload(name, payload);
assertNull(ccnxContentObject_GetKeyId(contentObject), "Expect NULL for KeyId here");
PARCBuffer *testKeyId = parcBuffer_WrapCString("keyhash");
PARCBuffer *sigbits = parcBuffer_WrapCString("siggybits");
PARCSignature *signature = parcSignature_Create(PARCSigningAlgorithm_RSA, PARC_HASH_SHA256, parcBuffer_Flip(sigbits));
ccnxContentObject_SetSignature(contentObject, testKeyId, signature, NULL);
PARCBuffer *keyId = ccnxContentObject_GetKeyId(contentObject);
assertTrue(parcBuffer_Equals(keyId, testKeyId), "Expect key ids to match");
parcBuffer_Release(&payload);
parcBuffer_Release(&sigbits);
parcBuffer_Release(&keyId);
parcSignature_Release(&signature);
ccnxName_Release(&name);
ccnxContentObject_Release(&contentObject);
}
/**
* Create and return a CCNxInterest whose Name contains our commend (e.g. "fetch" or "list"),
* and, optionally, the name of a target object (e.g. "file.txt"). The newly created CCNxInterest
* must eventually be released by calling ccnxInterest_Release().
*
* @param command The command to embed in the created CCNxInterest.
* @param targetName The name of the content, if any, that the command applies to.
*
* @return A newly created CCNxInterest for the specified command and targetName.
*/
static CCNxInterest *
_createInterest(const char *command, const char *targetName)
{
CCNxName *interestName = ccnxName_CreateFromURI(tutorialCommon_DomainPrefix); // Start with the prefix. We append to this.
// Create a NameSegment for our command, which we will append after the prefix we just created.
PARCBuffer *commandBuffer = parcBuffer_WrapCString((char *) command);
CCNxNameSegment *commandSegment = ccnxNameSegment_CreateTypeValue(CCNxNameLabelType_NAME, commandBuffer);
parcBuffer_Release(&commandBuffer);
// Append the new command segment to the prefix
ccnxName_Append(interestName, commandSegment);
ccnxNameSegment_Release(&commandSegment);
// If we have a target, then create another NameSegment for it and append that.
if (targetName != NULL) {
// Create a NameSegment for our target object
PARCBuffer *targetBuf = parcBuffer_WrapCString((char *) targetName);
CCNxNameSegment *targetSegment = ccnxNameSegment_CreateTypeValue(CCNxNameLabelType_NAME, targetBuf);
parcBuffer_Release(&targetBuf);
// Append it to the ccnxName.
ccnxName_Append(interestName, targetSegment);
ccnxNameSegment_Release(&targetSegment);
}
CCNxInterest *result = ccnxInterest_CreateSimple(interestName);
ccnxName_Release(&interestName);
return result;
}
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(Specialization, parcSortedList_GetLast)
{
PARCSortedList *instance = parcSortedList_Create();
PARCBuffer *element1 = parcBuffer_WrapCString("1");
PARCBuffer *element2 = parcBuffer_WrapCString("2");
PARCBuffer *element3 = parcBuffer_WrapCString("3");
PARCBuffer *element4 = parcBuffer_WrapCString("4");
PARCBuffer *element7 = parcBuffer_WrapCString("7");
PARCBuffer *element6 = parcBuffer_WrapCString("6");
PARCBuffer *element5 = parcBuffer_WrapCString("5");
PARCBuffer *element8 = parcBuffer_WrapCString("8");
parcSortedList_Add(instance, element1);
parcSortedList_Add(instance, element2);
parcSortedList_Add(instance, element3);
PARCBuffer *actual = (PARCBuffer *) parcSortedList_GetLast(instance);
assertTrue(parcBuffer_Equals(element3, actual), "Got the wrong value at index 1");
parcBuffer_Release(&element1);
parcBuffer_Release(&element2);
parcBuffer_Release(&element3);
parcBuffer_Release(&element4);
parcBuffer_Release(&element5);
parcBuffer_Release(&element6);
parcBuffer_Release(&element7);
parcBuffer_Release(&element8);
parcSortedList_Release(&instance);
}
LONGBOW_TEST_CASE(Specialization, parcSortedList_Remove)
{
PARCSortedList *instance = parcSortedList_Create();
PARCBuffer *element1 = parcBuffer_WrapCString("1");
PARCBuffer *element2 = parcBuffer_WrapCString("2");
PARCBuffer *element3 = parcBuffer_WrapCString("3");
PARCBuffer *element4 = parcBuffer_WrapCString("4");
PARCBuffer *element7 = parcBuffer_WrapCString("7");
PARCBuffer *element6 = parcBuffer_WrapCString("6");
PARCBuffer *element5 = parcBuffer_WrapCString("5");
PARCBuffer *element8 = parcBuffer_WrapCString("8");
parcSortedList_Add(instance, element1);
parcSortedList_Add(instance, element2);
parcSortedList_Add(instance, element3);
parcSortedList_Display(instance, 0);
parcSortedList_Remove(instance, element2);
assertTrue(parcSortedList_Size(instance) == 2, "Expected list to be 2 in size");
parcBuffer_Release(&element1);
parcBuffer_Release(&element2);
parcBuffer_Release(&element3);
parcBuffer_Release(&element4);
parcBuffer_Release(&element5);
parcBuffer_Release(&element6);
parcBuffer_Release(&element7);
parcBuffer_Release(&element8);
parcSortedList_Release(&instance);
}
LONGBOW_TEST_CASE(JSON, parcJSON_GetPairByIndex)
{
TestData *data = longBowTestCase_GetClipBoardData(testCase);
PARCJSONPair *pair = parcJSON_GetPairByIndex(data->json, 0);
PARCBuffer *name = parcJSONPair_GetName(pair);
PARCBuffer *expectedName = parcBuffer_WrapCString("string");
assertTrue(parcBuffer_Equals(expectedName, name),
"Expected 'string', actual '%s'", (char *) parcBuffer_ToString(name));
parcBuffer_Release(&expectedName);
pair = parcJSON_GetPairByIndex(data->json, 1);
name = parcJSONPair_GetName(pair);
expectedName = parcBuffer_WrapCString("null");
assertTrue(parcBuffer_Equals(expectedName, name),
"Expected 'null', actual '%s'", (char *) parcBuffer_ToString(name));
parcBuffer_Release(&expectedName);
pair = parcJSON_GetPairByIndex(data->json, 2);
name = parcJSONPair_GetName(pair);
expectedName = parcBuffer_WrapCString("true");
assertTrue(parcBuffer_Equals(expectedName, name),
"Expected 'true', actual '%s'", (char *) parcBuffer_ToString(name));
parcBuffer_Release(&expectedName);
pair = parcJSON_GetPairByIndex(data->json, 3);
name = parcJSONPair_GetName(pair);
expectedName = parcBuffer_WrapCString("false");
assertTrue(parcBuffer_Equals(expectedName, name),
"Expected 'false', actual '%s'", (char *) parcBuffer_ToString(name));
parcBuffer_Release(&expectedName);
pair = parcJSON_GetPairByIndex(data->json, 4);
name = parcJSONPair_GetName(pair);
expectedName = parcBuffer_WrapCString("integer");
assertTrue(parcBuffer_Equals(expectedName, name),
"Expected 'integer', actual '%s'", (char *) parcBuffer_ToString(name));
parcBuffer_Release(&expectedName);
pair = parcJSON_GetPairByIndex(data->json, 5);
name = parcJSONPair_GetName(pair);
expectedName = parcBuffer_WrapCString("float");
assertTrue(parcBuffer_Equals(expectedName, name),
"Expected 'float', actual '%s'", (char *) parcBuffer_ToString(name));
parcBuffer_Release(&expectedName);
pair = parcJSON_GetPairByIndex(data->json, 6);
name = parcJSONPair_GetName(pair);
expectedName = parcBuffer_WrapCString("json");
assertTrue(parcBuffer_Equals(expectedName, name),
"Expected 'json', actual '%s'", (char *) parcBuffer_ToString(name));
parcBuffer_Release(&expectedName);
pair = parcJSON_GetPairByIndex(data->json, 7);
name = parcJSONPair_GetName(pair);
expectedName = parcBuffer_WrapCString("array");
assertTrue(parcBuffer_Equals(expectedName, name),
"Expected 'array', actual '%s'", (char *) parcBuffer_ToString(name));
parcBuffer_Release(&expectedName);
}
LONGBOW_TEST_CASE(Global, ccnxKeyLocator_GetType)
{
// Try FromKey
char *hexString = "ABCDEF1234";
PARCBuffer *keyBuffer = parcBuffer_WrapCString(hexString);
PARCKeyId *keyId = parcKeyId_Create(keyBuffer);
PARCKey *key = parcKey_CreateFromDerEncodedPublicKey(keyId, PARCSigningAlgorithm_RSA, keyBuffer);
CCNxKeyLocator *keyLocator = ccnxKeyLocator_CreateFromKey(key);
parcKeyId_Release(&keyId);
parcBuffer_Release(&keyBuffer);
ccnxKeyLocator_AssertValid(keyLocator);
assertTrue(ccnxKeyLocator_GetType(keyLocator) == CCNxKeyLocatorType_Key, "Actual certificate type didn't match expected type");
ccnxKeyLocator_Release(&keyLocator);
parcKey_Release(&key);
// Try KeyName
CCNxName *keyURIName = ccnxName_CreateFromCString("lci://name/test");
CCNxLink *keyLink = ccnxLink_Create(keyURIName, NULL, NULL);
keyLocator = ccnxKeyLocator_CreateFromKeyLink(keyLink);
ccnxKeyLocator_AssertValid(keyLocator);
assertTrue(ccnxKeyLocator_GetType(keyLocator) == CCNxKeyLocatorType_Link, "Actual certificate type didn't match expected type");
assertFalse(ccnxKeyLocator_GetType(keyLocator) == CCNxKeyLocatorType_Key, "Actual certificate type didn't match expected type");
ccnxKeyLocator_Release(&keyLocator);
ccnxName_Release(&keyURIName);
ccnxLink_Release(&keyLink);
}
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);
}
LONGBOW_TEST_CASE(Global, ccnxTlvCodecName_Encode)
{
uint8_t truthBytes[] = { 0x10, 0x20, 0x00, 0x0E, 0x00, CCNxNameLabelType_NAME, 0x00, 0x0A, 'b', 'r', 'a', 'n', 'd', 'y', 'w', 'i', 'n', 'e' };
PARCBuffer *truth = parcBuffer_Wrap(truthBytes, sizeof(truthBytes), 0, sizeof(truthBytes));
CCNxCodecTlvEncoder *encoder = ccnxCodecTlvEncoder_Create();
ccnxCodecTlvEncoder_Initialize(encoder);
PARCBuffer *buffer = parcBuffer_WrapCString("brandywine");
CCNxNameSegment *segment = ccnxNameSegment_CreateTypeValue(CCNxNameLabelType_NAME, buffer);
CCNxName *name = ccnxName_Append(ccnxName_Create(), segment);
ccnxNameSegment_Release(&segment);
parcBuffer_Release(&buffer);
ccnxCodecSchemaV1NameCodec_Encode(encoder, 0x1020, name);
ccnxCodecTlvEncoder_Finalize(encoder);
PARCBuffer *test = ccnxCodecTlvEncoder_CreateBuffer(encoder);
if (!parcBuffer_Equals(truth, test)) {
printf("Buffers do not match\n");
printf("Excpected:\n");
parcBuffer_Display(truth, 3);
printf("Got:\n");
parcBuffer_Display(test, 3);
assertTrue(parcBuffer_Equals(truth, test), "Buffers do not match");
}
ccnxName_Release(&name);
parcBuffer_Release(&test);
ccnxCodecTlvEncoder_Destroy(&encoder);
parcBuffer_Release(&truth);
}
LONGBOW_TEST_CASE(Global, ccnxKeyLocator_Copy)
{
CCNxName *keyURIName = ccnxName_CreateFromCString("lci://name");
CCNxLink *keyLink = ccnxLink_Create(keyURIName, NULL, NULL);
CCNxKeyLocator *keyLocator = ccnxKeyLocator_CreateFromKeyLink(keyLink);
ccnxKeyLocator_AssertValid(keyLocator);
CCNxKeyLocator *copy = ccnxKeyLocator_Copy(keyLocator);
assertTrue(ccnxKeyLocator_Equals(copy, keyLocator), "Expected orig and copy to be the same");
ccnxKeyLocator_Release(&keyLocator);
ccnxKeyLocator_Release(©);
ccnxName_Release(&keyURIName);
ccnxLink_Release(&keyLink);
// Try FromHexString, too, for yucks.
PARCBuffer *keyBuffer = parcBuffer_WrapCString("hello world");
PARCKeyId *keyId = parcKeyId_Create(keyBuffer);
PARCKey *key = parcKey_CreateFromDerEncodedPublicKey(keyId, PARCSigningAlgorithm_RSA, keyBuffer);
parcKeyId_Release(&keyId);
parcBuffer_Release(&keyBuffer);
CCNxKeyLocator *keyLocator2 = ccnxKeyLocator_CreateFromKey(key);
CCNxKeyLocator *copy2 = ccnxKeyLocator_Copy(keyLocator2);
assertTrue(ccnxKeyLocator_Equals(copy, keyLocator), "Expected orig and copy to be the same");
parcKey_Release(&key);
ccnxKeyLocator_Release(&keyLocator2);
ccnxKeyLocator_Release(©2);
}
LONGBOW_TEST_CASE(Global, ccnxInterest_SetPayloadAndId)
{
CCNxName *name = ccnxName_CreateFromURI("lci:/name");
CCNxInterest *interest = ccnxInterest_CreateSimple(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_SetPayloadAndId(interest, payload);
PARCBuffer *payloadOut = ccnxInterest_GetPayload(interest);
assertTrue(parcBuffer_Equals(payload, payloadOut), "Expected an equal buffer");
CCNxName *nameAfterPayload = ccnxInterest_GetName(interest);
CCNxNameSegment *segment = ccnxName_GetSegment(nameAfterPayload, ccnxName_GetSegmentCount(nameAfterPayload) - 1);
assertTrue(ccnxNameSegment_GetType(segment) == CCNxNameLabelType_PAYLOADID, "Expected to find a payload ID appended to the name");
parcBuffer_Release(&payload);
}
ccnxName_Release(&name);
ccnxInterest_Release(&interest);
}
static PARCSignature *
_SignDigest(PARCSigner *interfaceContext)
{
PARCBuffer *buffer = parcBuffer_WrapCString(FAKE_SIGNATURE);
PARCSignature *signature = parcSignature_Create(PARCSigningAlgorithm_RSA, PARCCryptoHashType_SHA256, buffer);
parcBuffer_Release(&buffer);
return signature;
}
LONGBOW_TEST_CASE(Global, ccnxInterest_SetPayloadWithId)
{
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");
PARCBuffer *payloadIdBuffer = parcBuffer_WrapCString("payload Id buffer");
CCNxInterestPayloadId *payloadId = ccnxInterestPayloadId_Create(payloadIdBuffer,
CCNxInterestPayloadId_TypeCode_App + 2);
ccnxInterest_SetPayloadWithId(interest, payload, payloadId);
PARCBuffer *payloadOut = ccnxInterest_GetPayload(interest);
assertTrue(parcBuffer_Equals(payload, payloadOut), "Expected an equal buffer");
CCNxName *nameAfterPayload = ccnxInterest_GetName(interest);
CCNxNameSegment *segment = ccnxName_GetSegment(nameAfterPayload, ccnxName_GetSegmentCount(nameAfterPayload) - 1);
assertTrue(ccnxNameSegment_GetType(segment) == CCNxNameLabelType_PAYLOADID, "Expected to find a payload ID appended to the name");
CCNxInterestPayloadId *outId = ccnxInterestPayloadId_CreateFromSegmentInName(nameAfterPayload);
assertTrue(ccnxInterestPayloadId_Equals(outId, payloadId), "expected to see the same payload Id after setting the payload");
ccnxInterestPayloadId_Release(&payloadId);
ccnxInterestPayloadId_Release(&outId);
parcBuffer_Release(&payload);
parcBuffer_Release(&payloadIdBuffer);
}
ccnxName_Release(&name);
ccnxName_Release(&origNameCopy);
ccnxInterest_Release(&interest);
}
LONGBOW_TEST_CASE(Global, ccnxContentObject_SetSignature)
{
CCNxName *name = ccnxName_CreateFromCString("lci:/hello/dolly");
PARCBuffer *payload = parcBuffer_WrapCString("hello");
CCNxContentObject *contentObject = ccnxContentObject_CreateWithDataPayload(name, payload);
PARCBuffer *keyId = parcBuffer_WrapCString("keyhash");
PARCBuffer *sigbits = parcBuffer_WrapCString("siggybits");
PARCSignature *signature = parcSignature_Create(PARCSigningAlgorithm_RSA, PARC_HASH_SHA256, parcBuffer_Flip(sigbits));
ccnxContentObject_SetSignature(contentObject, keyId, signature, NULL);
parcBuffer_Release(&payload);
parcBuffer_Release(&sigbits);
parcBuffer_Release(&keyId);
parcSignature_Release(&signature);
ccnxName_Release(&name);
ccnxContentObject_Release(&contentObject);
}
LONGBOW_TEST_CASE(Global, ccnxKeyLocator_Equals)
{
char *hexString = "ABCDEF1234";
PARCBuffer *keyBuffer = parcBuffer_WrapCString(hexString);
PARCKeyId *keyId = parcKeyId_Create(keyBuffer);
PARCKey *key1 = parcKey_CreateFromDerEncodedPublicKey(keyId, PARCSigningAlgorithm_RSA, keyBuffer);
CCNxKeyLocator *keyLocator1 = ccnxKeyLocator_CreateFromKey(key1);
parcKeyId_Release(&keyId);
parcBuffer_Release(&keyBuffer);
CCNxKeyLocator *keyLocator1Copy = ccnxKeyLocator_Copy(keyLocator1);
PARCBuffer *keyBuffer2 = parcBuffer_WrapCString(hexString);
PARCKeyId *keyId2 = parcKeyId_Create(keyBuffer2);
PARCKey *key2 = parcKey_CreateFromDerEncodedPublicKey(keyId2, PARCSigningAlgorithm_RSA, keyBuffer2);
CCNxKeyLocator *keyLocator2 = ccnxKeyLocator_CreateFromKey(key2);
parcBuffer_Release(&keyBuffer2);
parcKeyId_Release(&keyId2);
CCNxName *keyURIName = ccnxName_CreateFromCString("lci://name");
CCNxLink *keyLink = ccnxLink_Create(keyURIName, NULL, NULL);
CCNxKeyLocator *keyLocatorDiff = ccnxKeyLocator_CreateFromKeyLink(keyLink);
ccnxKeyLocator_AssertValid(keyLocator1);
ccnxKeyLocator_AssertValid(keyLocator1Copy);
ccnxKeyLocator_AssertValid(keyLocator2);
ccnxKeyLocator_AssertValid(keyLocatorDiff);
assertEqualsContract(ccnxKeyLocator_Equals, keyLocator1, keyLocator1Copy, keyLocator2, keyLocatorDiff);
parcKey_Release(&key1);
ccnxKeyLocator_Release(&keyLocator1);
ccnxKeyLocator_Release(&keyLocator1Copy);
parcKey_Release(&key2);
ccnxKeyLocator_Release(&keyLocator2);
ccnxName_Release(&keyURIName);
ccnxLink_Release(&keyLink);
ccnxKeyLocator_Release(&keyLocatorDiff);
}
LONGBOW_TEST_CASE(Specialization, parcSortedList_RemoveFirst)
{
PARCSortedList *deque = parcSortedList_Create();
PARCBuffer *object1 = parcBuffer_WrapCString("1");
PARCBuffer *object2 = parcBuffer_WrapCString("2");
PARCBuffer *object3 = parcBuffer_WrapCString("3");
parcSortedList_Add(deque, object1);
parcSortedList_Add(deque, object2);
parcSortedList_Add(deque, object3);
PARCBuffer *peek = parcSortedList_RemoveFirst(deque);
assertTrue(parcBuffer_Equals(object1, peek), "Objects out of order");
parcBuffer_Release(&peek);
parcBuffer_Release(&object1);
parcBuffer_Release(&object2);
parcBuffer_Release(&object3);
parcSortedList_Release(&deque);
}
LONGBOW_TEST_CASE(Loca, _createHashableKey_NameAndObjectHash)
{
// Now try with key Ids.
CCNxName *name1 = ccnxName_CreateFromURI("lci:/name/1");
CCNxName *name2 = ccnxName_CreateFromURI("lci:/name/2");
PARCBuffer *objHash1 = parcBuffer_WrapCString("hash 1");
PARCBuffer *objHash2 = parcBuffer_WrapCString("hash 2");
PARCObject *keyObj1 = _createHashableKey(name1, NULL, objHash1);
PARCObject *keyObj2 = _createHashableKey(name1, NULL, NULL);
assertFalse(parcObject_HashCode(keyObj1) == 0, "Expected non zero hashcode");
assertFalse(parcObject_HashCode(keyObj2) == 0, "Expected non zero hashcode");
assertFalse(parcObject_HashCode(keyObj1) == parcObject_HashCode(keyObj2), "Expected different hashcodes");
parcObject_Release((PARCObject **) &keyObj1);
parcObject_Release((PARCObject **) &keyObj2);
// Different object hashes.
keyObj1 = _createHashableKey(name1, NULL, objHash1);
keyObj2 = _createHashableKey(name1, NULL, objHash2);
assertFalse(parcObject_HashCode(keyObj1) == 0, "Expected non zero hashcode");
assertFalse(parcObject_HashCode(keyObj2) == 0, "Expected non zero hashcode");
assertFalse(parcObject_HashCode(keyObj1) == parcObject_HashCode(keyObj2), "Expected different hashcodes");
parcObject_Release((PARCObject **) &keyObj1);
parcObject_Release((PARCObject **) &keyObj2);
parcBuffer_Release(&objHash1);
parcBuffer_Release(&objHash2);
// Now try with
ccnxName_Release(&name1);
ccnxName_Release(&name2);
}
LONGBOW_TEST_CASE(JSON, parcJSON_ParseBuffer_WithExcess)
{
char *string = "{ \"string\" : \"string\", \"null\" : null, \"true\" : true, \"false\" : false, \"integer\" : 31415, \"float\" : 3.141500, \"array\" : [ null, false, true, 31415, \"string\", [ null, false, true, 31415, \"string\" ], { } ] }Xhowdy";
PARCBuffer *buffer = parcBuffer_WrapCString((char *) string);
PARCJSON *json = parcJSON_ParseBuffer(buffer);
char actual = parcBuffer_GetUint8(buffer);
assertTrue(actual == 'X', "Expected buffer position to point to X, actual %x", actual);
parcBuffer_Release(&buffer);
parcJSON_Release(&json);
}
LONGBOW_TEST_CASE(Local, _athenaLRUContentStore_GetMatchByNameAndObjectHash)
{
AthenaLRUContentStore *impl = _createLRUContentStore();
PARCBuffer *payload = parcBuffer_Allocate(1200);
CCNxName *name = ccnxName_CreateFromURI("lci:/boose/roo/pie");
CCNxContentObject *contentObject = ccnxContentObject_CreateWithDataPayload(name, NULL);
parcBuffer_Release(&payload);
_AthenaLRUContentStoreEntry *entry1 = _athenaLRUContentStoreEntry_Create(contentObject);
entry1->hasKeyId = false;
entry1->hasContentObjectHash = false;
bool status = _athenaLRUContentStore_PutLRUContentStoreEntry(impl, entry1);
assertTrue(status, "Expected to add the entry");
// Now add another content object with the same name, but an object hash too.
CCNxContentObject *contentObject2 = ccnxContentObject_CreateWithDataPayload(name, NULL);
_AthenaLRUContentStoreEntry *entry2 = _athenaLRUContentStoreEntry_Create(contentObject2);
entry2->contentObjectHash = parcBuffer_WrapCString("corned beef");
entry2->hasContentObjectHash = true;
status = _athenaLRUContentStore_PutLRUContentStoreEntry(impl, entry2);
assertTrue(status, "Expected to add the entry");
assertTrue(impl->numEntries == 2, "Expected 2 store items");
// Now match on Name + ObjectHash.
CCNxInterest *interest = ccnxInterest_CreateSimple(name);
PARCBuffer *hashRestriction = parcBuffer_Copy(entry2->contentObjectHash);
ccnxInterest_SetContentObjectHashRestriction(interest, hashRestriction);
parcBuffer_Release(&hashRestriction);
CCNxContentObject *match = _athenaLRUContentStore_GetMatch(impl, interest);
assertNotNull(match, "Expected to match something");
assertTrue(match == contentObject2, "Expected the content object with the keyId");
_athenaLRUContentStoreEntry_Release(&entry1);
_athenaLRUContentStoreEntry_Release(&entry2);
ccnxContentObject_Release(&contentObject2);
ccnxContentObject_Release(&contentObject);
ccnxName_Release(&name);
ccnxInterest_Release(&interest);
_athenaLRUContentStore_Release((AthenaContentStoreImplementation *) &impl);
}
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);
}
LONGBOW_TEST_CASE(Local, _athenaLRUContentStore_PutLRUContentStoreEntry)
{
AthenaLRUContentStore *impl = _createLRUContentStore();
PARCBuffer *payload = parcBuffer_Allocate(1200);
CCNxContentObject *contentObject = _createContentObject("lci:/boose/roo/pie", 10, NULL);
parcBuffer_Release(&payload);
_AthenaLRUContentStoreEntry *entry = _athenaLRUContentStoreEntry_Create(contentObject);
ccnxContentObject_Release(&contentObject);
entry->expiryTime = 10000;
entry->contentObjectHash = parcBuffer_WrapCString("object hash buffer");
entry->keyId = parcBuffer_WrapCString("key id buffer");
entry->hasContentObjectHash = true;
entry->hasKeyId = true;
bool status = _athenaLRUContentStore_PutLRUContentStoreEntry(impl, entry);
assertTrue(status, "Expected to put content into the store");
assertTrue(status, "Expected to put content into the store a second time");
assertTrue(impl->numEntries == 1, "Expected 1 entry in the store");
assertTrue(impl->stats.numAdds == 1, "Expected stats to show 1 adds");
_athenaLRUContentStore_PurgeContentStoreEntry(impl, entry);
assertTrue(impl->numEntries == 0, "Expected 0 entries in the store");
parcBuffer_Release(&entry->keyId);
parcBuffer_Release(&entry->contentObjectHash);
_athenaLRUContentStoreEntry_Release(&entry);
_athenaLRUContentStore_Release((AthenaContentStoreImplementation *) &impl);
}
LONGBOW_TEST_CASE(JSON, parcJSON_GetValueByName)
{
TestData *data = longBowTestCase_GetClipBoardData(testCase);
int expected = 31415;
const PARCJSONValue *value = parcJSON_GetValueByName(data->json, "integer");
int64_t actual = parcJSONValue_GetInteger(value);
PARCBuffer *expectedName = parcBuffer_WrapCString("integer");
assertTrue(expected == actual, "Expected %d, actual %" PRIi64 "", expected, actual);
parcBuffer_Release(&expectedName);
}
static TestData *
_commonSetup(void)
{
TestData *data = parcMemory_AllocateAndClear(sizeof(TestData));
CCNxName *name = ccnxName_CreateFromCString("lci:/default/testData/content");
PARCBuffer *payload = parcBuffer_WrapCString("hello");
data->impl = CCNxContentObjectFacadeV1_Implementation;
data->name = name;
data->contentObject = ccnxContentObject_CreateWithImplAndPayload(&data->impl, name, CCNxPayloadType_DATA, payload);
parcBuffer_Release(&payload);
return data;
}
LONGBOW_TEST_CASE(Global, putContent)
{
AthenaLRUContentStoreConfig config;
config.capacityInMB = 10;
AthenaContentStore *store = athenaContentStore_Create(&AthenaContentStore_LRUImplementation, &config);
PARCBuffer *payload = parcBuffer_WrapCString("this is a payload");
CCNxContentObject *contentObject = _createContentObject("lci:/cakes/and/pies", 0, payload);
parcBuffer_Release(&payload);
ccnxContentObject_SetExpiryTime(contentObject, 100);
athenaContentStore_PutContentObject(store, contentObject);
athenaContentStore_Release(&store);
ccnxContentObject_Release(&contentObject);
}
LONGBOW_TEST_CASE(Global, ccnxKeyLocator_FromKey)
{
char *hexString = "ABCDEF1234";
PARCBuffer *keyBuffer = parcBuffer_WrapCString(hexString);
PARCKeyId *keyId = parcKeyId_Create(keyBuffer);
PARCKey *key = parcKey_CreateFromDerEncodedPublicKey(keyId, PARCSigningAlgorithm_RSA, keyBuffer);
CCNxKeyLocator *keyLocator = ccnxKeyLocator_CreateFromKey(key);
parcKeyId_Release(&keyId);
parcBuffer_Release(&keyBuffer);
ccnxKeyLocator_AssertValid(keyLocator);
ccnxKeyLocator_Release(&keyLocator);
parcKey_Release(&key);
}
CCNxSimpleFileTransferChunkList *
ccnxSimpleFileTransferChunkList_Create(const char *fileName, size_t numChunks)
{
CCNxSimpleFileTransferChunkList *result = parcObject_CreateAndClearInstance(CCNxSimpleFileTransferChunkList);
if (fileName != NULL) {
result->fileName = parcBuffer_WrapCString((char *) fileName);
}
size_t sizeNeeded = (numChunks * sizeof(CCNxContentObject *));
result->chunkPointers = parcMemory_AllocateAndClear(sizeNeeded);
result->numChunks = numChunks;
return result;
}
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);
}
LONGBOW_TEST_CASE(Global, ccnxContentObject_HasExpiryTime)
{
CCNxName *name = ccnxName_CreateFromCString("lci:/hello/dolly");
PARCBuffer *payload = parcBuffer_WrapCString("hello");
// Use a V1 ContentObject, as V0 doesn't support ExpiryTime
CCNxContentObject *contentObject =
ccnxContentObject_CreateWithImplAndPayload(&CCNxContentObjectFacadeV1_Implementation,
name, CCNxPayloadType_DATA, payload);
assertFalse(ccnxContentObject_HasExpiryTime(contentObject), "Expected no expiration time by default");
parcBuffer_Release(&payload);
ccnxName_Release(&name);
ccnxContentObject_Release(&contentObject);
}
LONGBOW_TEST_CASE(Specialization, parcSortedList_Add)
{
PARCSortedList *instance = parcSortedList_Create();
PARCBuffer *element1 = parcBuffer_WrapCString("1");
PARCBuffer *element2 = parcBuffer_WrapCString("2");
PARCBuffer *element3 = parcBuffer_WrapCString("3");
PARCBuffer *element4 = parcBuffer_WrapCString("4");
PARCBuffer *element7 = parcBuffer_WrapCString("7");
PARCBuffer *element6 = parcBuffer_WrapCString("6");
PARCBuffer *element5 = parcBuffer_WrapCString("5");
PARCBuffer *element8 = parcBuffer_WrapCString("8");
parcSortedList_Add(instance, element2);
parcSortedList_Display(instance, 0);
parcSortedList_Add(instance, element8);
parcSortedList_Display(instance, 0);
parcSortedList_Add(instance, element3);
parcSortedList_Display(instance, 0);
parcSortedList_Add(instance, element4);
parcSortedList_Display(instance, 0);
parcSortedList_Add(instance, element7);
parcSortedList_Display(instance, 0);
parcSortedList_Add(instance, element6);
parcSortedList_Display(instance, 0);
parcSortedList_Add(instance, element5);
parcSortedList_Display(instance, 0);
parcSortedList_Add(instance, element1);
parcSortedList_Display(instance, 0);
parcSortedList_Add(instance, element6);
parcSortedList_Display(instance, 0);
dump(instance);
parcBuffer_Release(&element1);
parcBuffer_Release(&element2);
parcBuffer_Release(&element3);
parcBuffer_Release(&element4);
parcBuffer_Release(&element5);
parcBuffer_Release(&element6);
parcBuffer_Release(&element7);
parcBuffer_Release(&element8);
parcSortedList_Release(&instance);
}
