arrtests.c

#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <time.h>

#include "arr.h"

arr_int func(void)
{
	return *((arr_int *) arr_of(1, 2, 3, 4, 5));
}

#define isodd(e, i, a) ((e % 2) == 0)
int isoddf(const int *e, int i, const int *a)
{
	return isodd(*e,,);
}

#define iseven(e, i, a) ((e % 2) == 1)
int isevenf(const int *e, int i, const int *a)
{
	return iseven(*e,,);
}

#define is25(e, i, a) (e == 25)

int is25f(const int *e, int i, const int *a)
{
	return is25(*e,,);
}

#define square(e,i,a) (e)*=(e);

void squaref(int *e, int i, const int *a)
{
	*e *= *e;
}

#define toidx(e,i,a) (i)
int toidxf(const int *e, int i, const int *a)
{
	return i;
}

int intcmpr(const int *a, const int *b)
{
	if(*a > *b) return 1;
	if(*a < *b) return -1;
	return 0;
}

int dotests()
{
	int i;
	const int ia[] = {1, 2, 3, 4, 5};
	const int ia2[] = {1, 99, 57, 42, 4, 5};
	
	arr_int a arr_cleanup = arr_empty;
	arr_int b arr_cleanup = arr_empty;
	arr_int c = {.data = (int *) ia, .len = 5, .siz = 5, .is_static = 1};
	arr_int d arr_cleanup = arr_empty;
	arr_int e arr_cleanup = arr_empty, f arr_cleanup = arr_empty, g arr_cleanup = arr_empty;
	arr_int h arr_cleanup;
	
	srand(time(0));
	
	b = *((arr_int *) arr_of(1, 2, 3, 4, 5));
	
	assert(b.len == 5);
	assert(c.len == 5);
	assert(!memcmp(b.data, ia, sizeof(int) * 5));
	assert(!memcmp(c.data, ia, sizeof(int) * 5));
	
	h = func();
	arr_splice(&h, 1, 2, 99, 57, 42);
	assert(!memcmp(h.data, ia2, sizeof(int) * 6));
	
	arr_reserve(&b, 200);
	assert(b.len == 5);
	assert(b.siz == 200);
	for(i = 0; i < 95; i++){
		int tmp = rand() % 30;
		arr_push(&b, tmp);
		assert(b.data[i + 5] == tmp);
	}
	arr_unreserve(&b);
	assert(b.siz == 100);
	assert(b.len == 100);
	
	arr_cpy(&b, &a);
	assert(a.siz == 100);
	assert(a.len == 100);
	assert(!memcmp(a.data, b.data, sizeof(int) * 100));
	
	arr_join(&b, &a, &d);
	assert(d.len == 200);
	assert(!memcmp(d.data , b.data, sizeof(int) * 100));
	assert(!memcmp(d.data + 100, a.data, sizeof(int) * 100));
	
	arr_cat(&b, &d);
	assert(b.len == 300);
	assert(!memcmp(b.data + 100, d.data, sizeof(int) * 200));
	
	arr_sieve(&b, isodd);
	if(b.len < 10) return 0;
	for(i = 0; i < b.len; i++){
		assert(isodd(b.data[i],,));
	}
	
	arr_sievef(&a, isoddf);
	if(a.len < 10) return 0;
	for(i = 0; i < a.len; i++){
		assert(isodd(a.data[i],,));
	}
	
	i = d.data[d.len - 1];
	arr_remove(&d, 97);
	assert(d.len == 199);
	assert(d.data[97] == i);
	
	assert(arr_everyf(&a, isoddf));
	assert(arr_every(&a, isodd));
	
	i = a.len;
	arr_fill(&a, 999);
	assert(a.len == i);
	for(i = 0; i < a.len; i++){
		assert(a.data[i] == 999);
	}
	
	arr_cpy(&d, &e);
	assert(e.len == d.len);
	assert(!memcmp(e.data, d.data, sizeof(int) * d.len));
	
	for(i = 0; i < d.len; i++){
		if(isodd(d.data[i],,)) break;
	}
	if(i == d.len) return 0;
	
	arr_filter(&d, isodd, &f);
	arr_filterf(&e, isoddf, &g);
	assert(f.len == g.len);
	assert(f.len);
	for(i = 0; i < f.len; i++){
		assert(isodd(f.data[i],,));
		assert(isodd(g.data[i],,));
	}
	assert(!memcmp(f.data, g.data, sizeof(int) * f.len));
	
	if(f.len < 3) return 0;
	
	for(i = 0; i < d.len; i++){
		if(d.data[i] == 25) break;
	}
	if(i == d.len) return 0;
	
	assert(arr_findf(&d, is25f) == 25);
	assert(arr_find(&d, is25) == 25);
	
	assert(d.data[arr_findidxf(&d, is25f)] == 25);
	assert(d.data[arr_findidx(&d, is25)] == 25);
	assert(arr_includes(&d, 25));
	assert(!arr_includes(&d, 99999));
	
	assert(arr_findidxf(&c, is25f) == 5);
	assert(arr_findidx(&c, is25) == 5);
	
	arr_foreachf(&d, squaref);
	for(i = 0; i < d.len; i++){
		assert(d.data[i] == e.data[i] * e.data[i]);
	}
	arr_foreach(&e, square);
	for(i = 0; i < d.len; i++){
		assert(d.data[i] == e.data[i]);
	}
	
	assert(arr_somef(&d, isevenf));
	assert(arr_some(&e, iseven));
	assert(!arr_somef(&f, isevenf));
	assert(!arr_some(&g, iseven));
	
	arr_free(&f);
	arr_free(&g);
	
	arr_mapf(&d, toidxf, &f);
	arr_map(&e, toidx, &g);
	for(i = 0; i < d.len; i++){
		assert(f.data[i] == i);
		assert(g.data[i] == i);
	}
	
	i = f.len;
	arr_shift(&f);
	assert(f.len == i - 1);
	assert(f.data[0] != 0);
	
	i = f.len;
	arr_pop(&f);
	assert(f.len == i - 1);
	
	assert(arr_idxof(&g, 33) == 33);
	
	arr_reverse(&g);
	for(i = 0; i < g.len; i++){
		assert(g.data[i] == g.len - i - 1);
	}
	
	arr_sort(&d, intcmpr);
	for(i = 1; i < d.len; i++){
		assert(d.data[i - 1] <= d.data[i]);
	}
	
	return 1;
}

int main()
{
	int i;
	for(i = 0; i < 500000;){
		if(dotests()) i++;
	}
}

/*
Test	Func
ok		arr_cleanup __attribute__ 
ok		arr_t
ok		arr_empty
ok		arr_reserve
ok		arr_unreserve
ok		arr_cpy
ok		arr_join
ok		arr_cat
ok		arr_push
ok		arr_free
ok		arr_splice
ok		arr_remove
ok		arr_sievef
ok		arr_sieve
ok		arr_of
ok		arr_everyf
ok		arr_fill
ok		arr_filterf
ok		arr_findf
ok		arr_findidxf
ok		arr_foreachf
ok		arr_somef
ok		arr_includes
ok		arr_idxof
ok		arr_mapf
ok		arr_pop
ok		arr_reverse
ok		arr_shift
ok		arr_sort
ok		arr_every
ok		arr_filter
ok		arr_find
ok		arr_findidx
ok		arr_foreach
ok		arr_some
ok		arr_map
*/