#include "xtest.h"
#include "examples.h"

static void fail_assert() {
    xtest_assert(0);
}

static void fail_assert_is_char() {
    xtest_assert_is((char) 'a', (char) 'b');
}

static void fail_assert_is_not_char() {
    xtest_assert_is_not((char) 'a', (char) 'a');
}

static void fail_assert_is_signed_char() {
    xtest_assert_is((signed char) 'a', (signed char) 'b');
}

static void fail_assert_is_not_signed_char() {
    xtest_assert_is_not((signed char) 'a', (signed char) 'a');
}

static void fail_assert_is_unsigned_char() {
    xtest_assert_is((unsigned char) 'a', (unsigned char) 'b');
}

static void fail_assert_is_not_unsigned_char() {
    xtest_assert_is_not((unsigned char) 'a', (unsigned char) 'a');
}

static void fail_assert_is_short() {
    xtest_assert_is((short) 1, (short) 2);
}

static void fail_assert_is_not_short() {
    xtest_assert_is_not((short) 1, (short) 1);
}

static void fail_assert_is_ushort() {
    xtest_assert_is((unsigned short) 1, (unsigned short) 2);
}

static void fail_assert_is_not_ushort() {
    xtest_assert_is_not((unsigned short) 1, (unsigned short) 1);
}

static void fail_assert_is_int() {
    xtest_assert_is((int) 1, (int) 2);
}

static void fail_assert_is_not_int() {
    xtest_assert_is_not((int) 1, (int) 1);
}

static void fail_assert_is_uint() {
    xtest_assert_is((unsigned int) 1, (unsigned int) 2);
}

static void fail_assert_is_not_uint() {
    xtest_assert_is_not((unsigned int) 1, (unsigned int) 1);
}

static void fail_assert_is_long() {
    xtest_assert_is((short) 1, (short) 2);
}

static void fail_assert_is_not_long() {
    xtest_assert_is_not((long) 1, (long) 1);
}

static void fail_assert_is_ulong() {
    xtest_assert_is((unsigned long) 1, (unsigned long) 2);
}

static void fail_assert_is_not_ulong() {
    xtest_assert_is_not((unsigned long) 1, (unsigned long) 1);
}

static void fail_assert_is_longlong() {
    xtest_assert_is((long long) 1, (long long) 2);
}

static void fail_assert_is_not_longlong() {
    xtest_assert_is_not((long long) 1, (long long) 1);
}

static void fail_assert_is_ulonglong() {
    xtest_assert_is((unsigned long long) 1, (unsigned long long) 2);
}

static void fail_assert_is_not_ulonglong() {
    xtest_assert_is_not((unsigned long long) 1, (unsigned long long) 1);
}

static void fail_assert_is_ptr() {
    int i = 1;
    int j = 1;
    xtest_assert_is((void *) &i, (void *) &j);
}

static void fail_assert_is_not_ptr() {
    int i = 1;
    xtest_assert_is_not((void *) &i, (void *) &i);
}

static void fail_assert_str_is() {
    xtest_assert_str_is("foo", "bar");
}

static void fail_assert_str_is_not() {
    xtest_assert_str_is_not("foo", "foo");
}

static void fail_assert_mem_is() {
    xtest_assert_mem_is("aaaaaaaaaaaaa", "aaaaaaaaaaaab", 13);
}

static void fail_assert_mem_is_not() {
    xtest_assert_mem_is_not("aaaaaaaaaaaaa", "aaaaaaaaaaaab", 12);
}


static void fail_assert_float_is() {
    xtest_assert_float_is(1.2356, 1.2346, 3);
}


static void fail_assert_float_is_not() {
    xtest_assert_float_is_not(1.2356, 1.2346, 2);
}

static void fail_assert_is(void) {
    xtest_run(fail_assert_is_char);
    xtest_run(fail_assert_is_not_char);
    xtest_run(fail_assert_is_signed_char);
    xtest_run(fail_assert_is_not_signed_char);
    xtest_run(fail_assert_is_unsigned_char);
    xtest_run(fail_assert_is_not_unsigned_char);
    xtest_run(fail_assert_is_short);
    xtest_run(fail_assert_is_not_short);
    xtest_run(fail_assert_is_ushort);
    xtest_run(fail_assert_is_not_ushort);
    xtest_run(fail_assert_is_int);
    xtest_run(fail_assert_is_not_int);
    xtest_run(fail_assert_is_uint);
    xtest_run(fail_assert_is_not_uint);
    xtest_run(fail_assert_is_long);
    xtest_run(fail_assert_is_not_long);
    xtest_run(fail_assert_is_ulong);
    xtest_run(fail_assert_is_not_ulong);
    xtest_run(fail_assert_is_longlong);
    xtest_run(fail_assert_is_not_longlong);
    xtest_run(fail_assert_is_ulonglong);
    xtest_run(fail_assert_is_not_ulonglong);
    xtest_run(fail_assert_is_ptr);
    xtest_run(fail_assert_is_not_ptr);
}

static void fail_assert_str(void) {
    xtest_run(fail_assert_str_is);
    xtest_run(fail_assert_str_is_not);
}

static void fail_assert_mem(void) {
    xtest_run(fail_assert_mem_is);
    xtest_run(fail_assert_mem_is_not);
}

static void fail_assert_float(void) {
    xtest_run(fail_assert_float_is);
    xtest_run(fail_assert_float_is_not);
}

void example_fail(void) {
    xtest_run(fail_assert);
    xtest_run_group(fail_assert_is);
    xtest_run_group(fail_assert_str);
    xtest_run_group(fail_assert_mem);
    xtest_run_group(fail_assert_float);
}

#ifndef XTEST_ALL_EXAMPLES
XTEST_RUN_MAIN(example_fail)
#endif