test_amxc_array.c File Reference

#include <stdio.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <amxc/amxc_array.h>
#include "test_amxc_array.h"
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Functions
static void	amxc_reset_test_array ()
static void	amxc_check_array_it_delete (amxc_array_it_t *it)
int	test_amxc_array_setup (UNUSED void **state)
int	test_amxc_array_teardown (UNUSED void **state)
void	test_amxc_array_new_delete_null (UNUSED void **state)
void	test_amxc_array_init_clean_null (UNUSED void **state)
void	test_amxc_array_init_clean (UNUSED void **state)
void	test_amxc_array_clean_cb (UNUSED void **state)
void	test_amxc_array_get_at_null (UNUSED void **state)
void	test_amxc_array_get_at (UNUSED void **state)
void	test_amxc_array_get_first_null (UNUSED void **state)
void	test_amxc_array_get_first (UNUSED void **state)
void	test_amxc_array_get_first_empty (UNUSED void **state)
void	test_amxc_array_get_first_free_null (UNUSED void **state)
void	test_amxc_array_get_first_free (UNUSED void **state)
void	test_amxc_array_get_last_null (UNUSED void **state)
void	test_amxc_array_get_last (UNUSED void **state)
void	test_amxc_array_get_last_empty (UNUSED void **state)
void	test_amxc_array_get_last_free_null (UNUSED void **state)
void	test_amxc_array_get_last_free (UNUSED void **state)
void	test_amxc_array_get_first_free_full (UNUSED void **state)
void	test_amxc_array_get_last_free_full (UNUSED void **state)
void	test_amxc_array_it_get_next_null (UNUSED void **state)
void	test_amxc_array_it_get_next (UNUSED void **state)
void	test_amxc_array_it_get_next_free_null (UNUSED void **state)
void	test_amxc_array_it_get_next_free (UNUSED void **state)
void	test_amxc_array_it_get_previous_null (UNUSED void **state)
void	test_amxc_array_it_get_previous (UNUSED void **state)
void	test_amxc_array_it_get_previous_free_null (UNUSED void **state)
void	test_amxc_array_it_get_previous_free (UNUSED void **state)
void	test_amxc_array_it_get_data_null (UNUSED void **state)
void	test_amxc_array_it_get_data (UNUSED void **state)
void	test_amxc_array_is_empty_null (UNUSED void **state)
void	test_amxc_array_is_empty (UNUSED void **state)
void	test_amxc_array_size_null (UNUSED void **state)
void	test_amxc_array_size (UNUSED void **state)
void	test_amxc_array_capacity_null (UNUSED void **state)
void	test_amxc_array_capacity (UNUSED void **state)
void	test_amxc_array_grow_null (UNUSED void **state)
void	test_amxc_array_grow (UNUSED void **state)
void	test_amxc_array_shrink_null (UNUSED void **state)
void	test_amxc_array_shrink (UNUSED void **state)
void	test_amxc_array_shift_null (UNUSED void **state)
void	test_amxc_array_shift_left (UNUSED void **state)
void	test_amxc_array_shift_left_all (UNUSED void **state)
void	test_amxc_array_shift_right (UNUSED void **state)
void	test_amxc_array_shift_right_all (UNUSED void **state)
void	test_amxc_array_set_at_null (UNUSED void **state)
void	test_amxc_array_set_at (UNUSED void **state)
void	test_amxc_array_it_set_data_null (UNUSED void **state)
void	test_amxc_array_it_set_data (UNUSED void **state)
void	test_amxc_array_append_data_null (UNUSED void **state)
void	test_amxc_array_append_data (UNUSED void **state)
void	test_amxc_array_prepend_data_null (UNUSED void **state)
void	test_amxc_array_prepend_data (UNUSED void **state)
void	test_amxc_array_take_first_data_null (UNUSED void **state)
void	test_amxc_array_take_first_data (UNUSED void **state)
void	test_amxc_array_take_last_data_null (UNUSED void **state)
void	test_amxc_array_take_last_data (UNUSED void **state)
void	test_amxc_array_it_take_data_null (UNUSED void **state)
void	test_amxc_array_it_take_data (UNUSED void **state)
void	test_amxc_array_it_index_null (UNUSED void **state)
void	test_amxc_array_it_index (UNUSED void **state)
static int	test_cmp (amxc_array_it_t *it1, amxc_array_it_t *it2)
void	test_amxc_array_sort (UNUSED void **state)

Variables
static int	counter = 0
static amxc_array_t *	array1 = NULL
char	data [] = "abcdefghij"

Function Documentation

amxc_check_array_it_delete()

static void amxc_check_array_it_delete ( amxc_array_it_t *  it )

static

Definition at line 79 of file test_amxc_array.c.

                                                            {
    counter++;
    assert_ptr_not_equal(it->data, NULL);
}

amxc_reset_test_array()

static void amxc_reset_test_array ( )

static

Definition at line 71 of file test_amxc_array.c.

                                    {
    amxc_array_clean(array1, NULL);
    amxc_array_init(array1, 10);
    amxc_array_set_data_at(array1, 3, &data[3]);
    amxc_array_set_data_at(array1, 6, &data[6]);
    amxc_array_set_data_at(array1, 9, &data[9]);
}

test_amxc_array_append_data()

void test_amxc_array_append_data

(

UNUSED void **

state

)

Definition at line 726 of file test_amxc_array.c.

                                                      {
    amxc_array_it_t* it = amxc_array_append_data(array1, NULL);
    assert_ptr_equal(it, NULL);
    assert_int_equal(amxc_array_capacity(array1), 10);
    assert_int_equal(amxc_array_size(array1), 3);
    assert_int_equal(array1->last_used, 9);
 
    it = amxc_array_append_data(array1, &data[0]);
    assert_ptr_not_equal(it, NULL);
    assert_int_equal(amxc_array_capacity(array1), 13);
    assert_int_equal(amxc_array_size(array1), 4);
    assert_int_equal(array1->last_used, 10);
 
    it = amxc_array_append_data(array1, &data[1]);
    assert_ptr_not_equal(it, NULL);
    assert_int_equal(amxc_array_capacity(array1), 13);
    assert_int_equal(amxc_array_size(array1), 5);
    assert_int_equal(array1->last_used, 11);
 
    amxc_array_clean(array1, NULL);
    assert_int_equal(amxc_array_capacity(array1), 0);
 
    it = amxc_array_append_data(array1, &data[0]);
    assert_ptr_not_equal(it, NULL);
    assert_int_equal(amxc_array_capacity(array1), 3);
    assert_int_equal(amxc_array_size(array1), 1);
    assert_int_equal(array1->last_used, 0);
    assert_int_equal(array1->first_used, 0);
 
    it = amxc_array_append_data(array1, &data[1]);
    assert_ptr_not_equal(it, NULL);
    assert_int_equal(amxc_array_capacity(array1), 3);
    assert_int_equal(amxc_array_size(array1), 2);
    assert_int_equal(array1->last_used, 1);
    assert_int_equal(array1->first_used, 0);
 
    amxc_reset_test_array();
}

test_amxc_array_append_data_null()

void test_amxc_array_append_data_null

(

UNUSED void **

state

)

Definition at line 722 of file test_amxc_array.c.

                                                           {
    assert_ptr_equal(amxc_array_append_data(NULL, NULL), NULL);
}

test_amxc_array_capacity()

void test_amxc_array_capacity

(

UNUSED void **

state

)

Definition at line 481 of file test_amxc_array.c.

                                                   {
    assert_int_equal(amxc_array_capacity(array1), 10);
}

test_amxc_array_capacity_null()

void test_amxc_array_capacity_null

(

UNUSED void **

state

)

Definition at line 477 of file test_amxc_array.c.

                                                        {
    assert_int_equal(amxc_array_capacity(NULL), 0);
}

test_amxc_array_clean_cb()

void test_amxc_array_clean_cb

(

UNUSED void **

state

)

Definition at line 144 of file test_amxc_array.c.

                                                   {
    amxc_array_t array;
 
    // initialize array with 10 items
    assert_int_equal(amxc_array_init(&array, 10), 0);
    assert_ptr_not_equal(array.buffer, NULL);
    assert_int_equal(array.items, 10);
    counter = 0;
    amxc_array_clean(&array, NULL);
    assert_int_equal(counter, 0);
    assert_int_equal(array.items, 0);
 
    // initialize array with 10 items
    assert_int_equal(amxc_array_init(&array, 10), 0);
    assert_ptr_not_equal(array.buffer, amxc_check_array_it_delete);
    assert_int_equal(array.items, 10);
    const char data[10] = "1234567890";
    for(unsigned int index = 0; index < 10; index++) {
        assert_ptr_equal(amxc_array_set_data_at(&array, index, (void*) &data[index]), &array.buffer[index]);
    }
    counter = 0;
    amxc_array_clean(&array, amxc_check_array_it_delete);
    assert_int_equal(array.items, 0);
    assert_int_equal(counter, 10);
}

test_amxc_array_get_at()

void test_amxc_array_get_at

(

UNUSED void **

state

)

Definition at line 185 of file test_amxc_array.c.

                                                 {
    amxc_array_it_t* it = NULL;
    for(int i = 0; i < 10; i++) {
        it = amxc_array_get_at(array1, i);
        assert_ptr_equal(it, &array1->buffer[i]);
        assert_ptr_equal(it->array, array1);
        if((i == 0) || ((i % 3) != 0)) {
            assert_ptr_equal(it->data, NULL);
        } else {
            assert_ptr_equal(it->data, &data[i]);
        }
    }
}

test_amxc_array_get_at_null()

void test_amxc_array_get_at_null

(

UNUSED void **

state

)

Definition at line 170 of file test_amxc_array.c.

                                                      {
    amxc_array_t* array = NULL;
    amxc_array_it_t* it = NULL;
 
    it = amxc_array_get_at(NULL, 5);
    assert_ptr_equal(it, NULL);
 
    assert_int_equal(amxc_array_new(&array, 0), 0);
    it = amxc_array_get_at(array, 0);
    assert_ptr_equal(it, NULL);
 
    amxc_array_delete(&array, NULL);
    assert_ptr_equal(array, NULL);
}

test_amxc_array_get_first()

void test_amxc_array_get_first

(

UNUSED void **

state

)

Definition at line 205 of file test_amxc_array.c.

                                                    {
    amxc_array_it_t* it = NULL;
    it = amxc_array_get_first(array1);
    assert_ptr_equal(it, &array1->buffer[3]);
    assert_ptr_equal(it->array, array1);
    assert_ptr_equal(it->data, &data[3]);
}

test_amxc_array_get_first_empty()

void test_amxc_array_get_first_empty

(

UNUSED void **

state

)

Definition at line 213 of file test_amxc_array.c.

                                                          {
    amxc_array_t* array = NULL;
    assert_int_not_equal(amxc_array_new(&array, 10), -1);
    assert_ptr_not_equal(array, NULL);
    assert_ptr_not_equal(array->buffer, NULL);
 
    amxc_array_it_t* it = NULL;
    it = amxc_array_get_first(array);
    assert_ptr_equal(it, NULL);
 
    amxc_array_delete(&array, NULL);
}

test_amxc_array_get_first_free()

void test_amxc_array_get_first_free

(

UNUSED void **

state

)

Definition at line 232 of file test_amxc_array.c.

                                                         {
    amxc_array_it_t* it = NULL;
    it = amxc_array_get_first_free(array1);
    assert_ptr_equal(it, &array1->buffer[0]);
    assert_ptr_equal(it->array, array1);
    assert_ptr_equal(it->data, NULL);
}

test_amxc_array_get_first_free_full()

void test_amxc_array_get_first_free_full

(

UNUSED void **

state

)

Definition at line 282 of file test_amxc_array.c.

                                                              {
    for(int i = 0; i < 10; i++) {
        amxc_array_set_data_at(array1, i, &data[i]);
    }
 
    amxc_array_it_t* it = amxc_array_get_first_free(array1);
    assert_ptr_equal(it, NULL);
}

test_amxc_array_get_first_free_null()

void test_amxc_array_get_first_free_null

(

UNUSED void **

state

)

Definition at line 226 of file test_amxc_array.c.

                                                              {
    amxc_array_it_t* it = NULL;
    it = amxc_array_get_first_free(NULL);
    assert_ptr_equal(it, NULL);
}

test_amxc_array_get_first_null()

void test_amxc_array_get_first_null

(

UNUSED void **

state

)

Definition at line 199 of file test_amxc_array.c.

                                                         {
    amxc_array_it_t* it = NULL;
    it = amxc_array_get_first(NULL);
    assert_ptr_equal(it, NULL);
}

test_amxc_array_get_last()

void test_amxc_array_get_last

(

UNUSED void **

state

)

Definition at line 246 of file test_amxc_array.c.

                                                   {
    amxc_array_it_t* it = NULL;
    it = amxc_array_get_last(array1);
    assert_ptr_equal(it, &array1->buffer[9]);
    assert_ptr_equal(it->array, array1);
    assert_ptr_equal(it->data, &data[9]);
}

test_amxc_array_get_last_empty()

void test_amxc_array_get_last_empty

(

UNUSED void **

state

)

Definition at line 254 of file test_amxc_array.c.

                                                         {
    amxc_array_t* array = NULL;
    assert_int_not_equal(amxc_array_new(&array, 10), -1);
    assert_ptr_not_equal(array, NULL);
    assert_ptr_not_equal(array->buffer, NULL);
 
    amxc_array_it_t* it = NULL;
    it = amxc_array_get_last(array);
    assert_ptr_equal(it, NULL);
 
    amxc_array_delete(&array, NULL);
}

test_amxc_array_get_last_free()

void test_amxc_array_get_last_free

(

UNUSED void **

state

)

Definition at line 273 of file test_amxc_array.c.

                                                        {
    amxc_array_it_t* it = NULL;
    it = amxc_array_get_last_free(array1);
    assert_ptr_not_equal(it, NULL);
    assert_ptr_equal(it, &array1->buffer[8]);
    assert_ptr_equal(it->array, array1);
    assert_ptr_equal(it->data, NULL);
}

test_amxc_array_get_last_free_full()

void test_amxc_array_get_last_free_full

(

UNUSED void **

state

)

Definition at line 291 of file test_amxc_array.c.

                                                             {
    for(int i = 0; i < 10; i++) {
        amxc_array_set_data_at(array1, i, &data[i]);
    }
 
    amxc_array_it_t* it = amxc_array_get_last_free(array1);
    assert_ptr_equal(it, NULL);
}

test_amxc_array_get_last_free_null()

void test_amxc_array_get_last_free_null

(

UNUSED void **

state

)

Definition at line 267 of file test_amxc_array.c.

                                                             {
    amxc_array_it_t* it = NULL;
    it = amxc_array_get_last_free(NULL);
    assert_ptr_equal(it, NULL);
}

test_amxc_array_get_last_null()

void test_amxc_array_get_last_null

(

UNUSED void **

state

)

Definition at line 240 of file test_amxc_array.c.

                                                        {
    amxc_array_it_t* it = NULL;
    it = amxc_array_get_last(NULL);
    assert_ptr_equal(it, NULL);
}

test_amxc_array_grow()

void test_amxc_array_grow

(

UNUSED void **

state

)

Definition at line 489 of file test_amxc_array.c.

                                               {
    assert_int_equal(amxc_array_grow(array1, 10), 0);
    assert_int_equal(amxc_array_capacity(array1), 20);
    assert_int_equal(array1->first_used, 3);
    assert_int_equal(array1->last_used, 9);
 
    assert_int_equal(amxc_array_grow(array1, 0), 0);
    assert_int_equal(amxc_array_capacity(array1), 20);
    assert_int_equal(array1->first_used, 3);
    assert_int_equal(array1->last_used, 9);
 
    assert_int_equal(amxc_array_shrink(array1, 10, NULL), 0);
}

test_amxc_array_grow_null()

void test_amxc_array_grow_null

(

UNUSED void **

state

)

Definition at line 485 of file test_amxc_array.c.

                                                    {
    assert_int_equal(amxc_array_grow(NULL, 0), -1);
}

test_amxc_array_init_clean()

void test_amxc_array_init_clean

(

UNUSED void **

state

)

Definition at line 126 of file test_amxc_array.c.

                                                     {
    amxc_array_t array;
 
    // initialize array with 0 items
    assert_int_equal(amxc_array_init(&array, 0), 0);
    assert_ptr_equal(array.buffer, NULL);
    assert_int_equal(array.items, 0);
    amxc_array_clean(&array, NULL);
    assert_int_equal(array.items, 0);
 
    // initialize array with 10 items
    assert_int_equal(amxc_array_init(&array, 10), 0);
    assert_ptr_not_equal(array.buffer, NULL);
    assert_int_equal(array.items, 10);
    amxc_array_clean(&array, NULL);
    assert_int_equal(array.items, 0);
}

test_amxc_array_init_clean_null()

void test_amxc_array_init_clean_null

(

UNUSED void **

state

)

Definition at line 120 of file test_amxc_array.c.

                                                          {
    // passing NULL pointers should not lead to segfault
    assert_int_equal(amxc_array_init(NULL, 0), -1);
    amxc_array_clean(NULL, NULL);
}

test_amxc_array_is_empty()

void test_amxc_array_is_empty

(

UNUSED void **

state

)

Definition at line 463 of file test_amxc_array.c.

                                                   {
    assert_int_equal(amxc_array_is_empty(array1), false);
    amxc_array_clean(array1, NULL);
    assert_int_equal(amxc_array_is_empty(array1), true);
}

test_amxc_array_is_empty_null()

void test_amxc_array_is_empty_null

(

UNUSED void **

state

)

Definition at line 459 of file test_amxc_array.c.

                                                        {
    assert_int_equal(amxc_array_is_empty(NULL), true);
}

test_amxc_array_it_get_data()

void test_amxc_array_it_get_data

(

UNUSED void **

state

)

Definition at line 444 of file test_amxc_array.c.

                                                      {
    amxc_array_it_t* it = NULL;
    it = amxc_array_get_at(array1, 0);
    assert_ptr_equal(amxc_array_it_get_data(it), NULL);
 
    it = amxc_array_get_at(array1, 1);
    assert_ptr_equal(amxc_array_it_get_data(it), NULL);
 
    it = amxc_array_get_at(array1, 2);
    assert_ptr_equal(amxc_array_it_get_data(it), NULL);
 
    it = amxc_array_get_at(array1, 3);
    assert_ptr_equal(amxc_array_it_get_data(it), &data[3]);
}

test_amxc_array_it_get_data_null()

void test_amxc_array_it_get_data_null

(

UNUSED void **

state

)

Definition at line 440 of file test_amxc_array.c.

                                                           {
    assert_ptr_equal(amxc_array_it_get_data(NULL), NULL);
}

test_amxc_array_it_get_next()

void test_amxc_array_it_get_next

(

UNUSED void **

state

)

Definition at line 306 of file test_amxc_array.c.

                                                      {
    amxc_array_it_t* it = NULL;
    it = amxc_array_get_first(array1);
 
    it = amxc_array_it_get_next(it);
    assert_ptr_equal(it, &array1->buffer[6]);
    assert_ptr_equal(it->array, array1);
    assert_ptr_equal(it->data, &data[6]);
 
    it = amxc_array_it_get_next(it);
    assert_ptr_equal(it, &array1->buffer[9]);
    assert_ptr_equal(it->array, array1);
    assert_ptr_equal(it->data, &data[9]);
 
    it = amxc_array_it_get_next(it);
    assert_ptr_equal(it, NULL);
}

test_amxc_array_it_get_next_free()

void test_amxc_array_it_get_next_free

(

UNUSED void **

state

)

Definition at line 330 of file test_amxc_array.c.

                                                           {
    amxc_array_it_t* it = NULL;
    it = amxc_array_get_first(array1);
 
    it = amxc_array_it_get_next_free(it);
    assert_ptr_equal(it, &array1->buffer[4]);
    assert_ptr_equal(it->array, array1);
    assert_ptr_equal(it->data, NULL);
 
    it = amxc_array_it_get_next_free(it);
    assert_ptr_equal(it, &array1->buffer[5]);
    assert_ptr_equal(it->array, array1);
    assert_ptr_equal(it->data, NULL);
 
    it = amxc_array_it_get_next_free(it);
    assert_ptr_equal(it, &array1->buffer[7]);
    assert_ptr_equal(it->array, array1);
    assert_ptr_equal(it->data, NULL);
 
    it = amxc_array_it_get_next_free(it);
    assert_ptr_equal(it, &array1->buffer[8]);
    assert_ptr_equal(it->array, array1);
    assert_ptr_equal(it->data, NULL);
 
    it = amxc_array_it_get_next_free(it);
    assert_ptr_equal(it, NULL);
}

test_amxc_array_it_get_next_free_null()

void test_amxc_array_it_get_next_free_null

(

UNUSED void **

state

)

Definition at line 324 of file test_amxc_array.c.

                                                                {
    amxc_array_it_t* it = NULL;
    it = amxc_array_it_get_next_free(NULL);
    assert_ptr_equal(it, NULL);
}

test_amxc_array_it_get_next_null()

void test_amxc_array_it_get_next_null

(

UNUSED void **

state

)

Definition at line 300 of file test_amxc_array.c.

                                                           {
    amxc_array_it_t* it = NULL;
    it = amxc_array_it_get_next(NULL);
    assert_ptr_equal(it, NULL);
}

test_amxc_array_it_get_previous()

void test_amxc_array_it_get_previous

(

UNUSED void **

state

)

Definition at line 364 of file test_amxc_array.c.

                                                          {
    amxc_array_it_t* it = NULL;
    amxc_array_it_t* rit = amxc_array_set_data_at(array1, 1, &data[1]);
 
    it = amxc_array_get_last(array1);
 
    it = amxc_array_it_get_previous(it);
    assert_ptr_equal(it, &array1->buffer[6]);
    assert_ptr_equal(it->array, array1);
    assert_ptr_equal(it->data, &data[6]);
 
    it = amxc_array_it_get_previous(it);
    assert_ptr_equal(it, &array1->buffer[3]);
    assert_ptr_equal(it->array, array1);
    assert_ptr_equal(it->data, &data[3]);
 
    it = amxc_array_it_get_previous(it);
    assert_ptr_equal(it, &array1->buffer[1]);
    assert_ptr_equal(it->array, array1);
    assert_ptr_equal(it->data, &data[1]);
 
    it = amxc_array_it_get_previous(it);
    assert_ptr_equal(it, NULL);
 
    amxc_array_it_take_data(rit);
}

test_amxc_array_it_get_previous_free()

void test_amxc_array_it_get_previous_free

(

UNUSED void **

state

)

Definition at line 397 of file test_amxc_array.c.

                                                               {
    amxc_array_it_t* it = NULL;
    it = amxc_array_get_last(array1);
 
    it = amxc_array_it_get_previous_free(it);
    assert_ptr_equal(it, &array1->buffer[8]);
    assert_ptr_equal(it->array, array1);
    assert_ptr_equal(it->data, NULL);
 
    it = amxc_array_it_get_previous_free(it);
    assert_ptr_equal(it, &array1->buffer[7]);
    assert_ptr_equal(it->array, array1);
    assert_ptr_equal(it->data, NULL);
 
    it = amxc_array_it_get_previous_free(it);
    assert_ptr_equal(it, &array1->buffer[5]);
    assert_ptr_equal(it->array, array1);
    assert_ptr_equal(it->data, NULL);
 
    it = amxc_array_it_get_previous_free(it);
    assert_ptr_equal(it, &array1->buffer[4]);
    assert_ptr_equal(it->array, array1);
    assert_ptr_equal(it->data, NULL);
 
    it = amxc_array_it_get_previous_free(it);
    assert_ptr_equal(it, &array1->buffer[2]);
    assert_ptr_equal(it->array, array1);
    assert_ptr_equal(it->data, NULL);
 
    it = amxc_array_it_get_previous_free(it);
    assert_ptr_equal(it, &array1->buffer[1]);
    assert_ptr_equal(it->array, array1);
    assert_ptr_equal(it->data, NULL);
 
    it = amxc_array_it_get_previous_free(it);
    assert_ptr_equal(it, &array1->buffer[0]);
    assert_ptr_equal(it->array, array1);
    assert_ptr_equal(it->data, NULL);
 
    it = amxc_array_it_get_previous_free(it);
    assert_ptr_equal(it, NULL);
}

test_amxc_array_it_get_previous_free_null()

void test_amxc_array_it_get_previous_free_null

(

UNUSED void **

state

)

Definition at line 391 of file test_amxc_array.c.

                                                                    {
    amxc_array_it_t* it = NULL;
    it = amxc_array_it_get_previous_free(NULL);
    assert_ptr_equal(it, NULL);
}

test_amxc_array_it_get_previous_null()

void test_amxc_array_it_get_previous_null

(

UNUSED void **

state

)

Definition at line 358 of file test_amxc_array.c.

                                                               {
    amxc_array_it_t* it = NULL;
    it = amxc_array_it_get_previous(NULL);
    assert_ptr_equal(it, NULL);
}

test_amxc_array_it_index()

void test_amxc_array_it_index

(

UNUSED void **

state

)

Definition at line 893 of file test_amxc_array.c.

                                                   {
    for(unsigned int index = 0; index < amxc_array_capacity(array1); index++) {
        amxc_array_it_t* it = amxc_array_get_at(array1, index);
        assert_int_equal(amxc_array_it_index(it), index);
    }
}

test_amxc_array_it_index_null()

void test_amxc_array_it_index_null

(

UNUSED void **

state

)

Definition at line 889 of file test_amxc_array.c.

                                                        {
    assert_int_equal(amxc_array_it_index(NULL), 0);
}

test_amxc_array_it_set_data()

void test_amxc_array_it_set_data

(

UNUSED void **

state

)

Definition at line 699 of file test_amxc_array.c.

                                                      {
    amxc_array_it_t* it = NULL;
 
    amxc_array_clean(array1, NULL);
    amxc_array_init(array1, 9);
 
    it = amxc_array_get_at(array1, 0);
    assert_int_equal(amxc_array_it_set_data(it, &data[0]), 0);
    assert_int_equal(array1->first_used, 0);
 
    it = amxc_array_get_at(array1, 2);
    assert_int_equal(amxc_array_it_set_data(it, &data[2]), 0);
    assert_int_equal(array1->first_used, 0);
    assert_int_equal(array1->last_used, 2);
 
    assert_int_equal(amxc_array_grow(array1, 10), 0);
    it = amxc_array_get_at(array1, 15);
    assert_int_equal(amxc_array_it_set_data(it, &data[5]), 0);
    assert_int_equal(array1->last_used, 15);
 
    amxc_reset_test_array();
}

test_amxc_array_it_set_data_null()

void test_amxc_array_it_set_data_null

(

UNUSED void **

state

)

Definition at line 688 of file test_amxc_array.c.

                                                           {
    assert_int_equal(amxc_array_it_set_data(NULL, NULL), -1);
    amxc_array_it_t* it = amxc_array_get_at(array1, 2);
    assert_int_equal(amxc_array_it_set_data(it, NULL), -1);
    assert_int_equal(array1->first_used, 3);
    assert_int_equal(amxc_array_grow(array1, 10), 0);
    it = amxc_array_get_at(array1, 15);
    assert_int_equal(amxc_array_it_set_data(it, NULL), -1);
    assert_int_equal(array1->last_used, 9);
}

test_amxc_array_it_take_data()

void test_amxc_array_it_take_data

(

UNUSED void **

state

)

Definition at line 864 of file test_amxc_array.c.

                                                       {
    assert_ptr_equal(amxc_array_it_take_data(NULL), NULL);
    amxc_array_it_t* it = amxc_array_get_at(array1, 3);
    assert_ptr_equal(amxc_array_it_take_data(it), &data[3]);
    assert_int_equal(array1->first_used, 6);
    assert_int_equal(array1->last_used, 9);
 
    it = amxc_array_get_at(array1, 4);
    assert_ptr_equal(amxc_array_it_take_data(it), NULL);
    assert_int_equal(array1->first_used, 6);
    assert_int_equal(array1->last_used, 9);
 
    it = amxc_array_get_at(array1, 9);
    assert_ptr_equal(amxc_array_it_take_data(it), &data[9]);
    assert_int_equal(array1->first_used, 6);
    assert_int_equal(array1->last_used, 6);
 
    it = amxc_array_get_at(array1, 6);
    assert_ptr_equal(amxc_array_it_take_data(it), &data[6]);
    assert_int_equal(array1->first_used, 0);
    assert_int_equal(array1->last_used, 0);
 
    assert_int_equal(amxc_array_is_empty(array1), true);
}

test_amxc_array_it_take_data_null()

void test_amxc_array_it_take_data_null

(

UNUSED void **

state

)

Definition at line 860 of file test_amxc_array.c.

                                                            {
    assert_int_equal(amxc_array_it_index(NULL), 0);
}

test_amxc_array_new_delete_null()

void test_amxc_array_new_delete_null

(

UNUSED void **

state

)

Definition at line 111 of file test_amxc_array.c.

                                                          {
    amxc_array_t* array = NULL;
 
    // passing NULL pointers should not lead to segfault
    assert_int_not_equal(amxc_array_new(NULL, 0), 0);
    assert_ptr_equal(array, NULL);
    amxc_array_delete(NULL, NULL);
}

test_amxc_array_prepend_data()

void test_amxc_array_prepend_data

(

UNUSED void **

state

)

Definition at line 769 of file test_amxc_array.c.

                                                       {
    amxc_array_it_t* it = amxc_array_prepend_data(array1, NULL);
    assert_ptr_equal(it, NULL);
    assert_int_equal(amxc_array_capacity(array1), 10);
    assert_int_equal(amxc_array_size(array1), 3);
    assert_int_equal(array1->first_used, 3);
 
    it = amxc_array_prepend_data(array1, &data[0]);
    assert_ptr_not_equal(it, NULL);
    assert_int_equal(amxc_array_capacity(array1), 10);
    assert_int_equal(amxc_array_size(array1), 4);
    assert_int_equal(array1->first_used, 2);
 
    it = amxc_array_prepend_data(array1, &data[1]);
    assert_ptr_not_equal(it, NULL);
    assert_int_equal(amxc_array_capacity(array1), 10);
    assert_int_equal(amxc_array_size(array1), 5);
    assert_int_equal(array1->first_used, 1);
 
    amxc_array_clean(array1, NULL);
    assert_int_equal(amxc_array_capacity(array1), 0);
 
    it = amxc_array_prepend_data(array1, &data[0]);
    assert_ptr_not_equal(it, NULL);
    assert_int_equal(amxc_array_capacity(array1), 3);
    assert_int_equal(amxc_array_size(array1), 1);
    assert_int_equal(array1->last_used, 0);
    assert_int_equal(array1->first_used, 0);
 
    it = amxc_array_prepend_data(array1, &data[1]);
    assert_ptr_not_equal(it, NULL);
    assert_int_equal(amxc_array_capacity(array1), 6);
    assert_int_equal(amxc_array_size(array1), 2);
    assert_int_equal(array1->last_used, 3);
    assert_int_equal(array1->first_used, 2);
 
    amxc_reset_test_array();
}

test_amxc_array_prepend_data_null()

void test_amxc_array_prepend_data_null

(

UNUSED void **

state

)

Definition at line 765 of file test_amxc_array.c.

                                                            {
    assert_ptr_equal(amxc_array_prepend_data(NULL, NULL), NULL);
}

test_amxc_array_set_at()

void test_amxc_array_set_at

(

UNUSED void **

state

)

Definition at line 639 of file test_amxc_array.c.

                                                 {
    assert_ptr_equal(amxc_array_set_data_at(array1, 2, NULL), &array1->buffer[2]);
    assert_int_equal(array1->first_used, 3);
    assert_int_equal(array1->last_used, 9);
    assert_int_equal(amxc_array_is_empty(array1), false);
    assert_int_equal(amxc_array_size(array1), 3);
 
    assert_ptr_equal(amxc_array_set_data_at(array1, 9, NULL), &array1->buffer[9]);
    assert_int_equal(array1->first_used, 3);
    assert_int_equal(array1->last_used, 6);
    assert_int_equal(amxc_array_is_empty(array1), false);
    assert_int_equal(amxc_array_size(array1), 2);
 
    assert_ptr_equal(amxc_array_set_data_at(array1, 3, NULL), &array1->buffer[3]);
    assert_int_equal(array1->first_used, 6);
    assert_int_equal(array1->last_used, 6);
    assert_int_equal(amxc_array_is_empty(array1), false);
    assert_int_equal(amxc_array_size(array1), 1);
 
    assert_ptr_equal(amxc_array_set_data_at(array1, 6, NULL), &array1->buffer[6]);
    assert_int_equal(array1->first_used, 0);
    assert_int_equal(array1->last_used, 0);
    assert_int_equal(amxc_array_is_empty(array1), true);
    assert_int_equal(amxc_array_size(array1), 0);
 
    assert_ptr_equal(amxc_array_set_data_at(array1, 7, &data[7]), &array1->buffer[7]);
    assert_int_equal(array1->first_used, 7);
    assert_int_equal(array1->last_used, 7);
    assert_int_equal(amxc_array_is_empty(array1), false);
    assert_int_equal(amxc_array_size(array1), 1);
 
    assert_ptr_equal(amxc_array_set_data_at(array1, 2, &data[2]), &array1->buffer[2]);
    assert_int_equal(array1->first_used, 2);
    assert_int_equal(array1->last_used, 7);
    assert_int_equal(amxc_array_is_empty(array1), false);
    assert_int_equal(amxc_array_size(array1), 2);
 
    assert_ptr_equal(amxc_array_set_data_at(array1, 5, &data[5]), &array1->buffer[5]);
    assert_int_equal(array1->first_used, 2);
    assert_int_equal(array1->last_used, 7);
    assert_int_equal(amxc_array_is_empty(array1), false);
    assert_int_equal(amxc_array_size(array1), 3);
 
    assert_ptr_equal(amxc_array_set_data_at(array1, 10, NULL), NULL);
    assert_ptr_equal(amxc_array_set_data_at(array1, 11, NULL), NULL);
 
    amxc_reset_test_array();
}

test_amxc_array_set_at_null()

void test_amxc_array_set_at_null

(

UNUSED void **

state

)

Definition at line 635 of file test_amxc_array.c.

                                                      {
    assert_ptr_equal(amxc_array_set_data_at(NULL, 0, NULL), NULL);
}

test_amxc_array_setup()

int test_amxc_array_setup

(

UNUSED void **

state

)

Definition at line 84 of file test_amxc_array.c.

                                               {
    assert_int_equal(amxc_array_new(&array1, 10), 0);
    assert_ptr_not_equal(array1, NULL);
    assert_ptr_not_equal(array1->buffer, NULL);
 
    amxc_array_set_data_at(array1, 3, &data[3]);
    assert_int_equal(array1->first_used, 3);
    assert_int_equal(array1->last_used, 3);
 
    amxc_array_set_data_at(array1, 6, &data[6]);
    assert_int_equal(array1->first_used, 3);
    assert_int_equal(array1->last_used, 6);
 
    amxc_array_set_data_at(array1, 9, &data[9]);
    assert_int_equal(array1->first_used, 3);
    assert_int_equal(array1->last_used, 9);
 
    return 0;
}

test_amxc_array_shift_left()

void test_amxc_array_shift_left

(

UNUSED void **

state

)

Definition at line 544 of file test_amxc_array.c.

                                                     {
    assert_int_equal(amxc_array_shift_left(array1, 15, NULL), -1);
    assert_int_equal(amxc_array_shift_left(array1, 0, NULL), 0);
 
    assert_int_equal(amxc_array_shift_left(array1, 1, NULL), 0);
    assert_int_equal(amxc_array_capacity(array1), 10);
    assert_int_equal(amxc_array_size(array1), 3);
    assert_int_equal(array1->first_used, 2);
    assert_int_equal(array1->last_used, 8);
    assert_ptr_equal(array1->buffer[2].data, &data[3]);
    assert_ptr_equal(array1->buffer[3].data, NULL);
    assert_ptr_equal(array1->buffer[5].data, &data[6]);
    assert_ptr_equal(array1->buffer[6].data, NULL);
    assert_ptr_equal(array1->buffer[8].data, &data[9]);
    assert_ptr_equal(array1->buffer[9].data, NULL);
 
    assert_int_equal(amxc_array_shift_left(array1, 3, NULL), 0);
    assert_int_equal(amxc_array_capacity(array1), 10);
    assert_int_equal(amxc_array_size(array1), 2);
    assert_ptr_equal(array1->buffer[2].data, &data[6]);
    assert_ptr_equal(array1->buffer[5].data, &data[9]);
    assert_ptr_equal(array1->buffer[8].data, NULL);
    assert_int_equal(array1->first_used, 2);
    assert_int_equal(array1->last_used, 5);
 
    assert_int_equal(amxc_array_shift_left(array1, 6, NULL), 0);
    assert_int_equal(amxc_array_capacity(array1), 10);
    assert_int_equal(amxc_array_size(array1), 0);
    assert_int_equal(array1->first_used, 0);
    assert_int_equal(array1->last_used, 0);
}

test_amxc_array_shift_left_all()

void test_amxc_array_shift_left_all

(

UNUSED void **

state

)

Definition at line 576 of file test_amxc_array.c.

                                                         {
    assert_int_equal(amxc_array_shift_left(array1, 10, NULL), 0);
    assert_int_equal(amxc_array_capacity(array1), 10);
    assert_int_equal(amxc_array_size(array1), 0);
    assert_int_equal(array1->first_used, 0);
    assert_int_equal(array1->last_used, 0);
    assert_ptr_equal(array1->buffer[3].data, NULL);
    assert_ptr_equal(array1->buffer[6].data, NULL);
    assert_ptr_equal(array1->buffer[9].data, NULL);
 
    amxc_reset_test_array();
}

test_amxc_array_shift_null()

void test_amxc_array_shift_null

(

UNUSED void **

state

)

Definition at line 539 of file test_amxc_array.c.

                                                     {
    assert_int_equal(amxc_array_shift_left(NULL, 0, NULL), -1);
    assert_int_equal(amxc_array_shift_right(NULL, 0, NULL), -1);
}

test_amxc_array_shift_right()

void test_amxc_array_shift_right

(

UNUSED void **

state

)

Definition at line 589 of file test_amxc_array.c.

                                                      {
    assert_int_equal(amxc_array_shift_right(array1, 15, NULL), -1);
    assert_int_equal(amxc_array_shift_right(array1, 0, NULL), 0);
 
    assert_int_equal(amxc_array_shift_right(array1, 1, NULL), 0);
    assert_int_equal(amxc_array_capacity(array1), 10);
    assert_int_equal(amxc_array_size(array1), 2);
    assert_int_equal(array1->first_used, 4);
    assert_int_equal(array1->last_used, 7);
    assert_ptr_equal(array1->buffer[4].data, &data[3]);
    assert_ptr_equal(array1->buffer[3].data, NULL);
    assert_ptr_equal(array1->buffer[7].data, &data[6]);
    assert_ptr_equal(array1->buffer[6].data, NULL);
    assert_ptr_equal(array1->buffer[9].data, NULL);
 
    assert_int_equal(amxc_array_shift_right(array1, 3, NULL), 0);
    assert_int_equal(amxc_array_capacity(array1), 10);
    assert_int_equal(amxc_array_size(array1), 1);
    assert_ptr_equal(array1->buffer[7].data, &data[3]);
    assert_ptr_equal(array1->buffer[4].data, NULL);
    assert_int_equal(array1->first_used, 7);
    assert_int_equal(array1->last_used, 7);
 
    assert_int_equal(amxc_array_shift_right(array1, 3, NULL), 0);
    assert_int_equal(amxc_array_capacity(array1), 10);
    assert_int_equal(amxc_array_size(array1), 0);
    assert_int_equal(array1->first_used, 0);
    assert_int_equal(array1->last_used, 0);
 
    amxc_reset_test_array();
}

test_amxc_array_shift_right_all()

void test_amxc_array_shift_right_all

(

UNUSED void **

state

)

Definition at line 621 of file test_amxc_array.c.

                                                          {
    assert_int_equal(amxc_array_shift_right(array1, 10, NULL), 0);
    assert_int_equal(amxc_array_capacity(array1), 10);
    assert_int_equal(amxc_array_size(array1), 0);
    assert_int_equal(array1->first_used, 0);
    assert_int_equal(array1->last_used, 0);
    assert_ptr_equal(array1->buffer[3].data, NULL);
    assert_ptr_equal(array1->buffer[6].data, NULL);
    assert_ptr_equal(array1->buffer[9].data, NULL);
 
    amxc_reset_test_array();
}

test_amxc_array_shrink()

void test_amxc_array_shrink

(

UNUSED void **

state

)

Definition at line 507 of file test_amxc_array.c.

                                                 {
    assert_int_equal(amxc_array_shrink(array1, 15, NULL), -1);
 
    assert_int_equal(amxc_array_shrink(array1, 5, NULL), 0);
    assert_int_equal(amxc_array_capacity(array1), 5);
    assert_int_equal(array1->first_used, 3);
    assert_int_equal(array1->last_used, 3);
 
    assert_int_equal(amxc_array_shrink(array1, 3, NULL), 0);
    assert_int_equal(amxc_array_capacity(array1), 2);
    assert_int_equal(array1->first_used, 0);
    assert_int_equal(array1->last_used, 0);
 
    assert_int_equal(amxc_array_shrink(array1, 2, NULL), 0);
    assert_int_equal(amxc_array_capacity(array1), 0);
    assert_int_equal(array1->first_used, 0);
    assert_int_equal(array1->last_used, 0);
 
    assert_int_equal(amxc_array_grow(array1, 10), 0);
    amxc_array_set_data_at(array1, 3, &data[3]);
    assert_int_equal(array1->first_used, 3);
    assert_int_equal(array1->last_used, 3);
 
    amxc_array_set_data_at(array1, 6, &data[6]);
    assert_int_equal(array1->first_used, 3);
    assert_int_equal(array1->last_used, 6);
 
    amxc_array_set_data_at(array1, 9, &data[9]);
    assert_int_equal(array1->first_used, 3);
    assert_int_equal(array1->last_used, 9);
}

test_amxc_array_shrink_null()

void test_amxc_array_shrink_null

(

UNUSED void **

state

)

Definition at line 503 of file test_amxc_array.c.

                                                      {
    assert_int_equal(amxc_array_shrink(NULL, 0, NULL), -1);
}

test_amxc_array_size()

void test_amxc_array_size

(

UNUSED void **

state

)

Definition at line 473 of file test_amxc_array.c.

                                               {
    assert_int_equal(amxc_array_size(array1), 3);
}

test_amxc_array_size_null()

void test_amxc_array_size_null

(

UNUSED void **

state

)

Definition at line 469 of file test_amxc_array.c.

                                                    {
    assert_int_equal(amxc_array_size(NULL), 0);
}

test_amxc_array_sort()

void test_amxc_array_sort

(

UNUSED void **

state

)

Definition at line 913 of file test_amxc_array.c.

                                               {
    amxc_array_t array;
    const char data[16] = "KRATELEPUIMQCXOS";
    const char sorted[16] = "ACEEIKLMOPQRSTUX";
 
    const char data_sets[6][3] = {
        "ABC", "BCA", "CAB", "CBA", "BAC", "ACB"
    };
 
    // initialize array with 10 items
    assert_int_equal(amxc_array_init(&array, 20), 0);
    for(unsigned int index = 0; index < 16; index++) {
        assert_ptr_equal(amxc_array_set_data_at(&array, index, (void*) &data[index]), &array.buffer[index]);
    }
 
    assert_int_equal(amxc_array_sort(&array, test_cmp), 0);
    for(unsigned int index = 0; index < 16; index++) {
        char* d = amxc_array_it_get_data(amxc_array_get_at(&array, index));
        printf("%c\n", d[0]);
        assert_int_equal(d[0], sorted[index]);
    }
    amxc_array_clean(&array, NULL);
 
    assert_int_equal(amxc_array_init(&array, 40), 0);
    for(unsigned int index = 0; index < 32; index += 2) {
        assert_ptr_equal(amxc_array_set_data_at(&array, index, (void*) &data[index / 2]), &array.buffer[index]);
    }
 
    assert_int_equal(amxc_array_sort(&array, test_cmp), 0);
    for(unsigned int index = 0; index < 16; index++) {
        char* d = amxc_array_it_get_data(amxc_array_get_at(&array, index));
        printf("%c\n", d[0]);
        assert_int_equal(d[0], sorted[index]);
    }
    assert_int_equal(amxc_array_size(&array), 16);
    amxc_array_clean(&array, NULL);
 
    for(int sets = 0; sets < 6; sets++) {
        printf("\n %d - ", sets);
        assert_int_equal(amxc_array_init(&array, 20), 0);
        for(unsigned int index = 0; index < 3; index++) {
            assert_ptr_equal(amxc_array_set_data_at(&array, index, (void*) &data_sets[sets][index]), &array.buffer[index]);
        }
 
        assert_int_equal(amxc_array_sort(&array, test_cmp), 0);
        for(unsigned int index = 0; index < 3; index++) {
            char* d = amxc_array_it_get_data(amxc_array_get_at(&array, index));
            printf("%c", d[0]);
        }
        amxc_array_clean(&array, NULL);
    }
    printf("\n");
 
    assert_int_not_equal(amxc_array_sort(NULL, test_cmp), 0);
    assert_int_equal(amxc_array_init(&array, 20), 0);
    assert_int_not_equal(amxc_array_sort(&array, NULL), 0);
    assert_int_equal(amxc_array_sort(&array, test_cmp), 0);
    amxc_array_clean(&array, NULL);
    assert_int_equal(amxc_array_init(&array, 0), 0);
    assert_int_equal(amxc_array_sort(&array, test_cmp), 0);
    amxc_array_clean(&array, NULL);
}

test_amxc_array_take_first_data()

void test_amxc_array_take_first_data

(

UNUSED void **

state

)

Definition at line 812 of file test_amxc_array.c.

                                                          {
    char* d = amxc_array_take_first_data(array1);
    assert_ptr_equal(d, &data[3]);
    assert_int_equal(amxc_array_capacity(array1), 10);
    assert_int_equal(amxc_array_size(array1), 2);
    assert_int_equal(array1->first_used, 6);
 
    d = amxc_array_take_first_data(array1);
    assert_ptr_equal(d, &data[6]);
    assert_int_equal(amxc_array_capacity(array1), 10);
    assert_int_equal(amxc_array_size(array1), 1);
    assert_int_equal(array1->first_used, 9);
 
    d = amxc_array_take_first_data(array1);
    assert_ptr_equal(d, &data[9]);
    assert_int_equal(amxc_array_capacity(array1), 10);
    assert_int_equal(amxc_array_size(array1), 0);
    assert_int_equal(array1->first_used, 0);
 
    amxc_reset_test_array();
}

test_amxc_array_take_first_data_null()

void test_amxc_array_take_first_data_null

(

UNUSED void **

state

)

Definition at line 808 of file test_amxc_array.c.

                                                               {
    assert_ptr_equal(amxc_array_take_first_data(NULL), NULL);
}

test_amxc_array_take_last_data()

void test_amxc_array_take_last_data

(

UNUSED void **

state

)

Definition at line 838 of file test_amxc_array.c.

                                                         {
    char* d = amxc_array_take_last_data(array1);
    assert_ptr_equal(d, &data[9]);
    assert_int_equal(amxc_array_capacity(array1), 10);
    assert_int_equal(amxc_array_size(array1), 2);
    assert_int_equal(array1->last_used, 6);
 
    d = amxc_array_take_last_data(array1);
    assert_ptr_equal(d, &data[6]);
    assert_int_equal(amxc_array_capacity(array1), 10);
    assert_int_equal(amxc_array_size(array1), 1);
    assert_int_equal(array1->last_used, 3);
 
    d = amxc_array_take_last_data(array1);
    assert_ptr_equal(d, &data[3]);
    assert_int_equal(amxc_array_capacity(array1), 10);
    assert_int_equal(amxc_array_size(array1), 0);
    assert_int_equal(array1->first_used, 0);
 
    amxc_reset_test_array();
}

test_amxc_array_take_last_data_null()

void test_amxc_array_take_last_data_null

(

UNUSED void **

state

)

Definition at line 834 of file test_amxc_array.c.

                                                              {
    assert_ptr_equal(amxc_array_take_last_data(NULL), NULL);
}

test_amxc_array_teardown()

int test_amxc_array_teardown

(

UNUSED void **

state

)

Definition at line 104 of file test_amxc_array.c.

                                                  {
    amxc_array_delete(&array1, NULL);
 
    return 0;
}

test_cmp()

static int test_cmp ( amxc_array_it_t *  it1, amxc_array_it_t *  it2  )

static

Definition at line 900 of file test_amxc_array.c.

                                                                {
    char* d1 = amxc_array_it_get_data(it1);
    char* d2 = amxc_array_it_get_data(it2);
 
    if(d1[0] < d2[0]) {
        return -1;
    } else if(d1[0] > d2[0]) {
        return 1;
    }
 
    return 0;
}

Variable Documentation

array1

amxc_array_t* array1 = NULL

static

Definition at line 68 of file test_amxc_array.c.

counter

int counter = 0

static

Definition at line 66 of file test_amxc_array.c.

data

char data[] = "abcdefghij"

Definition at line 69 of file test_amxc_array.c.