//
// Created by rick on 13-03-21.
//

#ifdef ENABLE_SELF_TEST

#include <myke/debug/debug.h>
#include <string.h>
#include <stdlib.h>
#include <myke/libk/libk.h>
#include <errno.h>

void assert_int(int expected, int actual) {
    if (expected != actual) {
        debug_backtrace(true);
        k_panics("Assertion failed, integers not equal\n");
    }
}

void assert_long(long expected, long actual) {
    if (expected != actual) {
        debug_backtrace(true);
        k_panics("Assertion failed, integers not equal\n");
    }
}

void assert_long_long(long long expected, long long actual) {
    if (expected != actual) {
        debug_backtrace(true);
        k_panics("Assertion failed, integers not equal\n");
    }
}

void assert_ptr(const void *expected, const void *actual) {
    if (expected != actual) {
        debug_backtrace(true);
        k_panics("Assertion failed, integers not equal\n");
    }
}

void assert_array_equal(const uint8_t *a, const uint8_t *b, size_t size) {
    for (size_t i = 0; i < size; ++i) {
        if (a[i] != b[i]) {
            debug_backtrace(true);
            k_panics("Assertion failed, arrays differ\n");
        }
    }
}

void assert_array_all_entries(const uint8_t *a, uint8_t value, size_t size) {
    for (size_t i = 0; i < size; ++i) {
        if (a[i] != value) {
            debug_backtrace(true);
            k_panics("Assertion failed, arrays differ\n");
        }
    }
}

void test_string() {
    // test strncmp
    assert_int(0, strncmp("abc", "abc", 3));
    assert_int(1, strncmp("abcd", "abc", 4));
    assert_int(-1, strncmp("abc", "abcd", 4));

    // test strcmp
    assert_int(0, strcmp("abc", "abc"));
    assert_int(1, strcmp("abc", "abd"));
    assert_int(-1, strcmp("abc", "abb"));
    assert_int(-1, strcmp("abc", "abcd"));
    assert_int(1, strcmp("abcd", "abc"));

    uint8_t array_a[8] = {0};
    uint8_t array_b[16] = {0};
    // memset
    assert_array_all_entries(array_b, 0, 16);
    memset(array_b, 1, 8);
    assert_array_all_entries(array_b, 1, 8);
    assert_array_all_entries(array_b + 8, 0, 8);
    memset(array_b, 1, 16);
    assert_array_all_entries(array_b, 1, 16);

    // memcpy
    memcpy(array_b, array_a, 8);
    assert_array_all_entries(array_b, 0, 8);
    assert_array_all_entries(array_b + 8, 1, 8);
    memcpy(array_b + 8, array_a, 8);
    assert_array_all_entries(array_b, 0, 16);

    // strlen
    assert_int(3, strlen("abc"));
    assert_int(4, strlen("abcd"));
    assert_int(5, strlen("abcde"));
    assert_int(0, strlen(""));

    // strchr
    const char *strchr_test = "abcdef";
    assert_ptr(&strchr_test[3], strchr(strchr_test, 'd'));
    assert_ptr(NULL, strchr(strchr_test, '9'));

    // strcpy
    const char *strcpy_src_test = "abc\0def";
    char *strcpy_dst_test = "\0\0\0\0\0\0\0";
    const char *strcpy_expected_test = "abc\0\0\0\0";
    assert_ptr(strcpy_dst_test, strcpy(strcpy_dst_test, strcpy_src_test));
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wpointer-sign"
    assert_array_equal(strcpy_dst_test, strcpy_expected_test, 8);
#pragma clang diagnostic pop
}

void test_stdlib() {
    // abs
    assert_int(1, abs(1));
    assert_int(1, abs(-1));
    assert_int(0, abs(0));
    assert_int(0, abs(-0));

    // labs
    assert_long(1l, labs(1l));
    assert_long(1l, labs(-1l));
    assert_long(0l, labs(0l));
    assert_long(0l, labs(-0l));

    // llabs
    assert_long_long(1ll, llabs(1ll));
    assert_long_long(1ll, llabs(-1ll));
    assert_long_long(0ll, llabs(0ll));
    assert_long_long(0ll, llabs(-0ll));

    assert_long(10, strtol("10", NULL, 10));
    assert_long(-10, strtol("-10", NULL, 10));
    assert_long(16, strtol("10", NULL, 16));
    assert_long(-16, strtol("-10", NULL, 16));
    assert_long(8, strtol("10", NULL, 8));
    assert_long(-8, strtol("-10", NULL, 8));
    assert_long(8, strtol("010", NULL, 8));
    assert_long(-8, strtol("-010", NULL, 8));
    assert_long(200, strtol("5K", NULL, 36));
    assert_long(-200, strtol("-5K", NULL, 36));
    assert_long(-200, strtol("-5k", NULL, 36));

    errno = 0;
    assert_long(-1, strtol("A", NULL, 10));
    assert_int(errno, EINVAL);
}

void self_test() {
    test_string();
    test_stdlib();
}

#endif