LONGBOW_TEST_CASE(Global, PARCList_Equals_Empty) { PARCArrayList *a = parcArrayList_Create(parcArrayList_StdlibFreeFunction); PARCArrayList *b = parcArrayList_Create(parcArrayList_StdlibFreeFunction); assertTrue(parcArrayList_Equals(a, b), "Equal values were expected to be equal"); parcArrayList_Destroy(&a); parcArrayList_Destroy(&b); }
LONGBOW_TEST_CASE(Global, PARC_TreeRedBlack_Values) { PARCTreeRedBlack *tree1; PARCArrayList *list; tree1 = parcTreeRedBlack_Create(pointerComp, NULL, NULL, NULL, NULL, NULL); list = parcArrayList_Create(NULL); // Insert in tree out of order for (long i = 10; i < 20; i++) { // Add some elements to the tree parcTreeRedBlack_Insert(tree1, (void *) i, (void *) (i << 8)); } for (long i = 1; i < 10; i++) { // Add some elements to the tree parcTreeRedBlack_Insert(tree1, (void *) i, (void *) (i << 8)); } // Insert in list in order for (long i = 1; i < 20; i++) { // Add some elements to the tree parcArrayList_Add(list, (void *) (i << 8)); } PARCArrayList *values = parcTreeRedBlack_Values(tree1); assertTrue(parcArrayList_Equals(list, values), "Key list doesnt' match"); parcArrayList_Destroy(&values); parcArrayList_Destroy(&list); parcTreeRedBlack_Destroy(&tree1); }
LONGBOW_TEST_CASE(Global, PARCList_Equals_Same) { PARCArrayList *a = parcArrayList_Create(parcArrayList_StdlibFreeFunction); assertTrue(parcArrayList_Equals(a, a), "Expected the same array list to be equal to itself."); parcArrayList_Destroy(&a); }
LONGBOW_TEST_CASE(Global, parcList_Release) { PARCList *list = parcList(parcArrayList_Create(parcArrayList_StdlibFreeFunction), PARCArrayListAsPARCList); parcList_Release(&list); assertNull(list, "Expected null."); }
AthenaTransportLinkAdapter * athenaTransportLinkAdapter_Create(void (*removeLinkCallback)(void *removeLinkContext, PARCBitVector *parcBitVector), AthenaTransportLinkAdapter_RemoveLinkCallbackContext removeLinkContext) { AthenaTransportLinkAdapter *athenaTransportLinkAdapter = parcMemory_AllocateAndClear(sizeof(AthenaTransportLinkAdapter)); assertNotNull(athenaTransportLinkAdapter, "parcMemory_AllocateAndClear failed to create a new AthenaTransportLinkAdapter"); athenaTransportLinkAdapter->moduleList = parcArrayList_Create((void (*)(void **))athenaTransportLinkModule_Destroy); athenaTransportLinkAdapter->instanceList = parcArrayList_Create(NULL); athenaTransportLinkAdapter->listenerList = parcArrayList_Create(NULL); athenaTransportLinkAdapter->nextLinkToRead = 0; athenaTransportLinkAdapter->pollfdListSize = 0; athenaTransportLinkAdapter->removeLink = removeLinkCallback; athenaTransportLinkAdapter->removeLinkContext = removeLinkContext; athenaTransportLinkAdapter->log = _parc_logger_create(); return athenaTransportLinkAdapter; }
LONGBOW_TEST_CASE(Global, PARCList_InsertAtIndex_Last) { PARCArrayList *array = parcArrayList_Create(NULL); parcArrayList_Add(array, (void *) 1); parcArrayList_Add(array, (void *) 2); size_t actual = parcArrayList_Size(array); assertTrue(2 == actual, "Expected=%d, actual=%zu", 2, actual); parcArrayList_InsertAtIndex(array, 2, (void *) 3); actual = parcArrayList_Size(array); assertTrue(3 == actual, "Expected=%d, actual=%zu", 3, actual); void *element0 = parcArrayList_Get(array, 0); assertTrue(element0 == (void *) 1, "Element 1 moved?"); void *element1 = parcArrayList_Get(array, 1); assertTrue(element1 == (void *) 2, "Element 1 moved?"); void *element2 = parcArrayList_Get(array, 2); assertTrue(element2 == (void *) 3, "Element 1 moved?"); parcArrayList_Destroy(&array); }
int main(int argc, char *argv[]) { char *programName = "parc_publickey"; if (argc < 2) { printUsage(programName); exit(1); } PARCArrayList *args = parcArrayList_Create(NULL); parcArrayList_AddAll(args, (void **) argv, argc); parcSecurity_Init(); char *arg = parcArrayList_Get(args, 1); if (strcmp(arg, "-h") == 0 || strcmp(arg, "--help") == 0) { printUsage(programName); return 0; } else if (strcmp(arg, "-c") == 0 || strcmp(arg, "--create") == 0) { parcPublicKey_Create(args); } else if (strcmp(arg, "-v") == 0 || strcmp(arg, "--validate") == 0) { parcPublicKey_Validate(args); } else { printUsage(programName); exit(1); } parcSecurity_Fini(); return 0; }
CPIInterfaceSet * cpiInterfaceSet_Create(void) { CPIInterfaceSet *set = parcMemory_AllocateAndClear(sizeof(CPIInterfaceSet)); assertNotNull(set, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(CPIInterfaceSet)); set->listOfInterfaces = parcArrayList_Create(_destroyInterface); return set; }
LONGBOW_TEST_CASE(Global, PARCList_New) { PARCArrayList *array = parcArrayList_Create(parcArrayList_StdlibFreeFunction); size_t size = parcArrayList_Size(array); assertTrue(0 == size, "Expected %d actual=%zd", 0, size); parcArrayList_Destroy(&array); }
CPIConnectionList * cpiConnectionList_Create() { CPIConnectionList *list = parcMemory_AllocateAndClear(sizeof(CPIConnectionList)); assertNotNull(list, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(CPIConnectionList)); list->listOfConnections = parcArrayList_Create(_cpiConnectionList_ArrayDestroyer); return list; }
LONGBOW_TEST_CASE(Global, PARCList_Length) { PARCArrayList *array = parcArrayList_Create(NULL); parcArrayList_Add(array, 0); size_t size = parcArrayList_Size(array); assertTrue(1 == size, "Expected %d actual=%zd", 1, size); parcArrayList_Destroy(&array); }
MetisListenerSet * metisListenerSet_Create() { MetisListenerSet *set = parcMemory_AllocateAndClear(sizeof(MetisListenerSet)); assertNotNull(set, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(MetisListenerSet)); set->listOfListeners = parcArrayList_Create(metisListenerSet_DestroyListenerOps); return set; }
LONGBOW_TEST_CASE(Global, PARCList_Add) { PARCList *list = parcList(parcArrayList_Create(parcArrayList_StdlibFreeFunction), PARCArrayListAsPARCList); parcList_Add(list, 0); size_t actual = parcList_Size(list); assertTrue(1 == actual, "Expected=%d, actual=%zu", 1, actual); parcList_Release(&list); }
LONGBOW_TEST_CASE(Global, PARCList_IsEmpty) { PARCArrayList *array = parcArrayList_Create(NULL); assertTrue(parcArrayList_IsEmpty(array), "Expected a new array to be empty."); parcArrayList_Add(array, 0); assertFalse(parcArrayList_IsEmpty(array), "Expected an array with more than zero elements to be empty."); parcArrayList_Destroy(&array); }
MetisCommandLineInterface * metisCommandLineInterface_Create(MetisForwarder *metis, uint16_t port) { MetisCommandLineInterface *cli = parcMemory_AllocateAndClear(sizeof(MetisCommandLineInterface)); assertNotNull(cli, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(MetisCommandLineInterface)); cli->port = port; cli->listener = NULL; cli->metis = metis; cli->openSessions = parcArrayList_Create(_session_VoidDestroyer); return cli; }
LONGBOW_TEST_CASE(Global, PARCList_InsertAtIndex_Empty) { PARCArrayList *array = parcArrayList_Create(NULL); parcArrayList_InsertAtIndex(array, 0, (void *) 3); size_t actual = parcArrayList_Size(array); assertTrue(1 == actual, "Expected=%d, actual=%zu", 1, actual); parcArrayList_Destroy(&array); }
LONGBOW_TEST_CASE(Global, PARCList_Get) { PARCArrayList *array = parcArrayList_Create(parcArrayList_StdlibFreeFunction); char *expected = strdup("Hello World"); parcArrayList_Add(array, expected); char *actual = parcArrayList_Get(array, 0); assertTrue(expected == actual, "Expected=%p, actual=%p", (void *) expected, (void *) actual); parcArrayList_Destroy(&array); }
LONGBOW_TEST_CASE(Global, PARCList_RemoveAndDestroy_AtIndex_Last) { char a[] = "apple"; char b[] = "bananna"; char c[] = "cherry"; PARCArrayList *array = parcArrayList_Create(NULL); parcArrayList_Add(array, a); parcArrayList_Add(array, b); parcArrayList_Add(array, c); PARCArrayList *expected = parcArrayList_Create(NULL); parcArrayList_Add(expected, a); parcArrayList_Add(expected, b); parcArrayList_RemoveAndDestroyAtIndex(array, 2); assertTrue(parcArrayList_Equals(expected, array), "Expected "); parcArrayList_Destroy(&expected); parcArrayList_Destroy(&array); }
/** * Parse a string in to a PARCList with one word per element * * The string passed will be modified by inserting NULLs after each token. * * @param [in] str A c-string (will be modified) * * @retval non-null A PARCList where each item is a single word * * Example: * @code * <#example#> * @endcode */ static PARCList * _parseArgs(char *str) { PARCList *list = parcList(parcArrayList_Create(NULL), PARCArrayListAsPARCList); const char delimiters[] = " \t"; char *token; while ((token = strsep(&str, delimiters)) != NULL) { parcList_Add(list, token); } return list; }
LONGBOW_TEST_CASE(Global, PARCList_Remove_AtIndex) { char a[] = "apple"; char b[] = "bananna"; char c[] = "cherry"; PARCArrayList *array = parcArrayList_Create(NULL); parcArrayList_Add(array, a); parcArrayList_Add(array, b); parcArrayList_Add(array, c); PARCArrayList *expected = parcArrayList_Create(NULL); parcArrayList_Add(expected, a); parcArrayList_Add(expected, c); void *removedElement = parcArrayList_RemoveAtIndex(array, 1); assertTrue(removedElement == b, "Expected "); assertTrue(parcArrayList_Equals(expected, array), "Expected "); parcArrayList_Destroy(&expected); parcArrayList_Destroy(&array); }
LONGBOW_TEST_CASE(Global, PARCList_Copy) { char *a = strdup("apple"); char *b = strdup("bananna"); char *c = strdup("cherry"); PARCList *list = parcList(parcArrayList_Create(parcArrayList_StdlibFreeFunction), PARCArrayListAsPARCList); parcList_Add(list, a); parcList_Add(list, b); parcList_Add(list, c); parcList_Release(&list); }
LONGBOW_TEST_CASE(Local, _metisControlAddConnection_EtherExecute) { const char *argv[] = { "add", "connection", "ether", "conn3", "e8-06-88-cd-28-de", "em3" }; PARCList *args = parcList(parcArrayList_Create(NULL), PARCArrayListAsPARCList); parcList_AddAll(args, 6, (void **) &argv[0]); TestData *data = longBowTestCase_GetClipBoardData(testCase); MetisCommandOps *ops = _metisControlAddConnection_EtherCreate(data->state); MetisCommandReturn result = ops->execute(data->state->parser, ops, args); metisCommandOps_Destroy(&ops); parcList_Release(&args); assertTrue(result == MetisCommandReturn_Success, "Valid command line should succeed"); }
LONGBOW_TEST_CASE(Local, _metisControlAddConnection_UdpExecute) { TestData *data = longBowTestCase_GetClipBoardData(testCase); const char *argv[] = { "add", "connection", "tcp", "conn3", "1.2.3.4", "123" }; PARCList *args = parcList(parcArrayList_Create(NULL), PARCArrayListAsPARCList); parcList_AddAll(args, 6, (void **) &argv[0]); MetisCommandOps *ops = _metisControlAddConnection_UdpCreate(data->state); MetisCommandReturn result = ops->execute(data->state->parser, ops, args); metisCommandOps_Destroy(&ops); parcList_Release(&args); assertTrue(result == MetisCommandReturn_Success, "Unimplemented execute should have failed"); }
// // This function must be named "athenaTransportLinkModule" <module name> "_Init" so that // athenaTransportLinkAdapter can locate it to invoke initialization when it's loaded. It's // named uniquely (as opposed to _init()) so that it can also be statically linked into Athena. // PARCArrayList * athenaTransportLinkModuleTEMPLATE_Init() { // Template module for establishing point to point tunnel connections. AthenaTransportLinkModule *athenaTransportLinkModule; PARCArrayList *moduleInstanceList = parcArrayList_Create(NULL); assertNotNull(moduleInstanceList, "parcArrayList_Create failed to create module list"); athenaTransportLinkModule = athenaTransportLinkModule_Create("TEMPLATE", _TemplateOpen, _TemplatePoll); assertNotNull(athenaTransportLinkModule, "parcMemory_AllocateAndClear failed allocate Template athenaTransportLinkModule"); bool result = parcArrayList_Add(moduleInstanceList, athenaTransportLinkModule); assertTrue(result == true, "parcArrayList_Add failed"); return moduleInstanceList; }
PARCArrayList * athenaTransportLinkModuleUDP_Init() { // Module for providing UDP tunnel connections. AthenaTransportLinkModule *athenaTransportLinkModule; PARCArrayList *moduleList = parcArrayList_Create(NULL); assertNotNull(moduleList, "parcArrayList_Create failed to create module list"); athenaTransportLinkModule = athenaTransportLinkModule_Create("UDP", _UDPOpen, _UDPPoll); assertNotNull(athenaTransportLinkModule, "parcMemory_AllocateAndClear failed allocate UDP athenaTransportLinkModule"); bool result = parcArrayList_Add(moduleList, athenaTransportLinkModule); assertTrue(result == true, "parcArrayList_Add failed"); return moduleList; }
PARCArrayList * athenaTransportLinkModuleETH_Init() { // Module for providing Ethernet links. AthenaTransportLinkModule *athenaTransportLinkModule; PARCArrayList *moduleList = parcArrayList_Create(NULL); assertNotNull(moduleList, "parcArrayList_Create failed to create module list"); athenaTransportLinkModule = athenaTransportLinkModule_Create("ETH", _ETHOpen, _ETHPoll); assertNotNull(athenaTransportLinkModule, "parcMemory_AllocateAndClear failed allocate ETH athenaTransportLinkModule"); bool result = parcArrayList_Add(moduleList, athenaTransportLinkModule); assertTrue(result == true, "parcArrayList_Add failed"); return moduleList; }
static MetisCommandReturn testAddRoute(const LongBowTestCase *testCase, int argc, const char *prefix, const char *nexthop, const char *cost) { TestData *data = longBowTestCase_GetClipBoardData(testCase); metisControlState_SetDebug(data->state, true); const char *argv[] = { "add", "route", nexthop, prefix, cost }; PARCList *args = parcList(parcArrayList_Create(NULL), PARCArrayListAsPARCList); parcList_AddAll(args, argc, (void **) &argv[0]); MetisCommandOps *ops = metisControlAddRoute_Create(data->state); MetisCommandReturn result = ops->execute(data->state->parser, ops, args); metisCommandOps_Destroy(&ops); parcList_Release(&args); return result; }
LONGBOW_TEST_CASE(Global, PARCList_AddAll) { PARCList *list = parcList(parcArrayList_Create(parcArrayList_StdlibFreeFunction), PARCArrayListAsPARCList); void *elements[] = { strdup("a"), strdup("b"), strdup("c"), }; parcList_AddAll(list, 3, elements); size_t actual = parcList_Size(list); assertTrue(3 == actual, "Expected=%d, actual=%zu", 3, actual); parcList_Release(&list); }
PARCURIPath * parcURIPath_Copy(const PARCURIPath *path) { assertNotNull(path, "Parameter must be a non-null PARC_URIPath pointer."); PARCURIPath *result = parcURIPath_Create(); result->segments = parcArrayList_Create((void (*)(void **))parcURISegment_Release); size_t nSegments = parcURIPath_Count(path); for (size_t i = 0; i < nSegments; i++) { PARCURISegment *segment = parcURIPath_Get(path, i); PARCURISegment *segmentCopy = parcURISegment_Clone(segment); parcURIPath_Append(result, segmentCopy); } return result; }
static MetisCommandReturn testListConnections(const LongBowTestCase *testCase, int argc) { TestData *data = longBowTestCase_GetClipBoardData(testCase); metisControlState_SetDebug(data->state, true); data->customWriteReadReply = &customWriteReadResponse; const char *argv[] = { "list", "interfaces" }; PARCList *args = parcList(parcArrayList_Create(NULL), PARCArrayListAsPARCList); parcList_AddAll(args, argc, (void **) &argv[0]); MetisCommandOps *ops = metisControlListConnections_Create(data->state); MetisCommandReturn result = ops->execute(data->state->parser, ops, args); metisCommandOps_Destroy(&ops); parcList_Release(&args); return result; }