/*
 * Copyright 2015 (c) Anna Schumaker.
 */
#include <core/containers/set.h>
#include <tests/test.h>


void test_set()
{
	struct file f  = FILE_INIT("set", 0, 0);
	struct set set = SET_INIT();
	unsigned int i, N = 10;
	struct set_iter it;

	/* Insert N items. */
	for (i = 0; i < N; i++) {
		set_insert(&set, i);
		set_insert(&set, i);
		test_loop_equal(set_size(&set), i + 1, i);
		test_loop_equal(set_has(&set, i), (bool)true, i);
	} test_loop_passed();

	set_insert(&set, 0);
	test_equal(set_size(&set), N);

	/* Remove even items. */
	for (i = 0; i < N; i += 2) {
		set_remove(&set, i);
		set_remove(&set, i);
		test_loop_equal(set_has(&set, i), (bool)false, i);
	} test_loop_passed();
	test_equal(set_size(&set), N / 2);

	/* Test iterating. */
	i = 1;
	set_for_each(&set, &it) {
		test_loop_equal(it.it_val, i, i);
		i += 2;
	} test_loop_passed();

	file_open(&f, OPEN_WRITE);
	set_write(&f, &set);
	file_close(&f);

	set_clear(&set);
	test_equal(set_size(&set), 0);

	file_open(&f, OPEN_READ);
	set_read(&f, &set);
	test_equal(set_size(&set), N / 2);
	file_close(&f);

	/* Check values. */
	for (i = 0; i < N; i++) {
		if (i % 2) { /* Odd values. */
			test_loop_equal(set_has(&set, i), (bool)true, i);
		} else { /* Even values. */
			test_loop_equal(set_has(&set, i), (bool)false, i);
		}
	} test_loop_passed();

	set_deinit(&set);
}

void test_copy()
{
	struct set set1 = SET_INIT();
	struct set set2 = SET_INIT();
	struct set set3 = SET_INIT();
	unsigned int i;

	/* Test copy between two empty sets. */
	set_copy(&set1, &set2);
	test_equal(set_size(&set1), 0);
	test_equal(set_size(&set2), 0);

	/* Add values 0 - 9 to set1, but keep set2 empty. */
	for (i = 0; i < 10; i++)
		set_insert(&set1, i);
	set_copy(&set1, &set2);
	test_equal(set_size(&set1), 10);
	test_equal(set_size(&set2), 10);

	/* Set2 should now contain values 0 - 9. */
	for (i = 0; i < 10; i++) {
		test_loop_equal(set_has(&set2, i), (bool)true, i);
	} test_loop_passed();

	/* Add values 10 - 19 to set3, copy into set2. */
	for (i = 10; i < 20; i++)
		set_insert(&set3, i);
	set_copy(&set3, &set2);
	test_equal(set_size(&set3), 10);
	test_equal(set_size(&set2), 20);

	/* Set2 should now contain values 0 - 19. */
	for (i = 0; i < 20; i++) {
		test_loop_equal(set_has(&set2, i), (bool)true, i);
	} test_loop_passed();

	set_deinit(&set1);
	set_deinit(&set2);
	set_deinit(&set3);
}

void test_intersection()
{
	struct set set1 = SET_INIT();
	struct set set2 = SET_INIT();
	unsigned int i;

	/* Test intersection between two empty sets. */
	set_inline_intersect(&set1, &set2);
	test_equal(set_size(&set1), 0);
	test_equal(set_size(&set2), 0);


	/* Add values 5 - 14 to set2, but keep set1 empty. */
	for (i = 5; i < 15; i++)
		set_insert(&set2, i);
	set_inline_intersect(&set1, &set2);
	test_equal(set_size(&set1), 0);
	test_equal(set_size(&set2), 0);


	/* Add values 0 - 9 to set1, but keep set2 empty. */
	for (i = 0; i < 10; i++)
		set_insert(&set1, i);
	set_inline_intersect(&set1, &set2);
	test_equal(set_size(&set1), 10);
	test_equal(set_size(&set2), 0);


	/* Add values 5 - 14 back into set2. */
	for (i = 5; i < 15; i++)
		set_insert(&set2, i);
	set_inline_intersect(&set1, &set2);
	test_equal(set_size(&set1), 10);
	test_equal(set_size(&set2), 5);


	/* Set1 should now contain values 5 - 9. */
	for (i = 0; i < 15; i++) {
		if (i >= 5 && i < 10) {
			test_loop_equal(set_has(&set2, i), (bool)true, i);
		} else {
			test_loop_equal(set_has(&set2, i), (bool)false, i);
		}
	} test_loop_passed();

	set_deinit(&set1);
	set_deinit(&set2);
}

DECLARE_UNIT_TESTS(
	UNIT_TEST("Set", test_set),
	UNIT_TEST("Set Copy", test_copy),
	UNIT_TEST("Set Intersection", test_intersection),
);