clist_test.c

//#define game // include this symbol if platform_conio.h is available
#include <stdio.h>
#include <string.h>

#include "clist.h"

#define SUCCESS 0
#define FAIL 1

typedef struct {
    const char* file;
    int line;
    char message[240];
} TestErrorResult;

typedef TestErrorResult* (*TestFunction)();

typedef struct {
    const char * name;
    TestFunction func;
} TestFunctionEntry;

#ifdef game
#include "platform_conio.h"
int WaitJustOneMomentTillKeyPress(int milliseconds) {
    int soon = platform_upTimeMS() + milliseconds;
    while(platform_upTimeMS() < soon && !platform_kbhit()) {
        platform_sleep(1);
    }
    if (platform_kbhit()) {
        platform_getchar();
        return 1;
    }
    return 0;
}
void Success(const char* message, int pause, int flashes) {
    int delay = pause / (flashes * 2);
    for(int i = 0; i < flashes; ++i) {
        platform_setColor(PLATFORM_COLOR_GREEN|PLATFORM_COLOR_INTENSITY, -1);
        printf("\r%s",message);
        if(WaitJustOneMomentTillKeyPress(delay)) break;
        platform_setColor(PLATFORM_COLOR_GREEN, -1);
        printf("\r%s",message);
        if(WaitJustOneMomentTillKeyPress(delay)) break;
    }
    platform_setColor(PLATFORM_COLOR_INTENSITY, -1);
    printf("\r%s",message);
    platform_setColor(-1, -1);
}
#else
void Success(const char* message, int pause, int flashes) {}
#endif

static TestErrorResult _err;

#define ERR(format, ...)    (\
    _err.file = __FILE__,\
    _err.line = __LINE__ ,\
    sprintf(_err.message, format, ##__VA_ARGS__),\
    &_err\
)

#define IMPLEMENT_CHECK(result) if (result == Listfloat_NotImplemented) return ERR("function not implemented!");

int AppendArrayToCharBuffer(char* buffer, int bufferSize, float* list, int listCount, int maxDigits) {
    if (list == NULL || listCount == 0) { return SUCCESS; }
    char smallBuffer[16];
    int index = 0;

    for(int i = 0; i < bufferSize; ++i) {
        if (buffer[i] == '\0') {
            index = i;
            break;
        }
    }
    for(int i = 0; i < listCount; ++i) {
        sprintf(smallBuffer, "%f", list[i]);
        int len = strlen(smallBuffer);
        if (len > maxDigits) {
            len = maxDigits;
        }
        if (index+len >= bufferSize) { break; }
        for (int j = 0; j < len; ++j) {
            buffer[index+j] = smallBuffer[j];
        }
        index += len;
        if (index+1 >= bufferSize) { break; }
        buffer[index++] = ' ';
        if (index+1 >= bufferSize) { break; }
    }
    buffer[index] = '\0';
    return SUCCESS;
}

#define LISTERR(list,format, ...)   (_err.file = __FILE__, _err.line = __LINE__ , sprintf(_err.message, format, ##__VA_ARGS__),\
    AppendArrayToCharBuffer(_err.message, sizeof(_err.message), (list)->get, (list)->count, 5), &_err)

TestErrorResult* test_Listfloat_Init() {
    Listfloat list;
    int result = Listfloat_Init(&list);
    IMPLEMENT_CHECK(result)
    if (result == FAIL) {
        return ERR("Listfloat_Init failed. it should not fail");
    }
    if (list.get != NULL || list.capacity != 0 || list.count != 0) {
        return ERR("Listfloat_Init should set all values to zero. list: 0x%zx, capacity:%d, count:%d",
            list.get, list.capacity, list.count);
    }
    Listfloat_Release(&list);
    return NULL;
}

TestErrorResult* test_Listfloat_SetCapacity(){
    Listfloat list;
    Listfloat_Init(&list);
    int expectedSize = 10;
    int result = Listfloat_SetCapacity(&list, expectedSize);
    IMPLEMENT_CHECK(result)
    if (result != Listfloat_Success) { return ERR("SetCapacity failed (%d)", result); }
    if (list.get == NULL) { return ERR("SetCapacity clearly did not allocate memory", result); }
    if (list.capacity != expectedSize)
        return ERR("capacity did not grow as expected. expected %d, value is %d",
            expectedSize, list.capacity);
    if (list.count != 0) {
        return ERR("count changed, unexpectedly: %d", list.count);
    }
    if (list.get == 0) {
        return ERR("data is still null", 0);
    }
    Listfloat_Release(&list);
    return NULL;
}

TestErrorResult* test_Listfloat_Release() {
    Listfloat list;
    Listfloat_Init(&list);
    int result = Listfloat_SetCapacity(&list, 2);
    result = Listfloat_Release(&list);
    IMPLEMENT_CHECK(result)
    if (list.capacity != 0) {
        return ERR("capacity isn't zero, it's %d!", list.capacity);
    }
    if (list.count != 0) {
        return ERR("count isn't zero, it's %d!", list.count);
    }
    if (list.get != NULL) {
        return ERR("data isn't null, it's 0x%x!", list.get);
    }
    return NULL;
}

TestErrorResult* test_Listfloat_Add() {
    Listfloat list;
    Listfloat_Init(&list);
    int result = Listfloat_Add(&list, 1);
    IMPLEMENT_CHECK(result)
    if (result != 0) {
        return ERR("Add failed (%d)", result);
    }
    if (list.capacity == 0) {
        return ERR("capacity did not grow", 0);
    }
    if (list.count != 1) {
        return ERR("count is not 1, as expected: %d", list.count);
    }
    if (list.get == 0) {
        return ERR("data is still null", 0);
    }
    Listfloat_Release(&list);
    return NULL;
}

float RandomFloat() { return (rand() & 0xffff) / (float)(0x10000); }

TestErrorResult* AddRandomFloats(Listfloat * self, int count) {
    int initialCount = self->count;
    float * randomNums = malloc(sizeof(float)*count);
    for(int i = 0; i < count; ++i){
        randomNums[i] = RandomFloat();
        int result = Listfloat_Add(self, randomNums[i]);
        if (result != 0) {
            return LISTERR(self,"Add failed: %d\n", result);
        }
        if (self->count != initialCount+i+1) {
            return LISTERR(self,"count unexpected value: %d\n", self->count);
        }
        for(int j = 0; j < i; ++j) {
            if (self->get[initialCount+j] != randomNums[j]) {
                return LISTERR(self,"unexpected value at index %d: %f, instead of %f\n",
                    j, self->get[initialCount+j], randomNums[i]);
            }
        }
    }
    free(randomNums);
    return NULL;
}

#define GIVEN_A_RANDOM_LIST(listname, size) \
    Listfloat listname; \
    Listfloat_Init(&listname); \
    { TestErrorResult* err = AddRandomFloats(&listname, size); \
    if (err != NULL) { \
        return err; \
    } }

TestErrorResult* test_Listfloat_Adds() {
    GIVEN_A_RANDOM_LIST(list,10)
    Listfloat_Release(&list);
    return NULL;
}

TestErrorResult* test_Listfloat_Remove() {
    GIVEN_A_RANDOM_LIST(list,10)
    int result = Listfloat_Remove(&list, -1);
    IMPLEMENT_CHECK(result)
    if (result == 0) {
        return LISTERR(&list,"Remove returned no error code with negative index\n", 0);
    }
    result = Listfloat_Remove(&list, list.capacity);
    if (result == 0) {
        return LISTERR(&list,"Remove returned no error code with OOB index\n", 0);
    }
    int initialCapacity = list.capacity;
    int originalCount = list.count;
    for(int i = 0; i < originalCount; ++i) {
        int indexToRemove = rand() % list.count;
        float valueToRemove = list.get[indexToRemove];
        float nextValue = 0;
        if (indexToRemove < list.count-1) {
            nextValue = list.get[indexToRemove+1];
        }
        result = Listfloat_Remove(&list, indexToRemove);
        if (result != 0) {
            return LISTERR(&list,"Remove returned an error code %d when none was expected\n", result);
        }
        if (list.count != originalCount-(1+i)) {
            return LISTERR(&list,"Remove didn't reduce the count as expected. got %d instead of %d\n",
                list.count, originalCount-(1+i));
        }
        if (list.capacity != initialCapacity) {
            return LISTERR(&list,"Remove changed the capacity? expected capacity to stay %d, it changed to %d\n",
                initialCapacity, list.capacity);
        }
        if (list.get[indexToRemove] == valueToRemove) {
            return LISTERR(&list,"Remove(%d) didn't remove.\n", indexToRemove);
        }
    }
    Listfloat_Release(&list);
    return NULL;
}

TestErrorResult* test_Listfloat_RemoveRange() {
    GIVEN_A_RANDOM_LIST(list,20)
    int initialSize = list.count;
    int start = 1 + rand() % (initialSize-3), length = 2;
    int result = Listfloat_RemoveRange(&list, -1, 2);
    IMPLEMENT_CHECK(result)
    if (result == 0) {
        return ERR("RemoveRange returned no error code with negative index");
    }
    result = Listfloat_RemoveRange(&list, list.capacity, 1);
    if (result == 0) {
        return ERR("RemoveRange returned no error code with OOB index");
    }
    result = Listfloat_RemoveRange(&list, 1, -1);
    if (result == 0) {
        return ERR("RemoveRange returned no error code with negative count");
    }
    result = Listfloat_RemoveRange(&list, start, length);
    if (result != 0) {
        return ERR("RemoveRange returned error (%d) for values %d, %d (should be valid for size %d)",
            result, start, length, initialSize);
    }
    if (list.count != initialSize-length) {
        return ERR("count did not reduce as expected. expected %d, instead of %d",
            (initialSize-length), list.count);
    }
    Listfloat_Release(&list);
    return NULL;
}

TestErrorResult* test_Listfloat_Insert() {
    Listfloat list;
    Listfloat_Init(&list);
    int index = 0;
    float value = RandomFloat();
    // insert index 0 from empty list
    int result = Listfloat_Insert(&list, index, value);
    IMPLEMENT_CHECK(result)
    if (result != 0) { return ERR("insert should return 0 if successful"); }
    result = Listfloat_Insert(&list, -1, value);
    if (result == 0) { return ERR("insert should return error code for invalid indexes"); }
    result = Listfloat_Insert(&list, list.capacity+1, value);
    if (result == 0) { return ERR("insert should return error code for invalid indexes"); }
    if (list.count != 1) {
        return ERR("inserting %f into empty list should add", value);
    }
    if (list.count != 1 || list.get[index] != value) {
        return LISTERR(&list,"inserting %f into empty list should add\n", value);
    }
    int expectedCount = list.count;
    for(index = 0; index < 3; ++index) {
        value = RandomFloat();
        result = Listfloat_Insert(&list, index, value);
        expectedCount++;
        if (list.count != expectedCount || list.get[index] != value) {
            return LISTERR(&list,"inserting %f into %d didn't work\n", value, index);
        }
    }
    Listfloat_Release(&list);
    return NULL;
}

TestErrorResult* test_Listfloat_Clear() {
    GIVEN_A_RANDOM_LIST(list,10)
    if(list.count == 0) { return ERR("list started empty. that shouldn't happen."); }
    int result = Listfloat_Clear(&list);
    IMPLEMENT_CHECK(result)
    if(list.count != 0) { return LISTERR(&list,"clear does not set count to zero!\n"); }
    Listfloat_Release(&list);
    return NULL;
}

TestErrorResult* test_Listfloat_IndexOf() {
    GIVEN_A_RANDOM_LIST(list,20)
    int found = Listfloat_IndexOf(&list, 2);
    IMPLEMENT_CHECK(found)
    if (found >= 0) { return LISTERR(&list,"found element 2, which should be impossible\n"); }
    for(int i = 0; i < 10; i++) {
        int index = rand() % (list.count-2);
        list.get[index] = 2;
        list.get[index+2] = 2;
        found = Listfloat_IndexOf(&list, 2);
        if (found != index) {
            return LISTERR(&list,"didn't find element 2 (at %d), IndexOf found it at %d\n", index, found);
        }
        found = Listfloat_IndexOfStartingAt(&list, 2, index+1, list.count);
        if (found != index+2) {
            return LISTERR(&list,"didn't find element 2 after %d (at %d), IndexOf found it at %d\n",
                index+1, index+2, found);
        }
        list.get[index] = 0;
        list.get[index+2] = 0;
    }
    found = Listfloat_IndexOf(&list, 2);
    if (found >= 0) { return LISTERR(&list,"found element 2 again, which should be impossible\n"); }
    Listfloat_Release(&list);
    return NULL;
}

TestErrorResult* test_Listfloat_IndexOfLast() {
    GIVEN_A_RANDOM_LIST(list,20)
    int found = Listfloat_IndexOfLast(&list, 2);
    IMPLEMENT_CHECK(found)
    if (found >= 0) { return LISTERR(&list,"found element 2, which should be impossible\n"); }
    for(int i = 0; i < 10; i++) {
        int index = (rand() % (list.count-2)) + 2;
        list.get[index] = 2;
        list.get[index-2] = 2;
        found = Listfloat_IndexOfLast(&list, 2);
        if (found != index) {
            return LISTERR(&list,"didn't find element 2 (at %d), IndexOf found it at %d\n", index, found);
        }
        found = Listfloat_IndexOfLastEndingAt(&list, 2, index-1, 0);
        if (found != index-2) {
            return LISTERR(&list,"didn't find element 2 after %d (at %d), IndexOf found it at %d\n",
                index+1, index-2, found);
        }
        list.get[index] = 0;
        list.get[index-2] = 0;
    }
    found = Listfloat_IndexOf(&list, 2);
    if (found >= 0) {
        return LISTERR(&list,"found element 2 again, which should be impossible\n");
    }
    Listfloat_Release(&list);
    return NULL;
}

void Swap(float* a, float* b) {
    float temp = *a;
    *a = *b;
    *b = temp;
}

int IsListInOrder(Listfloat* list, SortPredicate sortPredicate) {
    for(int i = 1; i < list->count; ++i)
        if (sortPredicate(&(list->get[i]), &(list->get[i-1])))
            return FAIL;
    return SUCCESS;
}

int SortPredicateLittleEndian(void* a, void* b) {
    float fa = *((float*)a);
    float fb = *((float*)b);
    return fa < fb;
}

void MakeSureListIsOutOfOrder (Listfloat* list) {
    if (IsListInOrder(list, SortPredicateLittleEndian) == FAIL) {
        return;
    }
    if (list->get[0] != list->get[1]) {
        Swap(&list->get[0], &list->get[1]);
        return;
    }
    list->get[0] = list->get[1] + 1;
}

TestErrorResult* test_Listfloat_Sort() {
    GIVEN_A_RANDOM_LIST(list,20)
    MakeSureListIsOutOfOrder(&list);
    int result = Listfloat_Sort(&list);
    IMPLEMENT_CHECK(result)
    if (IsListInOrder(&list, SortPredicateLittleEndian) == FAIL) {
        return LISTERR(&list, "sort did not sort a random list\n");
    }
    Listfloat_Release(&list);
    return NULL;
}

int SortPredicateBigEndian(void* a, void* b) {
    float fa = *((float*)a);
    float fb = *((float*)b);
    return fb < fa;
}

TestErrorResult* test_Listfloat_SortPredicate() {
    GIVEN_A_RANDOM_LIST(list,20)
    MakeSureListIsOutOfOrder(&list);
    int result = Listfloat_SortPredicate(&list, SortPredicateLittleEndian);
    IMPLEMENT_CHECK(result)
    if (IsListInOrder(&list, SortPredicateLittleEndian) == FAIL) {
        return LISTERR(&list, "sort predicate did not sort a random list in order\n");
    }
    Listfloat_Clear(&list);
    AddRandomFloats(&list, 30);
    Listfloat_SortPredicate(&list, SortPredicateBigEndian);
    if (IsListInOrder(&list, SortPredicateBigEndian) == FAIL) {
        return LISTERR(&list, "sort predicate did not sort a random list in reverse order\n");
    }
    Listfloat_Release(&list);
    return NULL;
}

int __SortPredicateLittleEndianCounted_count;
int SortPredicateLittleEndianCounted(void* X, void* Y) {
    ++__SortPredicateLittleEndianCounted_count;
    float r = *((float*)X) - *((float*)Y);
    return r < 0 ? -1 : r > 0 ? 1 : 0;
}

int GetLog2(int value) {
    int count = 0;
    while(value > 0) {
        value >>= 1;
        ++count;
    }
    return count;
}

TestErrorResult* test_Listfloat_BinarySearchComparer() {
    GIVEN_A_RANDOM_LIST(list,40)
    Listfloat_SortPredicate(&list, SortPredicateLittleEndian);
    int maxSearches = GetLog2(list.count);
    int indexToSearch = 0;//(list.count-1) /2 /2;
    float lookingFor = list.get[indexToSearch];
    __SortPredicateLittleEndianCounted_count = 0;
    int found = Listfloat_BinarySearchComparer(&list, lookingFor, SortPredicateLittleEndianCounted);
    IMPLEMENT_CHECK(found)
    if (found < 0 || list.get[found] != lookingFor) {
        return LISTERR(&list, "binarysearch looked for %f (at index %d), and %d was returned after %d searches\n",
            lookingFor, indexToSearch, found, __SortPredicateLittleEndianCounted_count);
    }
    if (__SortPredicateLittleEndianCounted_count > maxSearches) {
        return LISTERR(&list, "binarysearch found %f at %d, after %d searches (too many searches)\n",
            lookingFor, indexToSearch, __SortPredicateLittleEndianCounted_count);
    }
    indexToSearch = list.count-1-indexToSearch;
    lookingFor = list.get[indexToSearch];
    __SortPredicateLittleEndianCounted_count = 0;
    found = Listfloat_BinarySearchComparer(&list, lookingFor, SortPredicateLittleEndianCounted);
    if (found < 0 || list.get[found] != lookingFor) {
        return LISTERR(&list, "binarysearch looked for %f (at index %d), and %d was returned after %d searches\n",
            lookingFor, indexToSearch, found, __SortPredicateLittleEndianCounted_count);
    }
    if (__SortPredicateLittleEndianCounted_count > maxSearches) {
        return LISTERR(&list, "binarysearch found %f at %d, after %d searches (too many searches)\n",
            lookingFor, indexToSearch, __SortPredicateLittleEndianCounted_count);
    }
    Listfloat_Release(&list);
    return NULL;
}

void AddTwoListsToErrorMessage(TestErrorResult* e, float* list1, int list1count, float* list2, int list2count, int digits) {
    AppendArrayToCharBuffer(e->message, sizeof(e->message), list1, list1count, digits);
    int len = strlen(e->message);
    if(len+2 < sizeof(e->message)) {
        e->message[len] = '\n';
        e->message[len+1] = '\0';
        AppendArrayToCharBuffer(e->message, sizeof(e->message), list2, list2count, digits);
    }
}

TestErrorResult* test_Listfloat_Reverse() {
    GIVEN_A_RANDOM_LIST(list,10)
    float* copy = malloc(sizeof(float)*list.count);
    for(int i = 0; i < 10; ++i)
        list.get[i] = i;
    Listfloat_Copy(copy, list.get, list.count);
    int result = Listfloat_Reverse(&list);
    IMPLEMENT_CHECK(result)
    for(int i = 0; i < list.count; ++i) {
        if (list.get[i] != copy[list.count-1-i]) {
            TestErrorResult* e = ERR("reverse doesn't work.\n");
            AddTwoListsToErrorMessage(e, copy, list.count, list.get, list.count, 4);
            return e;
        }
    }
    free(copy);
    Listfloat_Release(&list);
    return NULL;
}

TestErrorResult* test_Listfloat_GetSublist() {
    GIVEN_A_RANDOM_LIST(list,10)
    int count = (rand() % 5) + 3;
    int start = rand() % 3;
    float* destination = malloc(sizeof(float)*count);
    int result = Listfloat_GetSublist(&list, start, count, destination);
    IMPLEMENT_CHECK(result)
    for(int i = 0; i < count; ++i) {
        if (destination[i] != list.get[start+i]) {
            TestErrorResult* e = ERR("failed to get complete sublist index:%d count:%d.\n", start, count);
            AddTwoListsToErrorMessage(e, destination, count, list.get, list.count, 4);
            return e;
        }
    }
    free(destination);
    Listfloat_Release(&list);
    return NULL;
}

TestErrorResult* test_Listfloat_InsertRange() {
    int originalListSize = (rand() % 5) + 5;
    int count = (rand() % 5) + 3;
    int start = rand() % 3;
    GIVEN_A_RANDOM_LIST(list,originalListSize)
    GIVEN_A_RANDOM_LIST(sublist,count)
    int result = Listfloat_InsertRange(&list, start, sublist.get, sublist.count);
    IMPLEMENT_CHECK(result)
    if (list.count != originalListSize + sublist.count) {
        TestErrorResult* e = ERR("InsertRange(%d, %d) didn't increase size correctly.\n", start, count);
        AddTwoListsToErrorMessage(e, list.get, list.count, sublist.get, sublist.count, 4);
        return e;
    }
    for(int i = 0; i < sublist.count; ++i) {
        if (list.get[start+i] != sublist.get[i]) {
            TestErrorResult* e = ERR("InsertRange(%d, %d) didn't copy data correctly.\n", start, count);
            AddTwoListsToErrorMessage(e, list.get, list.count, sublist.get, sublist.count, 4);
            return e;
        }
    }
    Listfloat_Release(&sublist);
    Listfloat_Release(&list);
    return NULL;
}

// TODO make test cases for
// for each
// find index (predicate)
// find last (predicate)
// find all (predicate)

#define TEST(a) {#a, a}
TestFunctionEntry testFunctionEntries[] = {
    TEST(test_Listfloat_Init),
    TEST(test_Listfloat_SetCapacity),
    TEST(test_Listfloat_Release),
    TEST(test_Listfloat_Add),
    TEST(test_Listfloat_Adds),
    TEST(test_Listfloat_Remove),
    TEST(test_Listfloat_RemoveRange),
    TEST(test_Listfloat_Clear),
    TEST(test_Listfloat_Insert),
    TEST(test_Listfloat_IndexOf),
    TEST(test_Listfloat_IndexOfLast),
    TEST(test_Listfloat_Sort),
    TEST(test_Listfloat_SortPredicate),
    TEST(test_Listfloat_BinarySearchComparer),
    TEST(test_Listfloat_Reverse),
    TEST(test_Listfloat_GetSublist),
    TEST(test_Listfloat_InsertRange),
    TEST(NULL),
};


#include <time.h>

int RunTest(TestFunctionEntry* test) {
    TestErrorResult* error = test->func();
    if (error != NULL) {
        printf("%s failed @ %s:%d\n%s\n", test->name, error->file, error->line, error->message);
        return FAIL;
    }
    return SUCCESS;
}

void RunTests() {
    srand(time(0));
    int t = 0;
    while(testFunctionEntries[t].func) {
        printf("%s\r", testFunctionEntries[t].name);
        if(RunTest(&testFunctionEntries[t]) == FAIL)
            return;
        Success(testFunctionEntries[t].name, 500, 2);
        printf("\n");
        ++t;
    }
    Success("ALL TESTS PASSED!", 500*10, 2*10);
}

int main(int argc, char** argv) {
    RunTests();
    return 0;
}