Esempio n. 1
0
void test_deck_createDeck()
{
    struct Deck *deck;
    cut_assert_equal_pointer(NULL, deck_createDeck(MAX_GAME_PLAYERS + 1));
    cut_assert_equal_pointer(NULL, deck_createDeck(MIN_GAME_PLAYERS - 1));

    for (int i = MIN_GAME_PLAYERS; i <= MAX_GAME_PLAYERS; i++) {
        deck = deck_createDeck(i);
        int check = 0;
        if (deck == NULL)
            check++;
        cut_assert_equal_int(0, check);
        cut_assert_equal_int(i * MAX_CARDS, deck_getDeckSize(deck));
        
        int duplicates = 0;
        for (int j = 0; j < DECK_SIZE; j++)
            for (int k = 0; k < DECK_SIZE; k++)
                if (k != j && deck->cards[k] != NULL && deck->cards[j] != NULL
                    && deck->cards[k]->suit == deck->cards[j]->suit &&
                    deck->cards[k]->value == deck->cards[j]->value)
                    duplicates++;
        cut_assert_equal_int(0, duplicates);
        deck_deleteDeck(&deck);
    }
}
Esempio n. 2
0
void test_round_createRound()
{
    cut_assert_equal_pointer(NULL, round_createRound(MIN_CARDS - 1));
    cut_assert_equal_pointer(NULL, round_createRound(MAX_CARDS + 1));

    struct Round *round = round_createRound(MIN_CARDS);
    int check = 0;
    if (round == NULL)
        check++;
    cut_assert_equal_int(0, check);

    for (int i = 0; i < MAX_GAME_PLAYERS; i++) {
        cut_assert_equal_pointer(NULL, round->players[i]);
        cut_assert_equal_int(0, round->bids[i]);
        cut_assert_equal_int(0, round->handsNumber[i]);
        cut_assert_equal_int(0, round->pointsNumber[i]);
        cut_assert_equal_int(0, round->bonus[i]);
    }

    cut_assert_equal_int(MIN_CARDS, round->roundType);
    cut_assert_equal_pointer(NULL, round->hand);
    cut_assert_equal_pointer(NULL, round->trump);

    round_deleteRound(&round);
}
Esempio n. 3
0
void
test_fixture_function (gconstpointer data)
{
    const FixtureTestData *test_data = data;
    CutStartupFunction expected_startup_function = NULL;
    CutStartupFunction actual_startup_function = NULL;
    CutShutdownFunction expected_shutdown_function = NULL;
    CutShutdownFunction actual_shutdown_function = NULL;
    CutSetupFunction expected_setup_function = NULL;
    CutSetupFunction actual_setup_function = NULL;
    CutTeardownFunction expected_teardown_function = NULL;
    CutTeardownFunction actual_teardown_function = NULL;
    gchar *so_filename;

    loader = loader_new("fixture", test_data->file_name);
    test_case = cut_loader_load_test_case(loader);
    cut_assert(test_case);

    g_object_get(G_OBJECT(loader),
                 "so-filename", &so_filename,
                 NULL);
    module = g_module_open(so_filename,
                           G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL);
    g_free(so_filename);
    cut_assert_not_null(module);
    if (test_data->startup_function_name)
        cut_assert_true(g_module_symbol(module,
                                        test_data->startup_function_name,
                                        (gpointer)&expected_startup_function));
    if (test_data->setup_function_name)
        cut_assert_true(g_module_symbol(module,
                                        test_data->setup_function_name,
                                        (gpointer)&expected_setup_function));
    if (test_data->teardown_function_name)
        cut_assert_true(g_module_symbol(module,
                                        test_data->teardown_function_name,
                                        (gpointer)&expected_teardown_function));
    if (test_data->shutdown_function_name)
        cut_assert_true(g_module_symbol(module,
                                        test_data->shutdown_function_name,
                                        (gpointer)&expected_shutdown_function));

    g_object_get(G_OBJECT(test_case),
                 "startup-function", &actual_startup_function,
                 "setup-function", &actual_setup_function,
                 "teardown-function", &actual_teardown_function,
                 "shutdown-function", &actual_shutdown_function,
                 NULL);
    cut_assert_equal_pointer(expected_startup_function,
                             actual_startup_function);
    cut_assert_equal_pointer(expected_setup_function,
                             actual_setup_function);
    cut_assert_equal_pointer(expected_teardown_function,
                             actual_teardown_function);
    cut_assert_equal_pointer(expected_shutdown_function,
                             actual_shutdown_function);
}
Esempio n. 4
0
void
test_two_prepends(void)
{
    int x, y;
    List *l = list_prepend(NULL, &x);
    l = list_prepend(l, &y);
    cut_assert_not_null(l);
    cut_assert_equal_pointer(&y, l->data);
    cut_assert_not_null(l->next);
    cut_assert_equal_pointer(&x, l->next->data);
    cut_assert_null(l->next->next);
}
Esempio n. 5
0
void
test_atomic (void)
{
  gint i;
  gint atomic = -5;
  gpointer atomic_pointer = NULL;
  gpointer biggest_pointer = (gpointer)((gsize)atomic_pointer - 1);

  for (i = 0; i < 15; i++)
    g_atomic_int_inc (&atomic);
  cut_assert_equal_int (10, atomic);
  for (i = 0; i < 9; i++)
    cut_assert (!g_atomic_int_dec_and_test (&atomic));
  cut_assert (g_atomic_int_dec_and_test (&atomic));
  cut_assert_equal_int (0, atomic);

  cut_assert_equal_int (0, g_atomic_int_exchange_and_add (&atomic, 5));
  cut_assert_equal_int (5, atomic);

  cut_assert_equal_int (5, g_atomic_int_exchange_and_add (&atomic, -10));
  cut_assert_equal_int (-5, atomic);

  g_atomic_int_add (&atomic, 20);
  cut_assert_equal_int (15, atomic);

  g_atomic_int_add (&atomic, -35);
  cut_assert_equal_int (-20, atomic);

  cut_assert_equal_int (atomic, g_atomic_int_get (&atomic));

  cut_assert (g_atomic_int_compare_and_exchange (&atomic, -20, 20));
  cut_assert_equal_int (20, atomic);
  
  cut_assert (!g_atomic_int_compare_and_exchange (&atomic, 42, 12));
  cut_assert_equal_int (20, atomic);
  
  cut_assert (g_atomic_int_compare_and_exchange (&atomic, 20, G_MAXINT));
  cut_assert_equal_int (G_MAXINT, atomic);

  cut_assert (g_atomic_int_compare_and_exchange (&atomic, G_MAXINT, G_MININT));
  cut_assert_equal_int (G_MININT, atomic);

  cut_assert (g_atomic_pointer_compare_and_exchange (&atomic_pointer, 
						     NULL, biggest_pointer));
  cut_assert_equal_pointer (biggest_pointer, atomic_pointer);

  cut_assert_equal_pointer (atomic_pointer, g_atomic_pointer_get (&atomic_pointer));

  cut_assert (g_atomic_pointer_compare_and_exchange (&atomic_pointer, 
						     biggest_pointer, NULL));
  cut_assert (biggest_pointer);
}
Esempio n. 6
0
void
test_two_appends(void)
{
    List *l = list_append(NULL, INT_TO_POINTER(1));
    cut_assert_not_null(l);
    cut_assert_null(l->next);
    cut_assert_equal_pointer(INT_TO_POINTER(1), l->data);

    l = list_append(l, INT_TO_POINTER(2));
    cut_assert_equal_pointer(INT_TO_POINTER(1), l->data);
    cut_assert_not_null(l->next);
    cut_assert_equal_pointer(INT_TO_POINTER(2), l->next->data);
    cut_assert_null(l->next->next);
}
Esempio n. 7
0
void test_deck_createCard()
{
    struct Card *card;
    cut_assert_equal_pointer(NULL, deck_createCard(SuitEnd, VALUES[0]));
    cut_assert_equal_pointer(NULL, deck_createCard(DIAMONDS, -1));
    cut_assert_equal_pointer(NULL, deck_createCard(SuitEnd, -1));

    for (int i = 0; i < SuitEnd; i++)
        for (int j = 0; VALUES[j] != -1; j++) {
            card = deck_createCard(i, VALUES[j]);
            cut_assert_equal_int(card->suit, i);
            cut_assert_equal_int(card->value, VALUES[j]);
            deck_deleteCard(&card);
        }
}
Esempio n. 8
0
void test_hand_createHand()
{
    struct Hand *hand = hand_createHand();
    int check = 0;
    if (hand != NULL)
        check++;
    cut_assert_equal_int(1, check);

    for (int i = 0; i < MAX_GAME_PLAYERS; i++) {
        cut_assert_equal_pointer(NULL, hand->cards[i]);
        cut_assert_equal_pointer(NULL, hand->players[i]);
    }

    hand_deleteHand(&hand);
}
Esempio n. 9
0
void
test_mb_aiom_prep_pwrite(void)
{
    char buf[512];
    int fd = 3;
    long long offset = 23456;
    struct iocb *_iocb;

    aiom = mb_aiom_make(64);

    cut_assert_equal_int(0, aiom->nr_pending);

    _iocb = mb_aiom_prep_pwrite(aiom, fd, buf, 512, offset);

    cut_assert_equal_int(1, aiom->nr_pending);

    cut_assert_not_null(_iocb);
    cut_assert_equal_int(63, mb_aiom_nr_submittable(aiom));

    cut_assert_equal_int(IO_CMD_PWRITE, _iocb->aio_lio_opcode);
    cut_assert_equal_int(fd, _iocb->aio_fildes);
    cut_assert_equal_pointer(buf, _iocb->u.c.buf);
    cut_assert_equal_int(512, _iocb->u.c.nbytes);
    cut_assert(offset == _iocb->u.c.offset);
}
Esempio n. 10
0
void
test_mb_aiom_submit_pwrite(void)
{
    mb_mock_init();

    char buf[512];
    int fd = 123;

    aiom = mb_aiom_make(64);

    mb_mock_assert_will_call("io_submit",
                             MOCK_ARG_PTR, aiom->context,
                             MOCK_ARG_INT, 1,
                             MOCK_ARG_SKIP, NULL,
                             NULL);
    struct iocb *head = aiom->cbpool->head->data;

    cut_assert_equal_int(0, aiom->nr_inflight);

    cut_assert_equal_int(1, mb_aiom_submit_pwrite(aiom, fd, buf, 512, 9999));

    cut_assert_equal_int(1, aiom->nr_inflight);

    cut_assert_equal_int(IO_CMD_PWRITE, head->aio_lio_opcode);
    cut_assert_equal_int(fd, head->aio_fildes);
    cut_assert_equal_pointer(buf, head->u.c.buf);
    cut_assert_equal_int(512, head->u.c.nbytes);
    cut_assert(9999 == head->u.c.offset);

    cut_assert_equal_int(63, mb_aiom_nr_submittable(aiom));

    mb_mock_finish();
}
Esempio n. 11
0
void test_hand_addCard()
{
    struct Hand *hand = hand_createHand();
    struct Deck *deck = deck_createDeck(MAX_GAME_PLAYERS);
    struct Player *players[MAX_GAME_PLAYERS + 1];   

    for (int i = 0; i < MAX_GAME_PLAYERS; i++) {
        players[i] = player_createPlayer("A", i);
        hand_addPlayer(hand, players[i]);
        struct Card *card  = deck->cards[i];
        struct Card *card2 = deck->cards[i];
        cut_assert_equal_int(FUNCTION_NO_ERROR, 
                            hand_addCard(hand, players[i], &(deck->cards[i])));
        cut_assert_equal_pointer(NULL, deck->cards[i]);
        int check = 0;
        for (int j = 0; j < MAX_GAME_PLAYERS; j++)
            if (players[i] == hand->players[j] && card == hand->cards[j])
                check++;
        cut_assert_equal_int(1, check);
    }
    players[MAX_GAME_PLAYERS] = player_createPlayer("A", 1);
    cut_assert_equal_int(NOT_FOUND,
                         hand_addCard(hand, players[MAX_GAME_PLAYERS],
                                      &deck->cards[MAX_GAME_PLAYERS]));

    for (int i = 0; i <= MAX_GAME_PLAYERS; i++)
        player_deletePlayer(&players[i]);
    deck_deleteDeck(&deck);
    hand_deleteHand(&hand);
}
Esempio n. 12
0
void test_round_distributeDeck()
{
    struct Round *round = round_createRound(MAX_CARDS);
    struct Deck  *deck  = deck_createDeck(MAX_GAME_PLAYERS);
    struct Player *players[MAX_GAME_PLAYERS];

    cut_assert_equal_int(ROUND_NULL, round_distributeDeck(NULL, deck));
    cut_assert_equal_int(DECK_NULL, round_distributeDeck(round, NULL));

    for (int i = 0; i < MAX_GAME_PLAYERS; i++) {
        players[i] = player_createPlayer("A", i);
        round_addPlayer(round, players[i]);
    }

    cut_assert_equal_int(FUNCTIOON_NO_ERROR, round_distributeDeck(round, deck));
    cut_assert_equal_pointer(NULL, round->trump);
    for (int i = 0; i < MAX_GAME_PLAYERS; i++) {
        int nullCards = 0;
        int duplicate = 0;
        for (int j = 0; j < MAX_CARDS; j++)
            if (round->players[i]->hand[j] == NULL)
                nullCards++;
        for (int j = 0; j < MAX_CARDS - 1; j++)
            for (int k = j + 1; k < MAX_CARDS; k++)
                if (round->players[i]->hand[j] == round->players[i]->hand[k])
                    duplicate++;
        cut_assert_equal_int(0, nullCards);
        cut_assert_equal_int(0, duplicate);
    }

    round_deleteRound(&round);
    deck_deleteDeck(&deck);
    for (int i = 0; i < MAX_GAME_PLAYERS; i++)
        player_deletePlayer(&players[i]);
}
Esempio n. 13
0
void
test_flag_normalize(void)
{
  default_flags = GRN_SNIP_NORMALIZE;
  cut_assert_open_snip();
  cut_assert_equal_pointer(GRN_NORMALIZER_AUTO,
                           grn_snip_get_normalizer(&context, snip));
}
Esempio n. 14
0
void test_round_deleteRound()
{
    struct Round *round = round_createRound(MIN_CARDS);
    cut_assert_equal_int(POINTER_NULL, round_deleteRound(NULL));
    cut_assert_equal_int(FUNCTIOON_NO_ERROR, round_deleteRound(&round));
    cut_assert_equal_int(ROUND_NULL, round_deleteRound(&round));
    cut_assert_equal_pointer(NULL, round);
}
Esempio n. 15
0
void test_deck_deleteCard()
{
    struct Card *card = deck_createCard(DIAMONDS, VALUES[0]);
    cut_assert_equal_int(POINTER_NULL, deck_deleteCard(NULL));
    cut_assert_equal_int(FUNCTIOON_NO_ERROR, deck_deleteCard(&card));
    cut_assert_equal_pointer(NULL, card);
    cut_assert_equal_int(CARD_NULL, deck_deleteCard(&card));
}
Esempio n. 16
0
void
test_reverse_list(void)
{
    List *l = list_prepend(NULL, INT_TO_POINTER(1));
    l = list_prepend(l, INT_TO_POINTER(2));
    l = list_prepend(l, INT_TO_POINTER(3));

    l = list_reverse(l);

    cut_assert_not_null(l);
    cut_assert_equal_pointer(INT_TO_POINTER(1), l->data);
    cut_assert_not_null(l->next);
    cut_assert_equal_pointer(INT_TO_POINTER(2), l->next->data);
    cut_assert_not_null(l->next->next);
    cut_assert_equal_pointer(INT_TO_POINTER(3), l->next->next->data);
    cut_assert_null(l->next->next->next);
}
Esempio n. 17
0
void test_deck_deleteDeck()
{
    cut_assert_equal_int(POINTER_NULL, deck_deleteDeck(NULL));
    struct Deck *deck = deck_createDeck(MAX_GAME_PLAYERS);
    cut_assert_equal_int(FUNCTIOON_NO_ERROR, deck_deleteDeck(&deck));
    cut_assert_equal_pointer(NULL, deck);
    cut_assert_equal_int(DECK_NULL, deck_deleteDeck(&deck));
}
Esempio n. 18
0
void test_player_deletePlayer()
{
    struct Player *player = player_createPlayer("A", 1);
    cut_assert_equal_int(POINTER_NULL, player_deletePlayer(NULL));
    cut_assert_equal_int(FUNCTION_NO_ERROR, player_deletePlayer(&player));
    cut_assert_equal_pointer(NULL, player);
    cut_assert_equal_int(PLAYER_NULL, player_deletePlayer(&player));
}
Esempio n. 19
0
void test_hand_deleteHand()
{
    struct Hand *hand = hand_createHand();
    cut_assert_equal_int(FUNCTION_NO_ERROR, hand_deleteHand(&hand));
    cut_assert_equal_pointer(NULL, hand);
    cut_assert_equal_int(HAND_NULL, hand_deleteHand(&hand));
    cut_assert_equal_int(POINTER_NULL, hand_deleteHand(NULL));
}
Esempio n. 20
0
void
test_prepending_into_null(void)
{
    int x = 0;
    List *l = list_prepend(NULL, &x);
    cut_assert_not_null(l);
    cut_assert_null(l->next);
    cut_assert_equal_pointer(&x, l->data);
}
Esempio n. 21
0
void test_round_addTrump()
{
    struct Round *round  = round_createRound(MIN_CARDS);
    struct Card  *trump  = deck_createCard(DIAMONDS, VALUES[0]);
    struct Card  *trump2 = trump;

    cut_assert_equal_int(ROUND_NULL, round_addTrump(NULL, &trump));
    cut_assert_equal_int(POINTER_NULL, round_addTrump(round, NULL));
    cut_assert_operator_int(0, >, round_addTrump(NULL, NULL));
    cut_assert_equal_int(FUNCTIOON_NO_ERROR, round_addTrump(round, &trump));
    cut_assert_equal_pointer(NULL, trump);
    cut_assert_equal_pointer(trump2, round->trump);
    cut_assert_equal_int(FUNCTIOON_NO_ERROR, round_addTrump(round, &trump));
    cut_assert_equal_pointer(NULL, trump);
    cut_assert_equal_pointer(NULL, round->trump);

    round_deleteRound(&round);
}
Esempio n. 22
0
void
test_mb_res_pool_make(void)
{
    cbpool = mb_res_pool_make(64);
    cut_assert_not_null(cbpool);
    cut_assert_not_null(cbpool->ring);
    cut_assert_not_null(cbpool->head);
    cut_assert_not_null(cbpool->tail);
    cut_assert_equal_int(64, cbpool->size);
    cut_assert_equal_pointer(cbpool->ring, cbpool->head);
    cut_assert_false(cbpool->ring == cbpool->tail);

    // check it is a ring
    int i;
    mb_res_pool_cell_t *cell;
    for(cell = cbpool->ring, i = 0; i < 64; cell = cell->next, i++){}
    cut_assert_equal_pointer(cbpool->ring, cell);

    // initially a pool is empty
    cut_assert_equal_int(0, cbpool->nr_avail);
}
Esempio n. 23
0
void test_round_addPlayersInHand()
{
    struct Round *round = round_createRound(MIN_CARDS);
    cut_assert_equal_int(ROUND_NULL, round_addPlayersInHand(NULL, 0));
    cut_assert_equal_int(ILLEGAL_VALUE, round_addPlayersInHand(round, -1));
    cut_assert_equal_int(ILLEGAL_VALUE,
                         round_addPlayersInHand(round, MAX_GAME_PLAYERS + 1));
    cut_assert_equal_int(HAND_NULL, round_addPlayersInHand(round, 0));
    round->hand = hand_createHand();
    cut_assert_equal_int(INSUFFICIENT_PLAYERS,
                         round_addPlayersInHand(round, 0));

    struct Player *players[MAX_GAME_PLAYERS];
    for (int i = 0; i < MAX_GAME_PLAYERS; i++) {
        players[i] = player_createPlayer("A", i);
        round_addPlayer(round, players[i]);
    }

    for (int i = 0 ; i < MAX_GAME_PLAYERS; i++) {
        cut_assert_equal_int(FUNCTIOON_NO_ERROR,
                             round_addPlayersInHand(round, i));
        int position = 0;
        for (int j = i; j < MAX_GAME_PLAYERS; j++) {
            cut_assert_equal_pointer(round->players[j],
                                     round->hand->players[position]);
            position++;
        }
        for (int j = 0; j < i; j++) {
            cut_assert_equal_pointer(round->players[j],
                                     round->hand->players[position]);
            position++;
        }
        hand_deleteHand(&round->hand);
        round->hand = hand_createHand();
    }

    round_deleteRound(&round);
    for(int i = 0; i < MAX_GAME_PLAYERS; i++)
        player_deletePlayer(&players[i]);
}
Esempio n. 24
0
void
test_normalizer_accessor(void)
{
  grn_obj *normalizer;

  cut_assert_open_snip();
  cut_assert_null(grn_snip_get_normalizer(&context, snip));

  normalizer = grn_ctx_get(&context, "NormalizerNFKC51", -1);
  cut_assert_not_null(normalizer);

  grn_snip_set_normalizer(&context, snip, normalizer);
  cut_assert_equal_pointer(normalizer, grn_snip_get_normalizer(&context, snip));
}
Esempio n. 25
0
void
test_get_test_suite (void)
{
    result = cut_test_result_new(CUT_TEST_RESULT_SUCCESS,
                                 NULL, NULL, NULL, NULL, NULL,
                                 NULL, NULL, NULL);
    cut_assert_null(cut_test_result_get_test_suite(result));

    suite = cut_test_suite_new_empty();
    cut_test_result_set_test_suite(result, suite);
    cut_assert_equal_pointer(suite, cut_test_result_get_test_suite(result));

    cut_test_result_set_test_suite(result, NULL);
    cut_assert_null(cut_test_result_get_test_suite(result));
}
Esempio n. 26
0
void
test_table(gpointer data)
{
  grn_obj *table;
  grn_obj_flags flags = GPOINTER_TO_INT(data);
  grn_table_cursor *cursor;

  table = grn_table_create(context, NULL, 0, NULL,
                           flags,
                           get_object("ShortText"),
                           NULL);
  cursor = grn_table_cursor_open(context, table, NULL, 0, NULL, 0, 0, -1, 0);
  /* FIXME: grn_test_assert_equal_object() */
  cut_assert_equal_pointer(table, grn_table_cursor_table(context, cursor));
}
Esempio n. 27
0
void
test_table(gpointer data)
{
  grn_obj *table;
  grn_obj_flags flags = GPOINTER_TO_INT(data);
  grn_table_cursor *cursor;

  table = grn_table_create(&context, NULL, 0, NULL,
                           flags,
                           OBJECT("<shorttext>"),
                           0);
  cursor = grn_table_cursor_open(&context, table, NULL, 0, NULL, 0, 0);
  /* FIXME: grn_test_assert_equal_object() */
  cut_assert_equal_pointer(table, grn_table_cursor_table(&context, cursor));
}
Esempio n. 28
0
void test_round_addHand()
{
    struct Round *round = round_createRound(MIN_CARDS);
    struct Hand  *hand  = hand_createHand();

    cut_assert_equal_int(ROUND_NULL, round_addHand(NULL, &hand));
    cut_assert_equal_int(POINTER_NULL, round_addHand(round, NULL));
    cut_assert_operator_int(0, >, round_addHand(NULL, NULL));
    cut_assert_equal_int(FUNCTIOON_NO_ERROR, round_addHand(round, &hand));
    cut_assert_equal_int(HAND_NULL, round_addHand(round, &hand));
    cut_assert_equal_pointer(NULL, hand);
    int check = 0;
    if (round->hand == NULL)
        check++;
    cut_assert_equal_int(0, check);

    round_deleteRound(&round);
}
Esempio n. 29
0
void test_player_createPlayer()
{
    struct Player *player;
    cut_assert_equal_pointer(NULL, player_createPlayer(NULL, 1));

    char *name[] = {"A", "B", "C", "D", "E", "F", "G", "H", "I", "J" };
    for (int i = 0; i < 10; i++) {
        player = player_createPlayer(name[i], i);
        int check = 0;
        if (player == NULL)
            check++;
        cut_assert_equal_int(0, check);
        cut_assert_equal_int(i, player->isHuman);
        cut_assert_equal_string(name[i], player->name);
        for (int j = 0; j < MAX_CARDS; j++)
            if (player->hand[j] != NULL)
                check++;
        cut_assert_equal_int(0, check);
        player_deletePlayer(&player);
    }
}
Esempio n. 30
0
void test_round_getPlayerWhichWonHand()
{
    struct Round *round = round_createRound(1);
    struct Player *player;
    struct Card *cards[6];

    cut_assert_equal_pointer(NULL, round_getPlayerWhichWonHand(NULL));
    cut_assert_equal_pointer(NULL, round_getPlayerWhichWonHand(round));
    round->hand = hand_createHand();
    cut_assert_equal_pointer(NULL, round_getPlayerWhichWonHand(round));

    for (int i = 0; i < 6; i++) {
        player = player_createPlayer("A", i);
        round_addPlayer(round, player);
        hand_addPlayer(round->hand, player);
        player = NULL;
    }

    cards[0] = deck_createCard(DIAMONDS, 6);
    cards[1] = deck_createCard(DIAMONDS, 7);
    cards[2] = deck_createCard(DIAMONDS, 8);
    cards[3] = deck_createCard(DIAMONDS, 15);
    cards[4] = deck_createCard(CLUBS, 14);
    cards[5] = deck_createCard(SPADES, 7);

    cut_assert_equal_pointer(NULL, round_getPlayerWhichWonHand(round));

    for (int i = 0; i < 6; i++)
        hand_addCard(round->hand, round->hand->players[i], &cards[i]);

    struct Card *trump = deck_createCard(DIAMONDS, 14);

    cut_assert_equal_pointer(round->hand->players[3],
                             round_getPlayerWhichWonHand(round));
    round->trump = trump;
    cut_assert_equal_pointer(round->hand->players[3],
                             round_getPlayerWhichWonHand(round));
    round->trump->suit = CLUBS;
    cut_assert_equal_pointer(round->hand->players[4],
                             round_getPlayerWhichWonHand(round));
    round->trump->suit = SPADES;
    cut_assert_equal_pointer(round->hand->players[5],
                             round_getPlayerWhichWonHand(round));
    round->trump->suit = HEARTS;
    cut_assert_equal_pointer(round->hand->players[3],
                             round_getPlayerWhichWonHand(round));
    round->hand->cards[0]->suit = HEARTS;
    cut_assert_equal_pointer(round->hand->players[0],
                             round_getPlayerWhichWonHand(round));
    round->trump = NULL;
    cut_assert_equal_pointer(round->hand->players[0],
                             round_getPlayerWhichWonHand(round));
    round->trump = trump;
    round->trump->suit = DIAMONDS;
    cut_assert_equal_pointer(round->hand->players[3],
                             round_getPlayerWhichWonHand(round));
    round->trump->suit = CLUBS;
    cut_assert_equal_pointer(round->hand->players[4],
                             round_getPlayerWhichWonHand(round));
    round->trump->suit = SPADES;
    cut_assert_equal_pointer(round->hand->players[5],
                             round_getPlayerWhichWonHand(round));

    for (int i = 0; i < 6; i++)
        player_deletePlayer(&round->players[i]);

    round_deleteRound(&round);
}