diff --git a/src/test/Makefile b/src/test/Makefile
index d731ae6..5b9339d 100644
--- a/src/test/Makefile
+++ b/src/test/Makefile
@@ -16,7 +16,7 @@ endif
TARGET = test
HEADERS = cunit.h
-OBJECTS = cunit.o cunit_filereader.o cunit_half_edge.o
+OBJECTS = cunit.o cunit_filereader.o cunit_half_edge.o cunit_vector.o
INCS = -I. -I..
CFLAGS += $(shell $(PKG_CONFIG) --cflags gl glu glib-2.0)
diff --git a/src/test/cunit.c b/src/test/cunit.c
index 5a8ef43..6d96b8a 100644
--- a/src/test/cunit.c
+++ b/src/test/cunit.c
@@ -110,6 +110,73 @@ int main(void)
return CU_get_error();
}
+ /* add a suite to the registry */
+ pSuite = CU_add_suite("vector tests",
+ init_suite,
+ clean_suite);
+ if (NULL == pSuite) {
+ CU_cleanup_registry();
+ return CU_get_error();
+ }
+
+ /* add the tests to the suite */
+ if (
+ (NULL == CU_add_test(pSuite, "test1 calculating vector product",
+ test_vector_product1)) ||
+ (NULL == CU_add_test(pSuite, "test2 calculating vector product",
+ test_vector_product2)) ||
+ (NULL == CU_add_test(pSuite, "test3 calculating vector product",
+ test_vector_product3)) ||
+ (NULL == CU_add_test(pSuite, "test4 calculating vector product",
+ test_vector_product4)) ||
+ (NULL == CU_add_test(pSuite, "test5 calculating vector product",
+ test_vector_product5)) ||
+ (NULL == CU_add_test(pSuite, "test6 calculating vector product",
+ test_vector_product6)) ||
+ (NULL == CU_add_test(pSuite, "test1 adding vectors",
+ test_add_vectors1)) ||
+ (NULL == CU_add_test(pSuite, "test2 adding vectors",
+ test_add_vectors2)) ||
+ (NULL == CU_add_test(pSuite, "test3 adding vectors",
+ test_add_vectors3)) ||
+ (NULL == CU_add_test(pSuite, "test4 adding vectors",
+ test_add_vectors4)) ||
+ (NULL == CU_add_test(pSuite, "test5 adding vectors",
+ test_add_vectors5)) ||
+ (NULL == CU_add_test(pSuite, "test6 adding vectors",
+ test_add_vectors6)) ||
+ (NULL == CU_add_test(pSuite, "test1 substracting vectors",
+ test_sub_vectors1)) ||
+ (NULL == CU_add_test(pSuite, "test2 substracting vectors",
+ test_sub_vectors2)) ||
+ (NULL == CU_add_test(pSuite, "test3 substracting vectors",
+ test_sub_vectors3)) ||
+ (NULL == CU_add_test(pSuite, "test4 substracting vectors",
+ test_sub_vectors4)) ||
+ (NULL == CU_add_test(pSuite, "test5 substracting vectors",
+ test_sub_vectors5)) ||
+ (NULL == CU_add_test(pSuite, "test6 substracting vectors",
+ test_sub_vectors6)) ||
+ (NULL == CU_add_test(pSuite, "test1 normalizing vector",
+ test_normalize_vector1)) ||
+ (NULL == CU_add_test(pSuite, "test2 normalizing vector",
+ test_normalize_vector2)) ||
+ (NULL == CU_add_test(pSuite, "test3 normalizing vector",
+ test_normalize_vector3)) ||
+ (NULL == CU_add_test(pSuite, "test4 normalizing vector",
+ test_normalize_vector4)) ||
+ (NULL == CU_add_test(pSuite, "test1 copying vector",
+ test_copy_vector1)) ||
+ (NULL == CU_add_test(pSuite, "test2 copying vector",
+ test_copy_vector2)) ||
+ (NULL == CU_add_test(pSuite, "test3 copying vector",
+ test_copy_vector3))
+ ) {
+
+ CU_cleanup_registry();
+ return CU_get_error();
+ }
+
/* save stderr stream and close it */
my_stderr = dup(STDERR_FILENO);
close(STDERR_FILENO);
diff --git a/src/test/cunit.h b/src/test/cunit.h
index 8ecbf53..06e1c29 100644
--- a/src/test/cunit.h
+++ b/src/test/cunit.h
@@ -41,3 +41,36 @@ void test_find_center2(void);
void test_get_normalized_scale_factor1(void);
void test_get_normalized_scale_factor2(void);
+
+/*
+ * vector tests
+ */
+void test_vector_product1(void);
+void test_vector_product2(void);
+void test_vector_product3(void);
+void test_vector_product4(void);
+void test_vector_product5(void);
+void test_vector_product6(void);
+
+void test_add_vectors1(void);
+void test_add_vectors2(void);
+void test_add_vectors3(void);
+void test_add_vectors4(void);
+void test_add_vectors5(void);
+void test_add_vectors6(void);
+
+void test_sub_vectors1(void);
+void test_sub_vectors2(void);
+void test_sub_vectors3(void);
+void test_sub_vectors4(void);
+void test_sub_vectors5(void);
+void test_sub_vectors6(void);
+
+void test_normalize_vector1(void);
+void test_normalize_vector2(void);
+void test_normalize_vector3(void);
+void test_normalize_vector4(void);
+
+void test_copy_vector1(void);
+void test_copy_vector2(void);
+void test_copy_vector3(void);
diff --git a/src/test/cunit_vector.c b/src/test/cunit_vector.c
new file mode 100644
index 0000000..8668f55
--- /dev/null
+++ b/src/test/cunit_vector.c
@@ -0,0 +1,407 @@
+/*
+ * Copyright 2011-2014 hasufell
+ *
+ * This file is part of a hasufell project.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation version 2 of the License only.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+#include "vector.h"
+
+#include
+#include
+#include
+#include
+#include
+
+
+/**
+ * Test calculating vector product.
+ */
+void test_vector_product1(void)
+{
+ vector a = { 1, 5, 3 },
+ b = { 5, 0, 7 };
+ vector c;
+
+ bool retval = vector_product(&a, &b, &c);
+
+ CU_ASSERT_EQUAL(retval, true);
+ CU_ASSERT_EQUAL(c.x, 35);
+ CU_ASSERT_EQUAL(c.y, 8);
+ CU_ASSERT_EQUAL(c.z, -25);
+}
+
+/**
+ * Test calculating vector product, aliasing-safe.
+ */
+void test_vector_product2(void)
+{
+ vector a = { 1, 5, 3 },
+ b = { 5, 0, 7 };
+
+ bool retval = vector_product(&a, &b, &a);
+
+ CU_ASSERT_EQUAL(retval, true);
+ CU_ASSERT_EQUAL(a.x, 35);
+ CU_ASSERT_EQUAL(a.y, 8);
+ CU_ASSERT_EQUAL(a.z, -25);
+}
+
+/**
+ * Test calculating vector product, aliasing-safe.
+ */
+void test_vector_product3(void)
+{
+ vector a = { 1, 5, 3 },
+ b = { 5, 0, 7 };
+
+ bool retval = vector_product(&a, &b, &b);
+
+ CU_ASSERT_EQUAL(retval, true);
+ CU_ASSERT_EQUAL(b.x, 35);
+ CU_ASSERT_EQUAL(b.y, 8);
+ CU_ASSERT_EQUAL(b.z, -25);
+}
+
+/**
+ * Test error handling by passing a NULL pointer.
+ */
+void test_vector_product4(void)
+{
+ vector a = { 1, 5, 3 },
+ b = { 5, 0, 7 },
+ c;
+
+ bool retval = vector_product(&a, &b, NULL);
+
+ CU_ASSERT_EQUAL(retval, false);
+}
+
+/**
+ * Test error handling by passing a NULL pointer.
+ */
+void test_vector_product5(void)
+{
+ vector a = { 1, 5, 3 },
+ b = { 5, 0, 7 },
+ c;
+
+ bool retval = vector_product(NULL, &b, &c);
+
+ CU_ASSERT_EQUAL(retval, false);
+}
+
+/**
+ * Test error handling by passing a NULL pointer.
+ */
+void test_vector_product6(void)
+{
+ vector a = { 1, 5, 3 },
+ b = { 5, 0, 7 },
+ c;
+
+ bool retval = vector_product(&a, NULL, &c);
+
+ CU_ASSERT_EQUAL(retval, false);
+}
+
+/**
+ * Test adding vectors.
+ */
+void test_add_vectors1(void)
+{
+ vector a = { 1, 5, 3 },
+ b = { 5, 0, 7 },
+ c;
+
+ bool retval = add_vectors(&a, &b, &c);
+
+ CU_ASSERT_EQUAL(retval, true);
+
+ CU_ASSERT_EQUAL(c.x, 6);
+ CU_ASSERT_EQUAL(c.y, 5);
+ CU_ASSERT_EQUAL(c.z, 10);
+}
+
+/**
+ * Test adding vectors, aliasing-safe.
+ */
+void test_add_vectors2(void)
+{
+ vector a = { 1, 5, 3 },
+ b = { 5, 0, 7 };
+
+ bool retval = add_vectors(&a, &b, &a);
+
+ CU_ASSERT_EQUAL(retval, true);
+
+ CU_ASSERT_EQUAL(a.x, 6);
+ CU_ASSERT_EQUAL(a.y, 5);
+ CU_ASSERT_EQUAL(a.z, 10);
+}
+
+/**
+ * Test adding vectors, aliasing-safe.
+ */
+void test_add_vectors3(void)
+{
+ vector a = { 1, 5, 3 },
+ b = { 5, 0, 7 };
+
+ bool retval = add_vectors(&a, &b, &b);
+
+ CU_ASSERT_EQUAL(retval, true);
+
+ CU_ASSERT_EQUAL(b.x, 6);
+ CU_ASSERT_EQUAL(b.y, 5);
+ CU_ASSERT_EQUAL(b.z, 10);
+}
+
+/**
+ * Test error handling by passing a NULL pointer.
+ */
+void test_add_vectors4(void)
+{
+ vector a = { 1, 5, 3 },
+ b = { 5, 0, 7 },
+ c;
+
+ bool retval = add_vectors(&a, NULL, &c);
+
+ CU_ASSERT_EQUAL(retval, false);
+}
+
+/**
+ * Test error handling by passing a NULL pointer.
+ */
+void test_add_vectors5(void)
+{
+ vector a = { 1, 5, 3 },
+ b = { 5, 0, 7 },
+ c;
+
+ bool retval = add_vectors(&a, &b, NULL);
+
+ CU_ASSERT_EQUAL(retval, false);
+}
+
+/**
+ * Test error handling by passing a NULL pointer.
+ */
+void test_add_vectors6(void)
+{
+ vector a = { 1, 5, 3 },
+ b = { 5, 0, 7 },
+ c;
+
+ bool retval = add_vectors(NULL, &b, &c);
+
+ CU_ASSERT_EQUAL(retval, false);
+}
+
+/**
+ * Test substracting vectors.
+ */
+void test_sub_vectors1(void)
+{
+ vector a = { 1, 5, 3 },
+ b = { 5, 0, 7 },
+ c;
+
+ bool retval = sub_vectors(&a, &b, &c);
+
+ CU_ASSERT_EQUAL(retval, true);
+
+ CU_ASSERT_EQUAL(c.x, -4);
+ CU_ASSERT_EQUAL(c.y, 5);
+ CU_ASSERT_EQUAL(c.z, -4);
+}
+
+/**
+ * Test substracting vectors, aliasing-safe.
+ */
+void test_sub_vectors2(void)
+{
+ vector a = { 1, 5, 3 },
+ b = { 5, 0, 7 };
+
+ bool retval = sub_vectors(&a, &b, &a);
+
+ CU_ASSERT_EQUAL(retval, true);
+
+ CU_ASSERT_EQUAL(a.x, -4);
+ CU_ASSERT_EQUAL(a.y, 5);
+ CU_ASSERT_EQUAL(a.z, -4);
+}
+
+/**
+ * Test substracting vectors, aliasing-safe.
+ */
+void test_sub_vectors3(void)
+{
+ vector a = { 1, 5, 3 },
+ b = { 5, 0, 7 };
+
+ bool retval = sub_vectors(&a, &b, &b);
+
+ CU_ASSERT_EQUAL(retval, true);
+
+ CU_ASSERT_EQUAL(b.x, -4);
+ CU_ASSERT_EQUAL(b.y, 5);
+ CU_ASSERT_EQUAL(b.z, -4);
+}
+
+/**
+ * Test error handling by passing a NULL pointer.
+ */
+void test_sub_vectors4(void)
+{
+ vector a = { 1, 5, 3 },
+ b = { 5, 0, 7 },
+ c;
+
+ bool retval = sub_vectors(&a, NULL, &c);
+
+ CU_ASSERT_EQUAL(retval, false);
+}
+
+/**
+ * Test error handling by passing a NULL pointer.
+ */
+void test_sub_vectors5(void)
+{
+ vector a = { 1, 5, 3 },
+ b = { 5, 0, 7 },
+ c;
+
+ bool retval = sub_vectors(&a, &b, NULL);
+
+ CU_ASSERT_EQUAL(retval, false);
+}
+
+/**
+ * Test error handling by passing a NULL pointer.
+ */
+void test_sub_vectors6(void)
+{
+ vector a = { 1, 5, 3 },
+ b = { 5, 0, 7 },
+ c;
+
+ bool retval = sub_vectors(NULL, &b, &c);
+
+ CU_ASSERT_EQUAL(retval, false);
+}
+
+/**
+ * Test normalizing a vector.
+ */
+void test_normalize_vector1(void)
+{
+ vector a = { 24, 0, 0 },
+ b;
+
+ bool retval = normalize_vector(&a, &b);
+
+ CU_ASSERT_EQUAL(retval, true);
+
+ CU_ASSERT_EQUAL(b.x, 1.0f);
+ CU_ASSERT_EQUAL(b.y, 0.0f);
+ CU_ASSERT_EQUAL(b.z, 0.0f);
+}
+
+/**
+ * Test normalizing a vector, aliasing-safe.
+ */
+void test_normalize_vector2(void)
+{
+ vector a = { 24, 0, 0 };
+
+ bool retval = normalize_vector(&a, &a);
+
+ CU_ASSERT_EQUAL(retval, true);
+
+ CU_ASSERT_EQUAL(a.x, 1.0f);
+ CU_ASSERT_EQUAL(a.y, 0.0f);
+ CU_ASSERT_EQUAL(a.z, 0.0f);
+}
+
+/**
+ * Test error handling by passing a NULL pointer.
+ */
+void test_normalize_vector3(void)
+{
+ vector a = { 1, 5, 3 },
+ b = { 5, 0, 7 };
+
+ bool retval = normalize_vector(&a, NULL);
+
+ CU_ASSERT_EQUAL(retval, false);
+}
+
+/**
+ * Test error handling by passing a NULL pointer.
+ */
+void test_normalize_vector4(void)
+{
+ vector a = { 1, 5, 3 },
+ b = { 5, 0, 7 };
+
+ bool retval = normalize_vector(NULL, &b);
+
+ CU_ASSERT_EQUAL(retval, false);
+}
+
+/**
+ * Test copying vectors.
+ */
+void test_copy_vector1(void)
+{
+ vector a = { 1, 5, 3 },
+ b;
+
+ bool retval = copy_vector(&a, &b);
+
+ CU_ASSERT_EQUAL(retval, true);
+
+ CU_ASSERT_EQUAL(b.x, 1);
+ CU_ASSERT_EQUAL(b.y, 5);
+ CU_ASSERT_EQUAL(b.z, 3);
+}
+
+/**
+ * Test error handling by passing a NULL pointer.
+ */
+void test_copy_vector2(void)
+{
+ vector a = { 1, 5, 3 },
+ b;
+
+ bool retval = copy_vector(&a, NULL);
+
+ CU_ASSERT_EQUAL(retval, false);
+}
+
+/**
+ * Test error handling by passing a NULL pointer.
+ */
+void test_copy_vector3(void)
+{
+ vector a = { 1, 5, 3 },
+ b;
+
+ bool retval = copy_vector(NULL, &b);
+
+ CU_ASSERT_EQUAL(retval, false);
+}