//------------------------------------------------------------------------------------------------------------ void le_sls_Queue ( le_sls_List_t* listPtr, ///< [IN] The list to add to. le_sls_Link_t* newLinkPtr ///< [IN] The new link to add. ) { if (listPtr->tailLinkPtr == NULL) { // Add to an empty list. newLinkPtr->nextPtr = newLinkPtr; listPtr->tailLinkPtr = newLinkPtr; } else { le_sls_AddAfter(listPtr, listPtr->tailLinkPtr, newLinkPtr); } }
//-------------------------------------------------------------------------------------------------- static dstr_Ref_t NewOrNextSegmentRef ( dstr_Ref_t headRef, ///< [IN] The head of the string. dstr_Ref_t currentPtr ///< [IN] The current sub-section of the string. ) //-------------------------------------------------------------------------------------------------- { dstr_Ref_t segmentRef = NextSegmentRef(headRef, currentPtr); if (segmentRef != NULL) { return segmentRef; } segmentRef = NewSegment(); le_sls_AddAfter(&headRef->head.list, ¤tPtr->body.link, &segmentRef->body.link); return segmentRef; }
static le_result_t TestSinglyLinkLists(size_t maxListSize) { // Node definition. typedef struct { le_sls_Link_t link; uint32_t id; } idRecord_t; int i; le_sls_List_t list0, list1; printf("\n"); printf("*** Unit Test for le_singlyLinkedList module. ***\n"); // // Multiple list creation // // Initialize the lists list0 = LE_SLS_LIST_INIT; list1 = LE_SLS_LIST_INIT; printf("One singly linked list was successfully created.\n"); // // Attempt to query empty list // if ( (le_sls_Peek(&list0) != NULL) || (le_sls_Pop(&list0) != NULL) ) { printf("Query of empty list failed: %d", __LINE__); return LE_FAULT; } printf("Query of empty list correct.\n"); // // Node insertions // { idRecord_t* newNodePtr; le_sls_Link_t* prevLinkPtr; // Queue nodes to list0. for (i = 0; i < maxListSize; i++) { // Create the new node newNodePtr = (idRecord_t*)malloc(sizeof(idRecord_t)); newNodePtr->id = i; // Initialize the link. newNodePtr->link = LE_SLS_LINK_INIT; if (i < maxListSize/2) { // Insert the new node to the tail. le_sls_Queue(&list0, &(newNodePtr->link)); } else { // Insert to the tail using insert after. le_sls_AddAfter(&list0, prevLinkPtr, &(newNodePtr->link)); } prevLinkPtr = &(newNodePtr->link); } printf("%zu nodes were queued to the tail of list0.\n", maxListSize); // Stack nodes to list1. for (i = 0; i < maxListSize; i++) { // Create the new node newNodePtr = (idRecord_t*)malloc(sizeof(idRecord_t)); newNodePtr->id = i; // Initialize the link. newNodePtr->link = LE_SLS_LINK_INIT; // Insert the new node to the head. le_sls_Stack(&list1, &(newNodePtr->link)); } printf("%zu nodes were stacked to the head of list1.\n", maxListSize); } // // Check that all the nodes have been added properly // { idRecord_t* nodePtr; le_sls_Link_t* link0Ptr = le_sls_Peek(&list0); le_sls_Link_t* link1Ptr = le_sls_Peek(&list1); if ( (link0Ptr == NULL) || (link1Ptr == NULL) ) { printf("Link error: %d", __LINE__); return LE_FAULT; } i = 0; do { // Get the node from list 0 nodePtr = CONTAINER_OF(link0Ptr, idRecord_t, link); // Check the node. if ( nodePtr->id != i) { printf("Link error: %d", __LINE__); return LE_FAULT; } // Get the node from list 1 nodePtr = CONTAINER_OF(link1Ptr, idRecord_t, link); // Check the node. if ( nodePtr->id != maxListSize - i - 1) { printf("Link error: %d", __LINE__); return LE_FAULT; } // Move to the next node. link0Ptr = le_sls_PeekNext(&list0, link0Ptr); link1Ptr = le_sls_PeekNext(&list1, link1Ptr); i++; } while (link0Ptr != NULL); // Make sure everything is correct. if ( (i != maxListSize) || (link1Ptr != NULL) ) { printf("Link error: %d", __LINE__); return LE_FAULT; } } printf("Checked that all nodes added to the head and tails are all correct.\n"); // // Pop nodes. // { //pop half the list. for (i = 0; i < (maxListSize / 2); i++) { le_sls_Pop(&list0); } } printf("Popped half the nodes from the head of list0.\n"); // Check that the list is still in tact. { idRecord_t* nodePtr; // For list 0. le_sls_Link_t* linkPtr = le_sls_Peek(&list0); i = maxListSize/2; do { nodePtr = CONTAINER_OF(linkPtr, idRecord_t, link); if (nodePtr->id != i++) { printf("Link error: %d", __LINE__); return LE_FAULT; } linkPtr = le_sls_PeekNext(&list0, linkPtr); } while (linkPtr != NULL); // Check that the number of links left is correct. if (i != maxListSize) { printf("Wrong number of links: %d", __LINE__); return LE_FAULT; } } printf("Checked that all nodes were properly popped from the lists.\n"); // // Check for list corruption. // { le_sls_Link_t* linkPtr; if (le_sls_IsListCorrupted(&list0)) { printf("List0 is corrupt but shouldn't be: %d", __LINE__); return LE_FAULT; } // Access one of the links directly. This should corrupt the list. linkPtr = le_sls_Peek(&list0); linkPtr = le_sls_PeekNext(&list0, linkPtr); linkPtr->nextPtr = NULL; if (!le_sls_IsListCorrupted(&list0)) { printf("List0 is not corrupted but should be: %d", __LINE__); return LE_FAULT; } } printf("Checked lists for corruption.\n"); printf("*** Unit Test for le_singlyLinkedList module passed. ***\n"); printf("\n"); return LE_OK; }