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); }