LoL* tokenize(LinkedList* args) { int open_p = 0; Node* i; LoL* tk_list = LoL_new(); LinkedList* a = LinkedList_new(); if (args->front!=NULL) { for(i=args->front; i!=NULL; i=i->next) { if(strcmp(i->value, "(")==0) { append(a, i->value); open_p++; continue; } else if (strcmp(i->value, ")")==0) { append(a, i->value); open_p--; continue; } if(open_p==0) { if(strcmp(i->value, ",")==0) { appendLoL(tk_list, a); a = LinkedList_new(); continue; } } append(a, i->value); } appendLoL(tk_list, a); } clear(args); free(args); return tk_list; }
/* * Retrieves a list of all jump moves currently possible for a player. * * @params: (player) - the player whose moves are to be put in the list * @return: a LinkedList struct of jump moves currently possible for the player, or NULL if any allocation errors occurred */ static struct LinkedList* getPossibleJumps (char** board, int player){ struct LinkedList* jumpMoves = LinkedList_new(&PossibleMove_free); if(jumpMoves == NULL){ //allocation failed return NULL; } for (int x = 1; x <= Board_SIZE; x++){ for (int y = 1; y <= Board_SIZE; y++){ if (Board_evalPiece(board, x, y, player) <= 0){ continue; } for (int i = -1; i <= 1; i += 2){ for (int j = -1; j <= 1; j += 2){ struct Tile* destTile = NULL; if (!isInRange(x+i,y+j) || !isInRange(x+2*i,y+2*j)){ continue; } int pieceIsKing = Board_evalPiece(board, x, y, player) == 3; if (pieceIsKing){ destTile = canKingCaptureInDirection(board, x, y, i, j); } else{ int enemyNearby = Board_evalPiece(board, x+i, y+j, player) < 0; int enemyIsCapturable = Board_isEmpty(board, x+2*i, y+2*j); if(enemyNearby && enemyIsCapturable){ destTile = Tile_new(x+2*i, y+2*j); if (destTile == NULL){ // allocation failed return NULL; } } } if (!destTile){ continue; } struct LinkedList* jumpSteps = LinkedList_new(&Tile_free); if (jumpSteps == NULL){ // allocation failed Tile_free(destTile); return NULL; } LinkedList_add(jumpSteps, destTile); struct PossibleMove* possibleJumpMove = PossibleMove_new(x, y, jumpSteps, board); if (possibleJumpMove == NULL){ // allocation failed Tile_free(destTile); LinkedList_free(jumpSteps); return NULL; } populateJumpList(jumpMoves, possibleJumpMove); } } } } return jumpMoves; }
/* * Gets a list of all single step moves currently possible for a player. * * @params: (player) - the player whose moves are to be put in the list * @return: a list of single step moves currently possible for the player, or NULL if any allocation errors occurred */ static struct LinkedList* getPossibleSingleMoves (char** board, int player){ struct LinkedList* possibleSingleMoves = LinkedList_new(&PossibleMove_free); if (possibleSingleMoves == NULL){ return NULL; } int forward = (player == BLACK) ? -1 : 1; /* for each player's different direction of "forward" */ for (int x = 1; x <= Board_SIZE; x++){ for (int y = 1; y <= Board_SIZE; y++){ if (Board_evalPiece(board, x, y, player) <= 0){ //this tile doesn't contain one of this player's pieces continue; } for (int sideward = -1; sideward <= 1; sideward += 2){ for (int k = -Board_SIZE; k <= Board_SIZE; k++){ if (!isInRange(x+k*sideward, y+k)){ continue; } int pieceIsKing = Board_evalPiece(board, x, y, player) == 3; if (!pieceIsKing && k != forward){ continue; } if(Board_isEmpty(board, x+k*sideward, y+k)){ struct Tile* destTile = Tile_new(x+k*sideward, y+k); if (destTile == NULL){ // allocation failed return NULL; } struct LinkedList* singleSteps = LinkedList_new(&Tile_free); if (singleSteps == NULL){ // allocation failed Tile_free(destTile); return NULL; } LinkedList_add(singleSteps, destTile); struct PossibleMove* possibleSingleMove = PossibleMove_new(x, y, singleSteps, board); if (possibleSingleMove == NULL){ // allocation failed Tile_free(destTile); LinkedList_free(singleSteps); return NULL; } LinkedList_add(possibleSingleMoves, possibleSingleMove); } if (!pieceIsKing && k == forward){ break; } } } } } return possibleSingleMoves; }
END_TEST START_TEST(test_HeadAndTailOfLinkedListAreInitiallyNULL) { LinkedList* list = LinkedList_new(); ck_assert_ptr_eq(LinkedList_getHead(list), NULL); ck_assert_ptr_eq(LinkedList_getTail(list), NULL); }
END_TEST START_TEST(test_NodesHaveCorrectPreviousAndNextPointersAfterAddingMultipleElements) { LinkedList* list = LinkedList_new(); int elem1 = 1337; LinkedList_add(list, &elem1); char* elem2 = "theeta"; LinkedList_add(list, &elem2); int elem3 = 74; LinkedList_add(list, &elem3); char elem4 = 'a'; LinkedList_add(list, &elem4); Node* node = NULL; Node* prev = NULL; int i; for (i = 0; i < 4; i++) { node = LinkedList_getNode(list, i); ck_assert_ptr_eq(node->previous, prev); if (prev != NULL) { ck_assert_ptr_eq(prev->next, node); } prev = node; } ck_assert_ptr_eq(node->next, NULL); }
/* Drier program to test above functions*/ int main() { /* Start with the empty list */ LinkedList_T list; int i; list = LinkedList_new(); // Insert 6. So linked list becomes 6->NULL printf("add new item\n"); for(i=0; i<10; i++){ LinkedList_add(list, i) ; } printf("append new item\n"); for(i=100; i<110; i++){ LinkedList_append(list, i) ; } printf("print list item\n"); LinkedList_print(list); printf("print list item reverse\n"); LinkedList_print_reverse(list); printf("the first item is: %d\n", LinkedList_first(list)); printf("the last item is: %d\n", LinkedList_last(list)); getchar(); return 0; }
/* * Trims the list of possible jump moves, so it only contains moves that result in the maximum amount of captures * * @params: (jumpMovesList) - the list of all possible jump moves * @return: a trimmed list, or NULL if any allocation errors occurred */ static struct LinkedList* trimJumpMovesList (struct LinkedList* jumpMovesList){ int maxCaptures = 0; //finding the maximum number of captures in a currently possible jump move struct Iterator iterator; Iterator_init(&iterator, jumpMovesList); while(Iterator_hasNext(&iterator)){ struct PossibleMove* currMove = (struct PossibleMove*)(Iterator_next(&iterator)); int currNumOfCaptures = PossibleMove_numOfCaptures(currMove); if(currNumOfCaptures > maxCaptures){ maxCaptures = currNumOfCaptures; } } //creating a new list and filling it only with the appropriate moves struct LinkedList* trimmedJumpMoves = LinkedList_new(&PossibleMove_free); if(trimmedJumpMoves == NULL){ // allocation failed return NULL; } struct Iterator secondIterator; Iterator_init(&secondIterator, jumpMovesList); while(Iterator_hasNext(&secondIterator)){ struct PossibleMove* currMove = (struct PossibleMove*)(Iterator_next(&secondIterator)); if(PossibleMove_numOfCaptures(currMove) == maxCaptures){ struct PossibleMove* clonedCurrMove = PossibleMove_clone(currMove); if (clonedCurrMove == NULL){ // allocation failed LinkedList_free(trimmedJumpMoves); return NULL; } LinkedList_add(trimmedJumpMoves, clonedCurrMove); } } LinkedList_free(jumpMovesList); return trimmedJumpMoves; }
END_TEST START_TEST(test_SizeOfLinkedListIsOneAfterAddingAnElement) { LinkedList* list = LinkedList_new(); int elem = 1337; LinkedList_add(list, &elem); ck_assert_int_eq(LinkedList_size(list), 1); }
END_TEST START_TEST(test_GettingAStoredElementFromListNodeWorks) { LinkedList* list = LinkedList_new(); int elem = 1337; LinkedList_add(list, &elem); ck_assert_int_eq(*(int*) LinkedList_getNode(list, 0)->elem, 1337); }
END_TEST START_TEST(test_ListHasSameHeadAndTailNodeAfterAddingAnElement) { LinkedList* list = LinkedList_new(); int elem = 1337; LinkedList_add(list, &elem); ck_assert_ptr_ne(LinkedList_getHead(list), NULL); ck_assert_ptr_eq(LinkedList_getHead(list), LinkedList_getTail(list)); }
void Physics_addCollisionCallbackOnGameObject(CollisionCallback* callback, GameObject* object) { if (object->collisionListeners == NULL) { object->collisionListeners = LinkedList_new(); } LinkedList_addLast(object->collisionListeners, callback); }
void Physics_addCollisionCallbackOnObjectType(CollisionCallback* callback, ObjectType* type) { if (type->collisionListeners == NULL) { type->collisionListeners = LinkedList_new(); } LinkedList_addLast(type->collisionListeners, callback); }
int main(void) { LinkedList* list = LinkedList_new(); char* elem1 = "cat"; LinkedList_add(list, &elem1); char* elem2 = "rat"; LinkedList_add(list, &elem2); char* elem3 = "dog"; LinkedList_add(list, &elem3); char* elem4 = "sheep"; LinkedList_add(list, &elem4); char* elem5 = "goat"; LinkedList_add(list, &elem5); char* elem6 = "kebab"; LinkedList_add(list, &elem6); char* elem7 = "pig"; LinkedList_add(list, &elem7); char* elem8 = "cow"; LinkedList_add(list, &elem8); char* elem9 = "chicken"; LinkedList_add(list, &elem9); char* elem10 = "duck"; LinkedList_add(list, &elem10); char* elem11 = "fox"; LinkedList_add(list, &elem11); char* elem12 = "rabbit"; LinkedList_add(list, &elem12); char* elem13 = "mouse"; LinkedList_add(list, &elem13); char* elem14 = "hedgehog"; LinkedList_add(list, &elem14); printf("list before: \n"); for (int i = 0; i < LinkedList_size(list); i++) { if (LinkedList_get(list, i) != NULL) { printf("%d: %s \n", i, *(char**)LinkedList_get(list, i)); } } printf("\nremoving element 5, %s\n", *(char**)LinkedList_get(list, 5)); LinkedList_remove(list, 5); printf("\nlist after: \n"); for (int i = 0; i < LinkedList_size(list); i++) { if (LinkedList_get(list, i) != NULL) { printf("%d: %s \n", i, *(char**)LinkedList_get(list, i)); } } LinkedList_destroy(list); free(list); }
int maina() { LinkedList* l; l = LinkedList_new(); LinkedListIterator* iter = LinkedList_getIterator(l); if (LinkedListIterator_hasMore(iter)) { return 1; } if (LinkedListIterator_getNext(iter) != NULL) { return 2; } if (LinkedListIterator_getSame(iter) != NULL) { return 3; } LinkedListIterator_delete(iter); int i; int* j; // Add 100 integer pointers to list. for (i = 0; i < 100; i++) { j = malloc(sizeof(int)); *j = i; LinkedList_addLast(l, j); } iter = LinkedList_getIterator(l); int count = 0; while (LinkedListIterator_hasMore(iter)) { j = LinkedListIterator_getNext(iter); if (count != *j) { return 4; } count++; if (j != LinkedListIterator_getSame(iter)) { return 5; } } if (count != 99) { return 6; } LinkedListIterator_delete(iter); LinkedList_deleteContents(l, intDeleter); LinkedList_delete(l); return 0; }
END_TEST START_TEST(test_RemovingElementFromListDoesNotFreeItFromMemory) { LinkedList* list = LinkedList_new(); int* elem = malloc(sizeof (int)); *elem = 35; LinkedList_add(list, elem); ck_assert_int_eq(*(int*) LinkedList_get(list, 0), 35); LinkedList_remove(list, 0); ck_assert_int_eq(*elem, 35); }
END_TEST START_TEST(test_GettingANonExistentElementFromListReturnsNULL) { LinkedList* list = LinkedList_new(); int elem = 24; LinkedList_add(list, &elem); int elem1 = 25; LinkedList_add(list, &elem1); ck_assert_int_eq(*(int*) LinkedList_get(list, 1), 25); ck_assert_ptr_eq(LinkedList_get(list, 4), NULL); ck_assert_ptr_eq(LinkedList_get(list, -1), NULL); }
END_TEST START_TEST(test_StoringEvenMoreElementsToListWorks) { int i; for (i = 0; i < 10; i++) { LinkedList* list = LinkedList_new(); int elem1 = 1337; LinkedList_add(list, &elem1); char* elem2 = "theeta"; LinkedList_add(list, &elem2); int elem3 = 74; LinkedList_add(list, &elem3); char elem4 = 'a'; LinkedList_add(list, &elem4); int elem5 = 55; LinkedList_add(list, &elem5); int elem6 = 66; LinkedList_add(list, &elem6); int elem7 = 77; LinkedList_add(list, &elem7); int elem8 = 88; LinkedList_add(list, &elem8); int elem9 = 99; LinkedList_add(list, &elem9); int elem10 = 110; LinkedList_add(list, &elem10); int elem11 = 111; LinkedList_add(list, &elem11); int elem12 = 1212; LinkedList_add(list, &elem12); int elem13 = 1313; LinkedList_add(list, &elem13); int elem14 = 1414; LinkedList_add(list, &elem14); ck_assert_int_eq(*(int*) LinkedList_get(list, 0), 1337); ck_assert_str_eq(*(char**) LinkedList_get(list, 1), "theeta"); ck_assert_int_eq(*(int*) LinkedList_get(list, 2), 74); ck_assert_int_eq(*(char*) LinkedList_get(list, 3), 'a'); ck_assert_int_eq(*(int*) LinkedList_get(list, 9), 110); ck_assert_int_eq(*(int*) LinkedList_get(list, 10), 111); ck_assert_int_eq(*(int*) LinkedList_get(list, 11), 1212); ck_assert_int_eq(*(int*) LinkedList_get(list, 12), 1313); ck_assert_int_eq(*(int*) LinkedList_get(list, 13), 1414); ck_assert_int_eq(LinkedList_size(list), 14); } }
int main() { ALL_TESTS = LinkedList_new(); $(ALL_TESTS, addStart, &dummy_start); $(ALL_TESTS, addStart, &dummy_tail); declare_test(); printf("%zu\n", ALL_TESTS->fields->size); LinkedListNode *p = ALL_TESTS->fields->head; while(p) { ((TestFunction)(p->data))(); p = p->next; } // $(list, removeNode, list->fields->tail); // TODO: allocate the data dynamically. // assert(_(list, size) == 5); return 0; }
RenderBatch* RenderBatch_new(unsigned int objectSize, Texture* texture, unsigned int initialSize) { RenderBatch* ret = (RenderBatch*)malloc(sizeof(RenderBatch)); ret->data = BatchData_new(initialSize); ret->objectSize = objectSize; ret->dataSize = 0; ret->texture = texture; ret->drawables = LinkedList_new(); generateBuffer(&ret->vertexBufferIndex); generateBuffer(&ret->colorBufferIndex); generateBuffer(&ret->textureBufferIndex); return ret; }
END_TEST START_TEST(test_StoringMultipleElementsToListWorks) { LinkedList* list = LinkedList_new(); int elem1 = 1337; LinkedList_add(list, &elem1); char* elem2 = "theeta"; LinkedList_add(list, &elem2); int elem3 = 74; LinkedList_add(list, &elem3); char elem4 = 'a'; LinkedList_add(list, &elem4); ck_assert_int_eq(*(int*) LinkedList_get(list, 0), 1337); ck_assert_str_eq(*(char**) LinkedList_get(list, 1), "theeta"); ck_assert_int_eq(*(int*) LinkedList_get(list, 2), 74); ck_assert_int_eq(*(char*) LinkedList_get(list, 3), 'a'); ck_assert_int_eq(LinkedList_size(list), 4); }
int setSelectedMoveToBest(){ if (movesOfSelectedPiece){ LinkedList_free(movesOfSelectedPiece); } movesOfSelectedPiece = LinkedList_new(&PossibleMove_free); if (!movesOfSelectedPiece){ return -1; } PossibleMove* bestMove = getBestMove(); if (!bestMove){ return -1; } selectedX = bestMove->fromX; selectedY = bestMove->fromY; if(LinkedList_add(movesOfSelectedPiece, bestMove)){ return -1; } return 0; }
END_TEST START_TEST(test_RemovingElementFromListWorks) { LinkedList* list = LinkedList_new(); int elem1 = 1337; LinkedList_add(list, &elem1); char* elem2 = "theeta"; LinkedList_add(list, &elem2); int elem3 = 74; LinkedList_add(list, &elem3); ck_assert_int_eq(*(int*) LinkedList_get(list, 0), 1337); ck_assert_str_eq(*(char**) LinkedList_get(list, 1), "theeta"); ck_assert_int_eq(*(int*) LinkedList_get(list, 2), 74); LinkedList_remove(list, 1); ck_assert_int_eq(*(int*) LinkedList_get(list, 0), 1337); ck_assert_int_eq(*(int*) LinkedList_get(list, 1), 74); ck_assert_int_eq(LinkedList_size(list), 2); }
#define DEFINE_TEST(name) \ void test_##name() { \ #define END_TEST() \ } typedef struct { double height; int8_t age; bool gender; } Person; DEFINE_TEST(linked_list) LinkedList *list; list = LinkedList_new(); // LinkedList_initialize(list, "haha"); assert(list->fields->size == 0); Person a = {171.1, 16, true}; Person b = {188.8, 18, false}; Person c = {88.8, 8, false}; Person d = {53.8, 8, false}; Person e = {58.8, 8, true}; Person f = {68.8, 8, true}; Person g = {78.8, 8, false}; Person h = {98.8, 8, true}; $(list, addStart, &a); assert(_(list, size) == 1); $(list, addEnd, &b); assert(_(list, size) == 2); $(list, insertBefore, list->fields->tail, &c);
int Physics_init() { activeCollisionChecks = LinkedList_new(); return 0; }