#include "unity.h"
#include "curtle/vector.h"

void setUp(void)
{
}

void tearDown(void)
{
}

void test_vec2_add()
{
	struct vec2 a = { 1, 2 };
	struct vec2 b = { 3, 4 };

	struct vec2 r = vec2_add(a, b);

	struct vec2 e = { 4, 6 };
	TEST_ASSERT_EQUAL_MEMORY(&e, &r, 8);
}

void test_vec2_sub()
{
	struct vec2 a = { 1, 2 };
	struct vec2 b = { 3, 4 };

	struct vec2 r = vec2_sub(a, b);

	struct vec2 e = { -2, -2 };
	TEST_ASSERT_EQUAL_MEMORY(&e, &r, 8);
}

void test_vec2_dot()
{
	struct vec2 a = { 1, 2 };
	struct vec2 b = { 3, 4 };

	float r = vec2_dot(a, b);

	TEST_ASSERT_EQUAL_FLOAT(11, r);
}

void test_vec2_det()
{
	struct vec2 a = { 1, 2 };
	struct vec2 b = { 3, 4 };

	float r = vec2_det(a, b);

	TEST_ASSERT_EQUAL_FLOAT(-2, r);
}

void test_vec2_scale()
{
	struct vec2 a = { 1, 2 };
	float s = 2;

	struct vec2 r = vec2_scale(a, 2);

	struct vec2 e = { 2, 4 };
	TEST_ASSERT_EQUAL_MEMORY(&e, &r, 8);
}

void test_vec2_len()
{
	struct vec2 a = { 4, 3 };

	float r = vec2_len(a);

	TEST_ASSERT_EQUAL_FLOAT(5, r);
}

void test_vec2_normalize()
{
	struct vec2 a = { 4, 0 };

	struct vec2 r = vec2_normalize(a);

	struct vec2 e = { 1, 0 };
	TEST_ASSERT_EQUAL_MEMORY(&e, &r, 8);
}

void test_vec3_add()
{
	struct vec3 a = { 1, 2, 5 };
	struct vec3 b = { 3, 4, 2 };

	struct vec3 r = vec3_add(a, b);

	struct vec3 e = { 4, 6, 7 };
	TEST_ASSERT_EQUAL_MEMORY(&e, &r, 12);
}

void test_vec3_sub()
{
	struct vec3 a = { 1, 2, 5 };
	struct vec3 b = { 3, 4, 2 };

	struct vec3 r = vec3_sub(a, b);

	struct vec3 e = { -2, -2, 3 };
	TEST_ASSERT_EQUAL_MEMORY(&e, &r, 12);
}

void test_vec3_dot()
{
	struct vec3 a = { 1, 2, 5 };
	struct vec3 b = { 3, 4, 2 };

	float r = vec3_dot(a, b);

	TEST_ASSERT_EQUAL_FLOAT(21, r);
}

void test_vec3_cross()
{
	struct vec3 a = { 1, 2, 5 };
	struct vec3 b = { 3, 4, 2 };

	struct vec3 r = vec3_cross(a, b);

	struct vec3 e = { -16, 13, -2 };
	TEST_ASSERT_EQUAL_MEMORY(&e, &r, 12);
}


void test_vec3_scale()
{
	struct vec3 a = { 1, 2, 5 };
	float s = 2;

	struct vec3 r = vec3_scale(a, 2);

	struct vec3 e = { 2, 4, 10 };
	TEST_ASSERT_EQUAL_MEMORY(&e, &r, 12);
}

void test_vec3_len()
{
	struct vec3 a = { 4, 3, 12 };

	float r = vec3_len(a);

	TEST_ASSERT_EQUAL_FLOAT(13, r);
}

void test_vec3_normalize()
{
	struct vec3 a = { 1, 2, 2 };

	struct vec3 r = vec3_normalize(a);

	struct vec3 e = { 1.f / 3.f, 2.f / 3.f, 2.f / 3.f };
	TEST_ASSERT_EQUAL_MEMORY(&e, &r, 12);
}

int main(void)
{
	UNITY_BEGIN();
	RUN_TEST(test_vec2_add);
	RUN_TEST(test_vec2_sub);
	RUN_TEST(test_vec2_dot);
	RUN_TEST(test_vec2_det);
	RUN_TEST(test_vec2_scale);
	RUN_TEST(test_vec2_len);
	RUN_TEST(test_vec2_normalize);
	RUN_TEST(test_vec3_add);
	RUN_TEST(test_vec3_sub);
	RUN_TEST(test_vec3_dot);
	RUN_TEST(test_vec3_cross);
	RUN_TEST(test_vec3_scale);
	RUN_TEST(test_vec3_len);
	RUN_TEST(test_vec3_normalize);
	return UNITY_END();
}