Added *vec1 tests

test/ext/CMakeLists.txt

@@ -1,6 +1,9 @@
 glmCreateTestGTC(ext_matrix_relational)
 glmCreateTestGTC(ext_scalar_relational)
 glmCreateTestGTC(ext_vec1)
+glmCreateTestGTC(ext_vector_vec1)
 glmCreateTestGTC(ext_vector_bvec1)
+glmCreateTestGTC(ext_vector_dvec1)
+glmCreateTestGTC(ext_vector_ivec1)
 glmCreateTestGTC(ext_vector_uvec1)
 glmCreateTestGTC(ext_vector_relational)

test/ext/ext_vector_dvec1.cpp

@@ -0,0 +1,130 @@
+#include <glm/gtc/constants.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/vector_dvec1.hpp>
+#include <glm/ext/vector_dvec1_precision.hpp>
+#include <glm/vector_dvec2.hpp>
+#include <glm/vector_dvec3.hpp>
+#include <glm/vector_dvec4.hpp>
+
+template <typename genType>
+static int test_operators()
+{
+	int Error = 0;
+
+	{
+		genType const A(1);
+		genType const B(1);
+
+		genType const C = A + B;
+		Error += glm::all(glm::equal(C, genType(2), glm::epsilon<double>())) ? 0 : 1;
+
+		genType const D = A - B;
+		Error += glm::all(glm::equal(D, genType(0), glm::epsilon<double>())) ? 0 : 1;
+
+		genType const E = A * B;
+		Error += glm::all(glm::equal(E, genType(1), glm::epsilon<double>())) ? 0 : 1;
+
+		genType const F = A / B;
+		Error += glm::all(glm::equal(F, genType(1), glm::epsilon<double>())) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+template <typename genType>
+static int test_ctor()
+{
+	int Error = 0;
+
+	glm::dvec1 const A = genType(1);
+
+	glm::dvec1 const E(genType(1));
+	Error += glm::all(glm::equal(A, E, glm::epsilon<double>())) ? 0 : 1;
+
+	glm::dvec1 const F(E);
+	Error += glm::all(glm::equal(A, F, glm::epsilon<double>())) ? 0 : 1;
+
+	genType const B = genType(1);
+	genType const G(glm::dvec2(1));
+	Error += glm::all(glm::equal(B, G, glm::epsilon<double>())) ? 0 : 1;
+
+	genType const H(glm::dvec3(1));
+	Error += glm::all(glm::equal(B, H, glm::epsilon<double>())) ? 0 : 1;
+
+	genType const I(glm::dvec4(1));
+	Error += glm::all(glm::equal(B, I, glm::epsilon<double>())) ? 0 : 1;
+
+	return Error;
+}
+
+template <typename genType>
+static int test_size()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::dvec1) == sizeof(genType) ? 0 : 1;
+	Error += genType().length() == 1 ? 0 : 1;
+	Error += genType::length() == 1 ? 0 : 1;
+
+	return Error;
+}
+
+template <typename genType>
+static int test_relational()
+{
+	int Error = 0;
+
+	genType const A(1);
+	genType const B(1);
+	genType const C(0);
+
+	Error += all(equal(A, B, glm::epsilon<double>())) ? 0 : 1;
+	Error += any(notEqual(A, C, glm::epsilon<double>())) ? 0 : 1;
+
+	return Error;
+}
+
+template <typename genType>
+static int test_constexpr()
+{
+#	if GLM_CONFIG_CONSTEXP == GLM_ENABLE
+		static_assert(genType::length() == 1, "GLM: Failed constexpr");
+		static_assert(glm::equal(genType(1)[0], 1.0, glm::epsilon<double>()), "GLM: Failed constexpr");
+		static_assert(glm::all(glm::equal(genType(1), genType(glm::vec1(1), glm::epsilon<double>()), "GLM: Failed constexpr");
+		static_assert(glm::all(glm::notEqual(genType(1), genType(0), glm::epsilon<double>())), "GLM: Failed constexpr");
+#	endif
+
+	return 0;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_operators<glm::dvec1>();
+	Error += test_operators<glm::lowp_dvec1>();
+	Error += test_operators<glm::mediump_dvec1>();
+	Error += test_operators<glm::highp_dvec1>();
+
+	Error += test_ctor<glm::dvec1>();
+	Error += test_ctor<glm::lowp_dvec1>();
+	Error += test_ctor<glm::mediump_dvec1>();
+	Error += test_ctor<glm::highp_dvec1>();
+
+	Error += test_size<glm::dvec1>();
+	Error += test_size<glm::lowp_dvec1>();
+	Error += test_size<glm::mediump_dvec1>();
+	Error += test_size<glm::highp_dvec1>();
+
+	Error += test_relational<glm::dvec1>();
+	Error += test_relational<glm::lowp_dvec1>();
+	Error += test_relational<glm::mediump_dvec1>();
+	Error += test_relational<glm::highp_dvec1>();
+
+	Error += test_constexpr<glm::dvec1>();
+	Error += test_constexpr<glm::lowp_dvec1>();
+	Error += test_constexpr<glm::mediump_dvec1>();
+	Error += test_constexpr<glm::highp_dvec1>();
+
+	return Error;
+}

test/ext/ext_vector_ivec1.cpp

@@ -0,0 +1,180 @@
+#include <glm/ext/vector_ivec1.hpp>
+#include <glm/ext/vector_ivec1_precision.hpp>
+#include <glm/vector_ivec2.hpp>
+#include <glm/vector_ivec3.hpp>
+#include <glm/vector_ivec4.hpp>
+#include <glm/vector_relational.hpp>
+
+template <typename genType>
+static int test_operators()
+{
+	int Error = 0;
+
+	{
+		genType const A(1);
+		genType const B(1);
+
+		bool const R = A != B;
+		bool const S = A == B;
+		Error += (S && !R) ? 0 : 1;
+	}
+
+	{
+		genType const A(1);
+		genType const B(1);
+
+		genType const C = A + B;
+		Error += C == genType(2) ? 0 : 1;
+
+		genType const D = A - B;
+		Error += D == genType(0) ? 0 : 1;
+
+		genType const E = A * B;
+		Error += E == genType(1) ? 0 : 1;
+
+		genType const F = A / B;
+		Error += F == genType(1) ? 0 : 1;
+	}
+
+	{
+		genType const A(3);
+		genType const B(2);
+
+		genType const C = A % B;
+		Error += C == genType(1) ? 0 : 1;
+	}
+
+	{
+		genType const A(1);
+		genType const B(1);
+		genType const C(0);
+
+		genType const I = A & B;
+		Error += I == genType(1) ? 0 : 1;
+		genType const D = A & C;
+		Error += D == genType(0) ? 0 : 1;
+
+		genType const E = A | B;
+		Error += E == genType(1) ? 0 : 1;
+		genType const F = A | C;
+		Error += F == genType(1) ? 0 : 1;
+
+		genType const G = A ^ B;
+		Error += G == genType(0) ? 0 : 1;
+		genType const H = A ^ C;
+		Error += H == genType(1) ? 0 : 1;
+	}
+
+	{
+		genType const A(0);
+		genType const B(1);
+		genType const C(2);
+
+		genType const D = B << B;
+		Error += D == genType(2) ? 0 : 1;
+		genType const E = C >> B;
+		Error += E == genType(1) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+template <typename genType>
+static int test_ctor()
+{
+	int Error = 0;
+
+	glm::ivec1 const A = genType(1);
+
+	glm::ivec1 const E(genType(1));
+	Error += A == E ? 0 : 1;
+
+	glm::ivec1 const F(E);
+	Error += A == F ? 0 : 1;
+
+	genType const B = genType(1);
+	genType const G(glm::ivec2(1));
+	Error += B == G ? 0 : 1;
+
+	genType const H(glm::ivec3(1));
+	Error += B == H ? 0 : 1;
+
+	genType const I(glm::ivec4(1));
+	Error += B == I ? 0 : 1;
+
+	return Error;
+}
+
+template <typename genType>
+static int test_size()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::ivec1) == sizeof(genType) ? 0 : 1;
+	Error += genType().length() == 1 ? 0 : 1;
+	Error += genType::length() == 1 ? 0 : 1;
+
+	return Error;
+}
+
+template <typename genType>
+static int test_relational()
+{
+	int Error = 0;
+
+	genType const A(1);
+	genType const B(1);
+	genType const C(0);
+
+	Error += A == B ? 0 : 1;
+	Error += A != C ? 0 : 1;
+	Error += all(equal(A, B)) ? 0 : 1;
+	Error += any(notEqual(A, C)) ? 0 : 1;
+
+	return Error;
+}
+
+template <typename genType>
+static int test_constexpr()
+{
+#	if GLM_CONFIG_CONSTEXP == GLM_ENABLE
+		static_assert(genType::length() == 1, "GLM: Failed constexpr");
+		static_assert(genType(1)[0] == 1, "GLM: Failed constexpr");
+		static_assert(genType(1) == genType(glm::ivec1(1)), "GLM: Failed constexpr");
+		static_assert(genType(1) != genType(0), "GLM: Failed constexpr");
+#	endif
+
+	return 0;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_operators<glm::ivec1>();
+	Error += test_operators<glm::lowp_ivec1>();
+	Error += test_operators<glm::mediump_ivec1>();
+	Error += test_operators<glm::highp_ivec1>();
+
+	Error += test_ctor<glm::ivec1>();
+	Error += test_ctor<glm::lowp_ivec1>();
+	Error += test_ctor<glm::mediump_ivec1>();
+	Error += test_ctor<glm::highp_ivec1>();
+
+	Error += test_size<glm::ivec1>();
+	Error += test_size<glm::lowp_ivec1>();
+	Error += test_size<glm::mediump_ivec1>();
+	Error += test_size<glm::highp_ivec1>();
+
+	Error += test_relational<glm::ivec1>();
+	Error += test_relational<glm::lowp_ivec1>();
+	Error += test_relational<glm::mediump_ivec1>();
+	Error += test_relational<glm::highp_ivec1>();
+
+	Error += test_constexpr<glm::ivec1>();
+	Error += test_constexpr<glm::lowp_ivec1>();
+	Error += test_constexpr<glm::mediump_ivec1>();
+	Error += test_constexpr<glm::highp_ivec1>();
+
+	return Error;
+}

test/ext/ext_vector_uvec1.cpp

@@ -36,6 +36,46 @@ static int test_operators()
 		Error += F == genType(1) ? 0 : 1;
 	}
 
+	{
+		genType const A(3);
+		genType const B(2);
+
+		genType const C = A % B;
+		Error += C == genType(1) ? 0 : 1;
+	}
+
+	{
+		genType const A(1);
+		genType const B(1);
+		genType const C(0);
+
+		genType const I = A & B;
+		Error += I == genType(1) ? 0 : 1;
+		genType const D = A & C;
+		Error += D == genType(0) ? 0 : 1;
+
+		genType const E = A | B;
+		Error += E == genType(1) ? 0 : 1;
+		genType const F = A | C;
+		Error += F == genType(1) ? 0 : 1;
+
+		genType const G = A ^ B;
+		Error += G == genType(0) ? 0 : 1;
+		genType const H = A ^ C;
+		Error += H == genType(1) ? 0 : 1;
+	}
+
+	{
+		genType const A(0);
+		genType const B(1);
+		genType const C(2);
+
+		genType const D = B << B;
+		Error += D == genType(2) ? 0 : 1;
+		genType const E = C >> B;
+		Error += E == genType(1) ? 0 : 1;
+	}
+
 	return Error;
 }
 

test/ext/ext_vector_vec1.cpp

@@ -0,0 +1,130 @@
+#include <glm/gtc/constants.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/vector_vec1.hpp>
+#include <glm/ext/vector_vec1_precision.hpp>
+#include <glm/vector_vec2.hpp>
+#include <glm/vector_vec3.hpp>
+#include <glm/vector_vec4.hpp>
+
+template <typename genType>
+static int test_operators()
+{
+	int Error = 0;
+
+	{
+		genType const A(1);
+		genType const B(1);
+
+		genType const C = A + B;
+		Error += glm::all(glm::equal(C, genType(2), glm::epsilon<float>())) ? 0 : 1;
+
+		genType const D = A - B;
+		Error += glm::all(glm::equal(D, genType(0), glm::epsilon<float>())) ? 0 : 1;
+
+		genType const E = A * B;
+		Error += glm::all(glm::equal(E, genType(1), glm::epsilon<float>())) ? 0 : 1;
+
+		genType const F = A / B;
+		Error += glm::all(glm::equal(F, genType(1), glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+template <typename genType>
+static int test_ctor()
+{
+	int Error = 0;
+
+	glm::vec1 const A = genType(1);
+
+	glm::vec1 const E(genType(1));
+	Error += glm::all(glm::equal(A, E, glm::epsilon<float>())) ? 0 : 1;
+
+	glm::vec1 const F(E);
+	Error += glm::all(glm::equal(A, F, glm::epsilon<float>())) ? 0 : 1;
+
+	genType const B = genType(1);
+	genType const G(glm::vec2(1));
+	Error += glm::all(glm::equal(B, G, glm::epsilon<float>())) ? 0 : 1;
+
+	genType const H(glm::vec3(1));
+	Error += glm::all(glm::equal(B, H, glm::epsilon<float>())) ? 0 : 1;
+
+	genType const I(glm::vec4(1));
+	Error += glm::all(glm::equal(B, I, glm::epsilon<float>())) ? 0 : 1;
+
+	return Error;
+}
+
+template <typename genType>
+static int test_size()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::vec1) == sizeof(genType) ? 0 : 1;
+	Error += genType().length() == 1 ? 0 : 1;
+	Error += genType::length() == 1 ? 0 : 1;
+
+	return Error;
+}
+
+template <typename genType>
+static int test_relational()
+{
+	int Error = 0;
+
+	genType const A(1);
+	genType const B(1);
+	genType const C(0);
+
+	Error += all(equal(A, B, glm::epsilon<float>())) ? 0 : 1;
+	Error += any(notEqual(A, C, glm::epsilon<float>())) ? 0 : 1;
+
+	return Error;
+}
+
+template <typename genType>
+static int test_constexpr()
+{
+#	if GLM_CONFIG_CONSTEXP == GLM_ENABLE
+		static_assert(genType::length() == 1, "GLM: Failed constexpr");
+		static_assert(glm::equal(genType(1)[0], 1.0f, glm::epsilon<float>()), "GLM: Failed constexpr");
+		static_assert(glm::all(glm::equal(genType(1), genType(glm::vec1(1), glm::epsilon<float>()), "GLM: Failed constexpr");
+		static_assert(glm::all(glm::notEqual(genType(1), genType(0), glm::epsilon<float>())), "GLM: Failed constexpr");
+#	endif
+
+	return 0;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_operators<glm::vec1>();
+	Error += test_operators<glm::lowp_vec1>();
+	Error += test_operators<glm::mediump_vec1>();
+	Error += test_operators<glm::highp_vec1>();
+
+	Error += test_ctor<glm::vec1>();
+	Error += test_ctor<glm::lowp_vec1>();
+	Error += test_ctor<glm::mediump_vec1>();
+	Error += test_ctor<glm::highp_vec1>();
+
+	Error += test_size<glm::vec1>();
+	Error += test_size<glm::lowp_vec1>();
+	Error += test_size<glm::mediump_vec1>();
+	Error += test_size<glm::highp_vec1>();
+
+	Error += test_relational<glm::vec1>();
+	Error += test_relational<glm::lowp_vec1>();
+	Error += test_relational<glm::mediump_vec1>();
+	Error += test_relational<glm::highp_vec1>();
+
+	Error += test_constexpr<glm::vec1>();
+	Error += test_constexpr<glm::lowp_vec1>();
+	Error += test_constexpr<glm::mediump_vec1>();
+	Error += test_constexpr<glm::highp_vec1>();
+
+	return Error;
+}