lolengine
/
lol
mirror of https://github.com/lolengine/lol
1
0
Fork 0
Code Issues 0 Releases 0 Wiki Activity
Browse Source

lolunit: switch assert macros to lowercase.

undefined
Sam Hocevar 11 years ago
parent
5da959e6e4
commit
6b64e2c337
25 changed files with 1375 additions and 1367 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +90
    -90
      src/t/base/array.cpp
  2. +8
    -8
      src/t/base/enum.cpp
  3. +12
    -12
      src/t/base/map.cpp
  4. +89
    -89
      src/t/base/string.cpp
  5. +55
    -55
      src/t/base/types.cpp
  6. +70
    -70
      src/t/entity/camera.cpp
  7. +18
    -18
      src/t/image/color.cpp
  8. +11
    -11
      src/t/image/image.cpp
  9. +25
    -25
      src/t/math/array2d.cpp
  10. +44
    -44
      src/t/math/array3d.cpp
  11. +49
    -49
      src/t/math/arraynd.cpp
  12. +9
    -9
      src/t/math/box.cpp
  13. +28
    -28
      src/t/math/cmplx.cpp
  14. +110
    -110
      src/t/math/half.cpp
  15. +7
    -7
      src/t/math/interp.cpp
  16. +65
    -65
      src/t/math/matrix.cpp
  17. +184
    -184
      src/t/math/quat.cpp
  18. +19
    -19
      src/t/math/rand.cpp
  19. +117
    -117
      src/t/math/real.cpp
  20. +72
    -72
      src/t/math/rotation.cpp
  21. +36
    -36
      src/t/math/trig.cpp
  22. +138
    -138
      src/t/math/vector.cpp
  23. +9
    -9
      src/t/sys/thread.cpp
  24. +105
    -102
      tools/lolunit/lolunit.h
  25. +5
    -0
      tools/vimlol/vimlol.vim

+ 90
- 90
src/t/base/array.cpp View File

@@ -30,13 +30,13 @@ struct TrackedObj
int TrackedObj::m_ctor = 0;
int TrackedObj::m_dtor = 0;

LOLUNIT_FIXTURE(ArrayTest)
lolunit_declare_fixture(ArrayTest)
{
void SetUp() {}

void TearDown() {}

LOLUNIT_TEST(ArrayPush)
lolunit_declare_test(ArrayPush)
{
array<int> a;
a.Push(0);
@@ -44,188 +44,188 @@ LOLUNIT_FIXTURE(ArrayTest)
a.Push(2);
a.Push(3);

LOLUNIT_ASSERT_EQUAL(a[0], 0);
LOLUNIT_ASSERT_EQUAL(a[1], 1);
LOLUNIT_ASSERT_EQUAL(a[2], 2);
LOLUNIT_ASSERT_EQUAL(a[3], 3);
lolunit_assert_equal(a[0], 0);
lolunit_assert_equal(a[1], 1);
lolunit_assert_equal(a[2], 2);
lolunit_assert_equal(a[3], 3);
}

LOLUNIT_TEST(ArrayInitializer)
lolunit_declare_test(ArrayInitializer)
{
array<int> a({ 2, 4, 6 });

LOLUNIT_ASSERT_EQUAL(a[0], 2);
LOLUNIT_ASSERT_EQUAL(a[1], 4);
LOLUNIT_ASSERT_EQUAL(a[2], 6);
lolunit_assert_equal(a[0], 2);
lolunit_assert_equal(a[1], 4);
lolunit_assert_equal(a[2], 6);

array<int> b = { 2, 4, 6 };

LOLUNIT_ASSERT_EQUAL(b[0], 2);
LOLUNIT_ASSERT_EQUAL(b[1], 4);
LOLUNIT_ASSERT_EQUAL(b[2], 6);
lolunit_assert_equal(b[0], 2);
lolunit_assert_equal(b[1], 4);
lolunit_assert_equal(b[2], 6);

array<int, float> c = { { 2, 3.0f },
{ 4, 5.0f },
{ 6, 7.0f } };

LOLUNIT_ASSERT_EQUAL(c[0].m1, 2);
LOLUNIT_ASSERT_EQUAL(c[0].m2, 3.0f);
LOLUNIT_ASSERT_EQUAL(c[1].m1, 4);
LOLUNIT_ASSERT_EQUAL(c[1].m2, 5.0f);
LOLUNIT_ASSERT_EQUAL(c[2].m1, 6);
LOLUNIT_ASSERT_EQUAL(c[2].m2, 7.0f);
lolunit_assert_equal(c[0].m1, 2);
lolunit_assert_equal(c[0].m2, 3.0f);
lolunit_assert_equal(c[1].m1, 4);
lolunit_assert_equal(c[1].m2, 5.0f);
lolunit_assert_equal(c[2].m1, 6);
lolunit_assert_equal(c[2].m2, 7.0f);
}

LOLUNIT_TEST(ArrayPushWithShift)
lolunit_declare_test(ArrayPushWithShift)
{
array<int> a;
a << 0 << 1 << 2 << 3;

LOLUNIT_ASSERT_EQUAL(a[0], 0);
LOLUNIT_ASSERT_EQUAL(a[1], 1);
LOLUNIT_ASSERT_EQUAL(a[2], 2);
LOLUNIT_ASSERT_EQUAL(a[3], 3);
lolunit_assert_equal(a[0], 0);
lolunit_assert_equal(a[1], 1);
lolunit_assert_equal(a[2], 2);
lolunit_assert_equal(a[3], 3);
}

LOLUNIT_TEST(ArrayCopy)
lolunit_declare_test(ArrayCopy)
{
array<int> a;
a << 0 << 1 << 2 << 3;

array<int> b = a;

LOLUNIT_ASSERT_EQUAL(b[0], 0);
LOLUNIT_ASSERT_EQUAL(b[1], 1);
LOLUNIT_ASSERT_EQUAL(b[2], 2);
LOLUNIT_ASSERT_EQUAL(b[3], 3);
lolunit_assert_equal(b[0], 0);
lolunit_assert_equal(b[1], 1);
lolunit_assert_equal(b[2], 2);
lolunit_assert_equal(b[3], 3);
}

LOLUNIT_TEST(ArrayRemove)
lolunit_declare_test(ArrayRemove)
{
array<int> a;
a << 0 << 1 << 2 << 3;
a.Remove(1);

LOLUNIT_ASSERT_EQUAL(a.Count(), 3);
LOLUNIT_ASSERT_EQUAL(a[0], 0);
LOLUNIT_ASSERT_EQUAL(a[1], 2);
LOLUNIT_ASSERT_EQUAL(a[2], 3);
lolunit_assert_equal(a.Count(), 3);
lolunit_assert_equal(a[0], 0);
lolunit_assert_equal(a[1], 2);
lolunit_assert_equal(a[2], 3);

array<int> b;
b << 0 << 1 << 2 << 3;
b.Remove(-2);

LOLUNIT_ASSERT_EQUAL(b.Count(), 3);
LOLUNIT_ASSERT_EQUAL(b[0], 0);
LOLUNIT_ASSERT_EQUAL(b[1], 1);
LOLUNIT_ASSERT_EQUAL(b[2], 3);
lolunit_assert_equal(b.Count(), 3);
lolunit_assert_equal(b[0], 0);
lolunit_assert_equal(b[1], 1);
lolunit_assert_equal(b[2], 3);
}

LOLUNIT_TEST(ArrayRemoveSwap)
lolunit_declare_test(ArrayRemoveSwap)
{
array<int> a;
a << 0 << 1 << 2 << 3;
a.RemoveSwap(1);

LOLUNIT_ASSERT_EQUAL(a.Count(), 3);
LOLUNIT_ASSERT_EQUAL(a[0], 0);
LOLUNIT_ASSERT_EQUAL(a[1], 3);
LOLUNIT_ASSERT_EQUAL(a[2], 2);
lolunit_assert_equal(a.Count(), 3);
lolunit_assert_equal(a[0], 0);
lolunit_assert_equal(a[1], 3);
lolunit_assert_equal(a[2], 2);

array<int> b;
b << 0 << 1 << 2 << 3;
b.Remove(1, 2);

LOLUNIT_ASSERT_EQUAL(b.Count(), 2);
LOLUNIT_ASSERT_EQUAL(b[0], 0);
LOLUNIT_ASSERT_EQUAL(b[1], 3);
lolunit_assert_equal(b.Count(), 2);
lolunit_assert_equal(b[0], 0);
lolunit_assert_equal(b[1], 3);
}

LOLUNIT_TEST(EightElements)
lolunit_declare_test(EightElements)
{
array<int, long, float, double, unsigned, char, bool, void *> a;
a.Push(1, 2, 3.f, 4.0, 5, 'a', true, 0);

LOLUNIT_ASSERT_EQUAL(a[0].m1, 1);
LOLUNIT_ASSERT_EQUAL(a[0].m2, 2);
LOLUNIT_ASSERT_EQUAL(a[0].m3, 3.f);
LOLUNIT_ASSERT_EQUAL(a[0].m4, 4.0);
LOLUNIT_ASSERT_EQUAL(a[0].m5, 5);
LOLUNIT_ASSERT_EQUAL(a[0].m6, 'a');
LOLUNIT_ASSERT_EQUAL(a[0].m7, true);
LOLUNIT_ASSERT_EQUAL(a[0].m8, 0);
lolunit_assert_equal(a[0].m1, 1);
lolunit_assert_equal(a[0].m2, 2);
lolunit_assert_equal(a[0].m3, 3.f);
lolunit_assert_equal(a[0].m4, 4.0);
lolunit_assert_equal(a[0].m5, 5);
lolunit_assert_equal(a[0].m6, 'a');
lolunit_assert_equal(a[0].m7, true);
lolunit_assert_equal(a[0].m8, 0);
}

LOLUNIT_TEST(ArraySwap)
lolunit_declare_test(ArraySwap)
{
array<int, int> a;
a.Push(10, 20);
a.Push(30, 40);
a.Swap(0, 1);

LOLUNIT_ASSERT_EQUAL(30, a[0].m1);
LOLUNIT_ASSERT_EQUAL(40, a[0].m2);
LOLUNIT_ASSERT_EQUAL(10, a[1].m1);
LOLUNIT_ASSERT_EQUAL(20, a[1].m2);
lolunit_assert_equal(30, a[0].m1);
lolunit_assert_equal(40, a[0].m2);
lolunit_assert_equal(10, a[1].m1);
lolunit_assert_equal(20, a[1].m2);
}

LOLUNIT_TEST(ArrayInsert)
lolunit_declare_test(ArrayInsert)
{
array<int> a;
a << 1 << 2;

a.Insert(5, 0);
LOLUNIT_ASSERT_EQUAL(5, a[0]);
LOLUNIT_ASSERT_EQUAL(1, a[1]);
LOLUNIT_ASSERT_EQUAL(2, a[2]);
lolunit_assert_equal(5, a[0]);
lolunit_assert_equal(1, a[1]);
lolunit_assert_equal(2, a[2]);

a.Insert(6, 3);
LOLUNIT_ASSERT_EQUAL(5, a[0]);
LOLUNIT_ASSERT_EQUAL(1, a[1]);
LOLUNIT_ASSERT_EQUAL(2, a[2]);
LOLUNIT_ASSERT_EQUAL(6, a[3]);
lolunit_assert_equal(5, a[0]);
lolunit_assert_equal(1, a[1]);
lolunit_assert_equal(2, a[2]);
lolunit_assert_equal(6, a[3]);

a.Insert(7, 2);
LOLUNIT_ASSERT_EQUAL(5, a[0]);
LOLUNIT_ASSERT_EQUAL(1, a[1]);
LOLUNIT_ASSERT_EQUAL(7, a[2]);
LOLUNIT_ASSERT_EQUAL(2, a[3]);
LOLUNIT_ASSERT_EQUAL(6, a[4]);
lolunit_assert_equal(5, a[0]);
lolunit_assert_equal(1, a[1]);
lolunit_assert_equal(7, a[2]);
lolunit_assert_equal(2, a[3]);
lolunit_assert_equal(6, a[4]);
}

LOLUNIT_TEST(ArrayConcat)
lolunit_declare_test(ArrayConcat)
{
array<int> a, b;
a << 0 << 1;
b << 2 << 3;

array<int> c = a + b;
LOLUNIT_ASSERT_EQUAL(c[0], 0);
LOLUNIT_ASSERT_EQUAL(c[1], 1);
LOLUNIT_ASSERT_EQUAL(c[2], 2);
LOLUNIT_ASSERT_EQUAL(c[3], 3);
lolunit_assert_equal(c[0], 0);
lolunit_assert_equal(c[1], 1);
lolunit_assert_equal(c[2], 2);
lolunit_assert_equal(c[3], 3);
}

LOLUNIT_TEST(ArrayAppend)
lolunit_declare_test(ArrayAppend)
{
array<int> a, b;
a << 0 << 1;
b << 2 << 3;

a += b;
LOLUNIT_ASSERT_EQUAL(a[0], 0);
LOLUNIT_ASSERT_EQUAL(a[1], 1);
LOLUNIT_ASSERT_EQUAL(a[2], 2);
LOLUNIT_ASSERT_EQUAL(a[3], 3);
lolunit_assert_equal(a[0], 0);
lolunit_assert_equal(a[1], 1);
lolunit_assert_equal(a[2], 2);
lolunit_assert_equal(a[3], 3);

b += b;
LOLUNIT_ASSERT_EQUAL(b[0], 2);
LOLUNIT_ASSERT_EQUAL(b[1], 3);
LOLUNIT_ASSERT_EQUAL(b[2], 2);
LOLUNIT_ASSERT_EQUAL(b[3], 3);
lolunit_assert_equal(b[0], 2);
lolunit_assert_equal(b[1], 3);
lolunit_assert_equal(b[2], 2);
lolunit_assert_equal(b[3], 3);
}

LOLUNIT_TEST(ElementCtorDtor)
lolunit_declare_test(ElementCtorDtor)
{
/* Ensure array elements get created and destroyed the proper
* number of times. */
@@ -236,7 +236,7 @@ LOLUNIT_FIXTURE(ArrayTest)

a.Push(TrackedObj());
}
LOLUNIT_ASSERT_EQUAL(TrackedObj::m_ctor, TrackedObj::m_dtor);
lolunit_assert_equal(TrackedObj::m_ctor, TrackedObj::m_dtor);

TrackedObj::m_ctor = 0;
TrackedObj::m_dtor = 0;
@@ -247,7 +247,7 @@ LOLUNIT_FIXTURE(ArrayTest)
a.Resize(4);
a.Resize(1);
}
LOLUNIT_ASSERT_EQUAL(TrackedObj::m_ctor, TrackedObj::m_dtor);
lolunit_assert_equal(TrackedObj::m_ctor, TrackedObj::m_dtor);
}
};



+ 8
- 8
src/t/base/enum.cpp View File

@@ -18,13 +18,13 @@
namespace lol
{

LOLUNIT_FIXTURE(EnumTest)
lolunit_declare_fixture(EnumTest)
{
void SetUp() {}

void TearDown() {}

LOLUNIT_TEST(EnumToString)
lolunit_declare_test(EnumToString)
{
LOL_SAFE_ENUM(MyEnum,
First = -10,
@@ -33,18 +33,18 @@ LOLUNIT_FIXTURE(EnumTest)
);

MyEnum e = MyEnum::First;
LOLUNIT_ASSERT(e.ToString() == "First");
lolunit_assert(e.ToString() == "First");

e = MyEnum::Second;
LOLUNIT_ASSERT(e.ToString() == "Second");
lolunit_assert(e.ToString() == "Second");

e = MyEnum::Third;
LOLUNIT_ASSERT(e.ToString() == "Third");
lolunit_assert(e.ToString() == "Third");

e = MyEnum(42);
LOLUNIT_ASSERT(e.ToString() != "First");
LOLUNIT_ASSERT(e.ToString() != "Second");
LOLUNIT_ASSERT(e.ToString() != "Third");
lolunit_assert(e.ToString() != "First");
lolunit_assert(e.ToString() != "Second");
lolunit_assert(e.ToString() != "Third");
}
};



+ 12
- 12
src/t/base/map.cpp View File

@@ -18,13 +18,13 @@
namespace lol
{

LOLUNIT_FIXTURE(MapTest)
lolunit_declare_fixture(MapTest)
{
void SetUp() {}

void TearDown() {}

LOLUNIT_TEST(MapDeclare)
lolunit_declare_test(MapDeclare)
{
map<uint8_t, uint8_t> m1;
map<int, int> m2;
@@ -32,7 +32,7 @@ LOLUNIT_FIXTURE(MapTest)
map<char const *, char const *> m4;
}

LOLUNIT_TEST(MapSet)
lolunit_declare_test(MapSet)
{
map<int, int> map;

@@ -43,22 +43,22 @@ LOLUNIT_FIXTURE(MapTest)
map[i] = i;

for (int i = 0; i < 1000; i++)
LOLUNIT_ASSERT_EQUAL(map[i], i);
lolunit_assert_equal(map[i], i);
}

LOLUNIT_TEST(MapHasKey)
lolunit_declare_test(MapHasKey)
{
map<int, int> map;

map[0] = 1;
map[2] = 2;

LOLUNIT_ASSERT(map.HasKey(0));
LOLUNIT_ASSERT(!map.HasKey(1));
LOLUNIT_ASSERT(map.HasKey(2));
lolunit_assert(map.HasKey(0));
lolunit_assert(!map.HasKey(1));
lolunit_assert(map.HasKey(2));
}

LOLUNIT_TEST(StringMap)
lolunit_declare_test(StringMap)
{
map<char const *, int> map;

@@ -70,9 +70,9 @@ LOLUNIT_FIXTURE(MapTest)
int bar = map["bar"];
int baz = map["baz"];

LOLUNIT_ASSERT_EQUAL(42, foo);
LOLUNIT_ASSERT_EQUAL(12, bar);
LOLUNIT_ASSERT_EQUAL(2, baz);
lolunit_assert_equal(42, foo);
lolunit_assert_equal(12, bar);
lolunit_assert_equal(2, baz);
}
};



+ 89
- 89
src/t/base/string.cpp View File

@@ -18,163 +18,163 @@
namespace lol
{

LOLUNIT_FIXTURE(StringTest)
lolunit_declare_fixture(StringTest)
{
void SetUp() {}

void TearDown() {}

LOLUNIT_TEST(StringBuild)
lolunit_declare_test(StringBuild)
{
String s1;
LOLUNIT_ASSERT_EQUAL(s1.Count(), 0);
LOLUNIT_ASSERT_EQUAL(s1[0], '\0');
lolunit_assert_equal(s1.Count(), 0);
lolunit_assert_equal(s1[0], '\0');

String s2("");
LOLUNIT_ASSERT_EQUAL(s2.Count(), 0);
LOLUNIT_ASSERT_EQUAL(s2[0], '\0');
lolunit_assert_equal(s2.Count(), 0);
lolunit_assert_equal(s2[0], '\0');

String s3("a");
LOLUNIT_ASSERT_EQUAL(s3.Count(), 1);
LOLUNIT_ASSERT_EQUAL(s3[0], 'a');
LOLUNIT_ASSERT_EQUAL(s3[1], '\0');
lolunit_assert_equal(s3.Count(), 1);
lolunit_assert_equal(s3[0], 'a');
lolunit_assert_equal(s3[1], '\0');

String s4(s3);
LOLUNIT_ASSERT_EQUAL(s4.Count(), 1);
LOLUNIT_ASSERT_EQUAL(s4[0], 'a');
LOLUNIT_ASSERT_EQUAL(s4[1], '\0');
lolunit_assert_equal(s4.Count(), 1);
lolunit_assert_equal(s4[0], 'a');
lolunit_assert_equal(s4[1], '\0');
}

LOLUNIT_TEST(StringAppendChar)
lolunit_declare_test(StringAppendChar)
{
String s;
s += 'a';
s += 'b';
s += 'c';

LOLUNIT_ASSERT_EQUAL(s[0], 'a');
LOLUNIT_ASSERT_EQUAL(s[1], 'b');
LOLUNIT_ASSERT_EQUAL(s[2], 'c');
LOLUNIT_ASSERT_EQUAL(s[3], '\0');
lolunit_assert_equal(s[0], 'a');
lolunit_assert_equal(s[1], 'b');
lolunit_assert_equal(s[2], 'c');
lolunit_assert_equal(s[3], '\0');
}

LOLUNIT_TEST(StringCopy)
lolunit_declare_test(StringCopy)
{
String s1 = "abc";

String s2 = s1;

LOLUNIT_ASSERT_EQUAL(s1[0], s2[0]);
LOLUNIT_ASSERT_EQUAL(s1[1], s2[1]);
LOLUNIT_ASSERT_EQUAL(s1[2], s2[2]);
LOLUNIT_ASSERT_EQUAL(s1[3], s2[3]);
lolunit_assert_equal(s1[0], s2[0]);
lolunit_assert_equal(s1[1], s2[1]);
lolunit_assert_equal(s1[2], s2[2]);
lolunit_assert_equal(s1[3], s2[3]);
}

LOLUNIT_TEST(StringConcat)
lolunit_declare_test(StringConcat)
{
String s1("ab"), s2("cd");

String s3 = s1 + s2;
LOLUNIT_ASSERT_EQUAL(s3[0], 'a');
LOLUNIT_ASSERT_EQUAL(s3[1], 'b');
LOLUNIT_ASSERT_EQUAL(s3[2], 'c');
LOLUNIT_ASSERT_EQUAL(s3[3], 'd');
LOLUNIT_ASSERT_EQUAL(s3[4], '\0');
lolunit_assert_equal(s3[0], 'a');
lolunit_assert_equal(s3[1], 'b');
lolunit_assert_equal(s3[2], 'c');
lolunit_assert_equal(s3[3], 'd');
lolunit_assert_equal(s3[4], '\0');
}

LOLUNIT_TEST(StringAppendString)
lolunit_declare_test(StringAppendString)
{
String s1("ab"), s2("cd");

s1 += s2;
LOLUNIT_ASSERT_EQUAL(s1.Count(), 4);
LOLUNIT_ASSERT_EQUAL(s1[0], 'a');
LOLUNIT_ASSERT_EQUAL(s1[1], 'b');
LOLUNIT_ASSERT_EQUAL(s1[2], 'c');
LOLUNIT_ASSERT_EQUAL(s1[3], 'd');
LOLUNIT_ASSERT_EQUAL(s1[4], '\0');
lolunit_assert_equal(s1.Count(), 4);
lolunit_assert_equal(s1[0], 'a');
lolunit_assert_equal(s1[1], 'b');
lolunit_assert_equal(s1[2], 'c');
lolunit_assert_equal(s1[3], 'd');
lolunit_assert_equal(s1[4], '\0');

s2 += s2;
LOLUNIT_ASSERT_EQUAL(s2.Count(), 4);
LOLUNIT_ASSERT_EQUAL(s2[0], 'c');
LOLUNIT_ASSERT_EQUAL(s2[1], 'd');
LOLUNIT_ASSERT_EQUAL(s2[2], 'c');
LOLUNIT_ASSERT_EQUAL(s2[3], 'd');
LOLUNIT_ASSERT_EQUAL(s2[4], '\0');
lolunit_assert_equal(s2.Count(), 4);
lolunit_assert_equal(s2[0], 'c');
lolunit_assert_equal(s2[1], 'd');
lolunit_assert_equal(s2[2], 'c');
lolunit_assert_equal(s2[3], 'd');
lolunit_assert_equal(s2[4], '\0');
}

LOLUNIT_TEST(StringEqual)
lolunit_declare_test(StringEqual)
{
String s1("abc");
String s2("abc");
String s3("ab");

LOLUNIT_ASSERT(s1 == s2);
LOLUNIT_ASSERT(!(s1 == s3));
lolunit_assert(s1 == s2);
lolunit_assert(!(s1 == s3));
}

LOLUNIT_TEST(StringDifferent)
lolunit_declare_test(StringDifferent)
{
String s1("abc");
String s2("ab");
String s3("abc");

LOLUNIT_ASSERT(s1 != s2);
LOLUNIT_ASSERT(!(s1 != s3));
lolunit_assert(s1 != s2);
lolunit_assert(!(s1 != s3));
}

LOLUNIT_TEST(StringCharsEqual)
lolunit_declare_test(StringCharsEqual)
{
char const* sz = "abc";
String s1("abc");
String s2("ab");

LOLUNIT_ASSERT(s1 == sz);
LOLUNIT_ASSERT(sz == s1);
LOLUNIT_ASSERT(!(s2 == sz));
LOLUNIT_ASSERT(!(sz == s2));
lolunit_assert(s1 == sz);
lolunit_assert(sz == s1);
lolunit_assert(!(s2 == sz));
lolunit_assert(!(sz == s2));
}

LOLUNIT_TEST(StringCharsDifferent)
lolunit_declare_test(StringCharsDifferent)
{
char const* sz = "abc";
String s1("ab");
String s2("abc");

LOLUNIT_ASSERT(s1 != sz);
LOLUNIT_ASSERT(sz != s1);
LOLUNIT_ASSERT(!(s2 != sz));
LOLUNIT_ASSERT(!(sz != s2));
lolunit_assert(s1 != sz);
lolunit_assert(sz != s1);
lolunit_assert(!(s2 != sz));
lolunit_assert(!(sz != s2));
}


LOLUNIT_TEST(StringPrintf)
lolunit_declare_test(StringPrintf)
{
String s1 = "3a";
String s2 = String::Printf("%d%x", 3, 10);

LOLUNIT_ASSERT(s1 == s2);
lolunit_assert(s1 == s2);

String s3 = "abc 3";
String s4 = String::Printf("abc %d", 3);

LOLUNIT_ASSERT(s3 == s4);
lolunit_assert(s3 == s4);
}

LOLUNIT_TEST(SubString)
lolunit_declare_test(SubString)
{
String s1 = "Hello World";

String s2 = s1.Sub(0, 5);
String s3 = "Hello";
LOLUNIT_ASSERT(s2 == s3);
lolunit_assert(s2 == s3);

String s4 = s1.Sub(6, 5);
String s5 = "World";
LOLUNIT_ASSERT(s4 == s5);
lolunit_assert(s4 == s5);
}

LOLUNIT_TEST(IndexOf)
lolunit_declare_test(IndexOf)
{
String s1 = "Hello World";
ptrdiff_t i1 = s1.IndexOf('H');
@@ -186,17 +186,17 @@ LOLUNIT_FIXTURE(StringTest)
ptrdiff_t i7 = s1.IndexOf("Hello World");
ptrdiff_t i8 = s1.IndexOf("Sup' dude");

LOLUNIT_ASSERT(i1 == 0);
LOLUNIT_ASSERT(i2 == 6);
LOLUNIT_ASSERT(i3 == 10);
LOLUNIT_ASSERT(i4 == i1);
LOLUNIT_ASSERT(i5 == i2);
LOLUNIT_ASSERT(i6 == 3);
LOLUNIT_ASSERT(i7 == 0);
LOLUNIT_ASSERT(i8 == -1);
lolunit_assert(i1 == 0);
lolunit_assert(i2 == 6);
lolunit_assert(i3 == 10);
lolunit_assert(i4 == i1);
lolunit_assert(i5 == i2);
lolunit_assert(i6 == 3);
lolunit_assert(i7 == 0);
lolunit_assert(i8 == -1);
}

LOLUNIT_TEST(LastIndexOf)
lolunit_declare_test(LastIndexOf)
{
String s1 = "Hello World";
ptrdiff_t i1 = s1.LastIndexOf('H');
@@ -209,26 +209,26 @@ LOLUNIT_FIXTURE(StringTest)
ptrdiff_t i8 = s1.LastIndexOf("Sup' dude");
ptrdiff_t i9 = s1.LastIndexOf('l');

LOLUNIT_ASSERT(i1 == 0);
LOLUNIT_ASSERT(i2 == 6);
LOLUNIT_ASSERT(i3 == 10);
LOLUNIT_ASSERT(i4 == i1);
LOLUNIT_ASSERT(i5 == i2);
LOLUNIT_ASSERT(i6 == 3);
LOLUNIT_ASSERT(i7 == 0);
LOLUNIT_ASSERT(i8 == -1);
LOLUNIT_ASSERT(i9 == 9);
lolunit_assert(i1 == 0);
lolunit_assert(i2 == 6);
lolunit_assert(i3 == 10);
lolunit_assert(i4 == i1);
lolunit_assert(i5 == i2);
lolunit_assert(i6 == 3);
lolunit_assert(i7 == 0);
lolunit_assert(i8 == -1);
lolunit_assert(i9 == 9);
}

LOLUNIT_TEST(StartsEndsWith)
lolunit_declare_test(StartsEndsWith)
{
String s = "lolilol";
LOLUNIT_ASSERT(s.StartsWith("loli"));
LOLUNIT_ASSERT(!s.StartsWith("lolo"));
LOLUNIT_ASSERT(!s.StartsWith("lolilolilol"));
LOLUNIT_ASSERT(s.EndsWith("ilol"));
LOLUNIT_ASSERT(!s.EndsWith("olol"));
LOLUNIT_ASSERT(!s.EndsWith("lolilolilol"));
lolunit_assert(s.StartsWith("loli"));
lolunit_assert(!s.StartsWith("lolo"));
lolunit_assert(!s.StartsWith("lolilolilol"));
lolunit_assert(s.EndsWith("ilol"));
lolunit_assert(!s.EndsWith("olol"));
lolunit_assert(!s.EndsWith("lolilolilol"));
}
};



+ 55
- 55
src/t/base/types.cpp View File

@@ -18,91 +18,91 @@
namespace lol
{

LOLUNIT_FIXTURE(BuildTest)
lolunit_declare_fixture(BuildTest)
{
LOLUNIT_TEST(TypeSizeHalf)
lolunit_declare_test(TypeSizeHalf)
{
LOLUNIT_ASSERT_EQUAL(sizeof(half), 2);
lolunit_assert_equal(sizeof(half), 2);

#if LOL_FEATURE_CXX11_UNRESTRICTED_UNIONS
LOLUNIT_ASSERT_EQUAL(sizeof(f16vec2), 4);
LOLUNIT_ASSERT_EQUAL(sizeof(f16vec3), 6);
LOLUNIT_ASSERT_EQUAL(sizeof(f16vec4), 8);
lolunit_assert_equal(sizeof(f16vec2), 4);
lolunit_assert_equal(sizeof(f16vec3), 6);
lolunit_assert_equal(sizeof(f16vec4), 8);

LOLUNIT_ASSERT_EQUAL(sizeof(f16mat2), 8);
LOLUNIT_ASSERT_EQUAL(sizeof(f16mat3), 18);
LOLUNIT_ASSERT_EQUAL(sizeof(f16mat4), 32);
lolunit_assert_equal(sizeof(f16mat2), 8);
lolunit_assert_equal(sizeof(f16mat3), 18);
lolunit_assert_equal(sizeof(f16mat4), 32);
#endif
}

LOLUNIT_TEST(TypeSizeFloat)
lolunit_declare_test(TypeSizeFloat)
{
LOLUNIT_ASSERT_EQUAL(sizeof(float), 4);
lolunit_assert_equal(sizeof(float), 4);

LOLUNIT_ASSERT_EQUAL(sizeof(vec2), 8);
LOLUNIT_ASSERT_EQUAL(sizeof(vec3), 12);
LOLUNIT_ASSERT_EQUAL(sizeof(vec4), 16);
lolunit_assert_equal(sizeof(vec2), 8);
lolunit_assert_equal(sizeof(vec3), 12);
lolunit_assert_equal(sizeof(vec4), 16);

LOLUNIT_ASSERT_EQUAL(sizeof(mat2), 16);
LOLUNIT_ASSERT_EQUAL(sizeof(mat3), 36);
LOLUNIT_ASSERT_EQUAL(sizeof(mat4), 64);
lolunit_assert_equal(sizeof(mat2), 16);
lolunit_assert_equal(sizeof(mat3), 36);
lolunit_assert_equal(sizeof(mat4), 64);
}

LOLUNIT_TEST(TypeSizeDouble)
lolunit_declare_test(TypeSizeDouble)
{
LOLUNIT_ASSERT_EQUAL(sizeof(double), 8);
lolunit_assert_equal(sizeof(double), 8);

LOLUNIT_ASSERT_EQUAL(sizeof(dvec2), 16);
LOLUNIT_ASSERT_EQUAL(sizeof(dvec3), 24);
LOLUNIT_ASSERT_EQUAL(sizeof(dvec4), 32);
lolunit_assert_equal(sizeof(dvec2), 16);
lolunit_assert_equal(sizeof(dvec3), 24);
lolunit_assert_equal(sizeof(dvec4), 32);

LOLUNIT_ASSERT_EQUAL(sizeof(dmat2), 32);
LOLUNIT_ASSERT_EQUAL(sizeof(dmat3), 72);
LOLUNIT_ASSERT_EQUAL(sizeof(dmat4), 128);
lolunit_assert_equal(sizeof(dmat2), 32);
lolunit_assert_equal(sizeof(dmat3), 72);
lolunit_assert_equal(sizeof(dmat4), 128);
}

LOLUNIT_TEST(TypeSizeInt8)
lolunit_declare_test(TypeSizeInt8)
{
LOLUNIT_ASSERT_EQUAL(sizeof(i8vec2), 2);
LOLUNIT_ASSERT_EQUAL(sizeof(u8vec2), 2);
LOLUNIT_ASSERT_EQUAL(sizeof(i8vec3), 3);
LOLUNIT_ASSERT_EQUAL(sizeof(u8vec3), 3);
LOLUNIT_ASSERT_EQUAL(sizeof(i8vec4), 4);
LOLUNIT_ASSERT_EQUAL(sizeof(u8vec4), 4);
lolunit_assert_equal(sizeof(i8vec2), 2);
lolunit_assert_equal(sizeof(u8vec2), 2);
lolunit_assert_equal(sizeof(i8vec3), 3);
lolunit_assert_equal(sizeof(u8vec3), 3);
lolunit_assert_equal(sizeof(i8vec4), 4);
lolunit_assert_equal(sizeof(u8vec4), 4);
}

LOLUNIT_TEST(TypeSizeInt16)
lolunit_declare_test(TypeSizeInt16)
{
LOLUNIT_ASSERT_EQUAL(sizeof(i16vec2), 4);
LOLUNIT_ASSERT_EQUAL(sizeof(u16vec2), 4);
LOLUNIT_ASSERT_EQUAL(sizeof(i16vec3), 6);
LOLUNIT_ASSERT_EQUAL(sizeof(u16vec3), 6);
LOLUNIT_ASSERT_EQUAL(sizeof(i16vec4), 8);
LOLUNIT_ASSERT_EQUAL(sizeof(u16vec4), 8);
lolunit_assert_equal(sizeof(i16vec2), 4);
lolunit_assert_equal(sizeof(u16vec2), 4);
lolunit_assert_equal(sizeof(i16vec3), 6);
lolunit_assert_equal(sizeof(u16vec3), 6);
lolunit_assert_equal(sizeof(i16vec4), 8);
lolunit_assert_equal(sizeof(u16vec4), 8);
}

LOLUNIT_TEST(TypeSizeInt32)
lolunit_declare_test(TypeSizeInt32)
{
LOLUNIT_ASSERT_EQUAL(sizeof(ivec2), 8);
LOLUNIT_ASSERT_EQUAL(sizeof(uvec2), 8);
LOLUNIT_ASSERT_EQUAL(sizeof(ivec3), 12);
LOLUNIT_ASSERT_EQUAL(sizeof(uvec3), 12);
LOLUNIT_ASSERT_EQUAL(sizeof(ivec4), 16);
LOLUNIT_ASSERT_EQUAL(sizeof(uvec4), 16);
lolunit_assert_equal(sizeof(ivec2), 8);
lolunit_assert_equal(sizeof(uvec2), 8);
lolunit_assert_equal(sizeof(ivec3), 12);
lolunit_assert_equal(sizeof(uvec3), 12);
lolunit_assert_equal(sizeof(ivec4), 16);
lolunit_assert_equal(sizeof(uvec4), 16);
}

LOLUNIT_TEST(TypeSizeInt64)
lolunit_declare_test(TypeSizeInt64)
{
LOLUNIT_ASSERT_EQUAL(sizeof(i64vec2), 16);
LOLUNIT_ASSERT_EQUAL(sizeof(u64vec2), 16);
LOLUNIT_ASSERT_EQUAL(sizeof(i64vec3), 24);
LOLUNIT_ASSERT_EQUAL(sizeof(u64vec3), 24);
LOLUNIT_ASSERT_EQUAL(sizeof(i64vec4), 32);
LOLUNIT_ASSERT_EQUAL(sizeof(u64vec4), 32);
lolunit_assert_equal(sizeof(i64vec2), 16);
lolunit_assert_equal(sizeof(u64vec2), 16);
lolunit_assert_equal(sizeof(i64vec3), 24);
lolunit_assert_equal(sizeof(u64vec3), 24);
lolunit_assert_equal(sizeof(i64vec4), 32);
lolunit_assert_equal(sizeof(u64vec4), 32);
}

#if !defined LOL_BUILD_DEBUG
LOLUNIT_TEST(FastMath)
lolunit_declare_test(FastMath)
{
double x, y;

@@ -111,7 +111,7 @@ LOLUNIT_FIXTURE(BuildTest)
/* The compiler should optimise this away */
y -= 4503599627370496.0;

LOLUNIT_ASSERT_EQUAL(x, y);
lolunit_assert_equal(x, y);
}
#endif
};


+ 70
- 70
src/t/entity/camera.cpp View File

@@ -19,7 +19,7 @@
namespace lol
{

LOLUNIT_FIXTURE(CameraTest)
lolunit_declare_fixture(CameraTest)
{
Camera tc;
vec3 eye;
@@ -54,11 +54,11 @@ LOLUNIT_FIXTURE(CameraTest)
void TearDown() {}

#define TEST_VECTOR(v0, v1) \
LOLUNIT_ASSERT_DOUBLES_EQUAL(v0.x, v1.x, 1.e-5f); \
LOLUNIT_ASSERT_DOUBLES_EQUAL(v0.y, v1.y, 1.e-5f); \
LOLUNIT_ASSERT_DOUBLES_EQUAL(v0.z, v1.z, 1.e-5f);
lolunit_assert_doubles_equal(v0.x, v1.x, 1.e-5f); \
lolunit_assert_doubles_equal(v0.y, v1.y, 1.e-5f); \
lolunit_assert_doubles_equal(v0.z, v1.z, 1.e-5f);

LOLUNIT_TEST(SetViewTest)
lolunit_declare_test(SetViewTest)
{
tc.SetView(eye, target, up);
TEST_VECTOR(eye, tc.GetPosition());
@@ -85,108 +85,108 @@ LOLUNIT_FIXTURE(CameraTest)
}

#define TEST_MATRIX(m0, m1) \
LOLUNIT_ASSERT_DOUBLES_EQUAL(m0[0][0], m1[0][0], 1.e-5f); \
LOLUNIT_ASSERT_DOUBLES_EQUAL(m0[1][0], m1[1][0], 1.e-5f); \
LOLUNIT_ASSERT_DOUBLES_EQUAL(m0[2][0], m1[2][0], 1.e-5f); \
LOLUNIT_ASSERT_DOUBLES_EQUAL(m0[3][0], m1[3][0], 1.e-5f); \
lolunit_assert_doubles_equal(m0[0][0], m1[0][0], 1.e-5f); \
lolunit_assert_doubles_equal(m0[1][0], m1[1][0], 1.e-5f); \
lolunit_assert_doubles_equal(m0[2][0], m1[2][0], 1.e-5f); \
lolunit_assert_doubles_equal(m0[3][0], m1[3][0], 1.e-5f); \
\
LOLUNIT_ASSERT_DOUBLES_EQUAL(m0[0][1], m1[0][1], 1.e-5f); \
LOLUNIT_ASSERT_DOUBLES_EQUAL(m0[1][1], m1[1][1], 1.e-5f); \
LOLUNIT_ASSERT_DOUBLES_EQUAL(m0[2][1], m1[2][1], 1.e-5f); \
LOLUNIT_ASSERT_DOUBLES_EQUAL(m0[3][1], m1[3][1], 1.e-5f); \
lolunit_assert_doubles_equal(m0[0][1], m1[0][1], 1.e-5f); \
lolunit_assert_doubles_equal(m0[1][1], m1[1][1], 1.e-5f); \
lolunit_assert_doubles_equal(m0[2][1], m1[2][1], 1.e-5f); \
lolunit_assert_doubles_equal(m0[3][1], m1[3][1], 1.e-5f); \
\
LOLUNIT_ASSERT_DOUBLES_EQUAL(m0[0][2], m1[0][2], 1.e-5f); \
LOLUNIT_ASSERT_DOUBLES_EQUAL(m0[1][2], m1[1][2], 1.e-5f); \
LOLUNIT_ASSERT_DOUBLES_EQUAL(m0[2][2], m1[2][2], 1.e-5f); \
LOLUNIT_ASSERT_DOUBLES_EQUAL(m0[3][2], m1[3][2], 1.e-5f); \
lolunit_assert_doubles_equal(m0[0][2], m1[0][2], 1.e-5f); \
lolunit_assert_doubles_equal(m0[1][2], m1[1][2], 1.e-5f); \
lolunit_assert_doubles_equal(m0[2][2], m1[2][2], 1.e-5f); \
lolunit_assert_doubles_equal(m0[3][2], m1[3][2], 1.e-5f); \
\
LOLUNIT_ASSERT_DOUBLES_EQUAL(m0[0][3], m1[0][3], 1.e-5f); \
LOLUNIT_ASSERT_DOUBLES_EQUAL(m0[1][3], m1[1][3], 1.e-5f); \
LOLUNIT_ASSERT_DOUBLES_EQUAL(m0[2][3], m1[2][3], 1.e-5f); \
LOLUNIT_ASSERT_DOUBLES_EQUAL(m0[3][3], m1[3][3], 1.e-5f);
lolunit_assert_doubles_equal(m0[0][3], m1[0][3], 1.e-5f); \
lolunit_assert_doubles_equal(m0[1][3], m1[1][3], 1.e-5f); \
lolunit_assert_doubles_equal(m0[2][3], m1[2][3], 1.e-5f); \
lolunit_assert_doubles_equal(m0[3][3], m1[3][3], 1.e-5f);


LOLUNIT_TEST(SetProjectionTest)
lolunit_declare_test(SetProjectionTest)
{
mat4 refmx = mat4::perspective(fov, screen_size, screen_size * screen_ratio, near, far);

tc.SetProjection(fov, near, far, screen_size, screen_ratio);
TEST_MATRIX(refmx, tc.GetProjection());
LOLUNIT_ASSERT_DOUBLES_EQUAL(fov, tc.GetFov(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(screen_size, tc.GetScreenSize(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(screen_ratio, tc.GetScreenRatio(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(near, tc.GetNear(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(far, tc.GetFar(), 1.e-5f);
LOLUNIT_ASSERT(is_shifted == tc.IsShifted());
lolunit_assert_doubles_equal(fov, tc.GetFov(), 1.e-5f);
lolunit_assert_doubles_equal(screen_size, tc.GetScreenSize(), 1.e-5f);
lolunit_assert_doubles_equal(screen_ratio, tc.GetScreenRatio(), 1.e-5f);
lolunit_assert_doubles_equal(near, tc.GetNear(), 1.e-5f);
lolunit_assert_doubles_equal(far, tc.GetFar(), 1.e-5f);
lolunit_assert(is_shifted == tc.IsShifted());

tc.SetProjection(fov, near, far);
TEST_MATRIX(refmx, tc.GetProjection());
LOLUNIT_ASSERT_DOUBLES_EQUAL(fov, tc.GetFov(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(screen_size, tc.GetScreenSize(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(screen_ratio, tc.GetScreenRatio(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(near, tc.GetNear(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(far, tc.GetFar(), 1.e-5f);
LOLUNIT_ASSERT(is_shifted == tc.IsShifted());
lolunit_assert_doubles_equal(fov, tc.GetFov(), 1.e-5f);
lolunit_assert_doubles_equal(screen_size, tc.GetScreenSize(), 1.e-5f);
lolunit_assert_doubles_equal(screen_ratio, tc.GetScreenRatio(), 1.e-5f);
lolunit_assert_doubles_equal(near, tc.GetNear(), 1.e-5f);
lolunit_assert_doubles_equal(far, tc.GetFar(), 1.e-5f);
lolunit_assert(is_shifted == tc.IsShifted());

tc.SetProjection(refmx);
TEST_MATRIX(refmx, tc.GetProjection());

tc.SetFov(fov);
TEST_MATRIX(refmx, tc.GetProjection());
LOLUNIT_ASSERT_DOUBLES_EQUAL(fov, tc.GetFov(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(screen_size, tc.GetScreenSize(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(screen_ratio, tc.GetScreenRatio(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(near, tc.GetNear(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(far, tc.GetFar(), 1.e-5f);
LOLUNIT_ASSERT(is_shifted == tc.IsShifted());
lolunit_assert_doubles_equal(fov, tc.GetFov(), 1.e-5f);
lolunit_assert_doubles_equal(screen_size, tc.GetScreenSize(), 1.e-5f);
lolunit_assert_doubles_equal(screen_ratio, tc.GetScreenRatio(), 1.e-5f);
lolunit_assert_doubles_equal(near, tc.GetNear(), 1.e-5f);
lolunit_assert_doubles_equal(far, tc.GetFar(), 1.e-5f);
lolunit_assert(is_shifted == tc.IsShifted());

tc.SetScreenInfos(screen_size);
TEST_MATRIX(refmx, tc.GetProjection());
LOLUNIT_ASSERT_DOUBLES_EQUAL(fov, tc.GetFov(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(screen_size, tc.GetScreenSize(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(screen_ratio, tc.GetScreenRatio(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(near, tc.GetNear(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(far, tc.GetFar(), 1.e-5f);
LOLUNIT_ASSERT(is_shifted == tc.IsShifted());
lolunit_assert_doubles_equal(fov, tc.GetFov(), 1.e-5f);
lolunit_assert_doubles_equal(screen_size, tc.GetScreenSize(), 1.e-5f);
lolunit_assert_doubles_equal(screen_ratio, tc.GetScreenRatio(), 1.e-5f);
lolunit_assert_doubles_equal(near, tc.GetNear(), 1.e-5f);
lolunit_assert_doubles_equal(far, tc.GetFar(), 1.e-5f);
lolunit_assert(is_shifted == tc.IsShifted());

tc.SetScreenInfos(screen_size, screen_ratio);
TEST_MATRIX(refmx, tc.GetProjection());
LOLUNIT_ASSERT_DOUBLES_EQUAL(fov, tc.GetFov(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(screen_size, tc.GetScreenSize(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(screen_ratio, tc.GetScreenRatio(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(near, tc.GetNear(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(far, tc.GetFar(), 1.e-5f);
LOLUNIT_ASSERT(is_shifted == tc.IsShifted());
lolunit_assert_doubles_equal(fov, tc.GetFov(), 1.e-5f);
lolunit_assert_doubles_equal(screen_size, tc.GetScreenSize(), 1.e-5f);
lolunit_assert_doubles_equal(screen_ratio, tc.GetScreenRatio(), 1.e-5f);
lolunit_assert_doubles_equal(near, tc.GetNear(), 1.e-5f);
lolunit_assert_doubles_equal(far, tc.GetFar(), 1.e-5f);
lolunit_assert(is_shifted == tc.IsShifted());

tc.SetDrawInfos(far);
TEST_MATRIX(refmx, tc.GetProjection());
LOLUNIT_ASSERT_DOUBLES_EQUAL(fov, tc.GetFov(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(screen_size, tc.GetScreenSize(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(screen_ratio, tc.GetScreenRatio(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(near, tc.GetNear(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(far, tc.GetFar(), 1.e-5f);
LOLUNIT_ASSERT(is_shifted == tc.IsShifted());
lolunit_assert_doubles_equal(fov, tc.GetFov(), 1.e-5f);
lolunit_assert_doubles_equal(screen_size, tc.GetScreenSize(), 1.e-5f);
lolunit_assert_doubles_equal(screen_ratio, tc.GetScreenRatio(), 1.e-5f);
lolunit_assert_doubles_equal(near, tc.GetNear(), 1.e-5f);
lolunit_assert_doubles_equal(far, tc.GetFar(), 1.e-5f);
lolunit_assert(is_shifted == tc.IsShifted());

tc.SetDrawInfos(near, far);
TEST_MATRIX(refmx, tc.GetProjection());
LOLUNIT_ASSERT_DOUBLES_EQUAL(fov, tc.GetFov(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(screen_size, tc.GetScreenSize(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(screen_ratio, tc.GetScreenRatio(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(near, tc.GetNear(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(far, tc.GetFar(), 1.e-5f);
LOLUNIT_ASSERT(is_shifted == tc.IsShifted());
lolunit_assert_doubles_equal(fov, tc.GetFov(), 1.e-5f);
lolunit_assert_doubles_equal(screen_size, tc.GetScreenSize(), 1.e-5f);
lolunit_assert_doubles_equal(screen_ratio, tc.GetScreenRatio(), 1.e-5f);
lolunit_assert_doubles_equal(near, tc.GetNear(), 1.e-5f);
lolunit_assert_doubles_equal(far, tc.GetFar(), 1.e-5f);
lolunit_assert(is_shifted == tc.IsShifted());

is_shifted = true;
refmx = mat4::shifted_perspective(fov, screen_size, screen_ratio, near, far);

tc.UseShift(is_shifted);
TEST_MATRIX(refmx, tc.GetProjection());
LOLUNIT_ASSERT_DOUBLES_EQUAL(fov, tc.GetFov(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(screen_size, tc.GetScreenSize(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(screen_ratio, tc.GetScreenRatio(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(near, tc.GetNear(), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(far, tc.GetFar(), 1.e-5f);
LOLUNIT_ASSERT(is_shifted == tc.IsShifted());
lolunit_assert_doubles_equal(fov, tc.GetFov(), 1.e-5f);
lolunit_assert_doubles_equal(screen_size, tc.GetScreenSize(), 1.e-5f);
lolunit_assert_doubles_equal(screen_ratio, tc.GetScreenRatio(), 1.e-5f);
lolunit_assert_doubles_equal(near, tc.GetNear(), 1.e-5f);
lolunit_assert_doubles_equal(far, tc.GetFar(), 1.e-5f);
lolunit_assert(is_shifted == tc.IsShifted());
}
};



+ 18
- 18
src/t/image/color.cpp View File

@@ -60,13 +60,13 @@ static float const ciede2k[] =
2.0776f, 0.0795f, -1.1350f, 0.9033f, -0.0636f, -0.5514f, 0.9082f,
};

LOLUNIT_FIXTURE(ColorTest)
lolunit_declare_fixture(ColorTest)
{
void SetUp() {}

void TearDown() {}

LOLUNIT_TEST(CIEDE2000)
lolunit_declare_test(CIEDE2000)
{
size_t count = sizeof(ciede2k) / sizeof(*ciede2k);

@@ -81,14 +81,14 @@ LOLUNIT_FIXTURE(ColorTest)

/* Check that our function works, and check that
* it is symmetrical. */
LOLUNIT_SET_CONTEXT(n / 7);
LOLUNIT_ASSERT_DOUBLES_EQUAL(d1, d2, 0.0001);
LOLUNIT_ASSERT_DOUBLES_EQUAL(d2, d3, 0.0001);
LOLUNIT_UNSET_CONTEXT(n / 7);
lolunit_set_context(n / 7);
lolunit_assert_doubles_equal(d1, d2, 0.0001);
lolunit_assert_doubles_equal(d2, d3, 0.0001);
lolunit_unset_context(n / 7);
}
}

LOLUNIT_TEST(RGBToHSV)
lolunit_declare_test(RGBToHSV)
{
for (int r = 0; r < 20; r++)
for (int g = 0; g < 20; g++)
@@ -99,18 +99,18 @@ LOLUNIT_FIXTURE(ColorTest)
vec3 v3 = Color::HSVToRGB(v2);

String rgb = String::Printf("[%f %f %f]", v1.r, v1.g, v1.b);
LOLUNIT_SET_CONTEXT(&rgb[0]);
lolunit_set_context(&rgb[0]);

if (r != g || g != b)
LOLUNIT_ASSERT_DOUBLES_EQUAL(v1.r, v3.r, 0.0001);
LOLUNIT_ASSERT_DOUBLES_EQUAL(v1.g, v3.g, 0.0001);
LOLUNIT_ASSERT_DOUBLES_EQUAL(v1.b, v3.b, 0.0001);
lolunit_assert_doubles_equal(v1.r, v3.r, 0.0001);
lolunit_assert_doubles_equal(v1.g, v3.g, 0.0001);
lolunit_assert_doubles_equal(v1.b, v3.b, 0.0001);

LOLUNIT_UNSET_CONTEXT(&rgb[0]);
lolunit_unset_context(&rgb[0]);
}
}

LOLUNIT_TEST(RGBToHSL)
lolunit_declare_test(RGBToHSL)
{
for (int r = 0; r < 20; r++)
for (int g = 0; g < 20; g++)
@@ -121,17 +121,17 @@ LOLUNIT_FIXTURE(ColorTest)
vec3 v3 = Color::HSVToHSL(Color::RGBToHSV(v1));

String rgb = String::Printf("[%f %f %f]", v1.r, v1.g, v1.b);
LOLUNIT_SET_CONTEXT(&rgb[0]);
lolunit_set_context(&rgb[0]);

/* Don’t check hue if saturation is zero. */
if (r != g || g != b)
LOLUNIT_ASSERT_DOUBLES_EQUAL(v2.x, v3.x, 0.0001);
lolunit_assert_doubles_equal(v2.x, v3.x, 0.0001);
/* Don’t check saturation if lightness is zero. */
if (r || g || b)
LOLUNIT_ASSERT_DOUBLES_EQUAL(v2.y, v3.y, 0.0001);
LOLUNIT_ASSERT_DOUBLES_EQUAL(v2.z, v3.z, 0.0001);
lolunit_assert_doubles_equal(v2.y, v3.y, 0.0001);
lolunit_assert_doubles_equal(v2.z, v3.z, 0.0001);

LOLUNIT_UNSET_CONTEXT(&rgb[0]);
lolunit_unset_context(&rgb[0]);
}
}
};


+ 11
- 11
src/t/image/image.cpp View File

@@ -20,26 +20,26 @@
namespace lol
{

LOLUNIT_FIXTURE(ImageTest)
lolunit_declare_fixture(ImageTest)
{
LOLUNIT_TEST(OpenImage)
lolunit_declare_test(OpenImage)
{
Image image("data/gradient.png");

ivec2 size = image.GetSize();
LOLUNIT_ASSERT_EQUAL(size.x, 256);
LOLUNIT_ASSERT_EQUAL(size.y, 16);
lolunit_assert_equal(size.x, 256);
lolunit_assert_equal(size.y, 16);

u8vec4 *data = image.Lock<PixelFormat::RGBA_8>();
LOLUNIT_ASSERT(data);
lolunit_assert(data);

LOLUNIT_ASSERT_EQUAL((int)data[0].r, 0x00);
LOLUNIT_ASSERT_EQUAL((int)data[0].g, 0x00);
LOLUNIT_ASSERT_EQUAL((int)data[0].b, 0x00);
lolunit_assert_equal((int)data[0].r, 0x00);
lolunit_assert_equal((int)data[0].g, 0x00);
lolunit_assert_equal((int)data[0].b, 0x00);

LOLUNIT_ASSERT_EQUAL((int)data[255].r, 0xff);
LOLUNIT_ASSERT_EQUAL((int)data[255].g, 0xff);
LOLUNIT_ASSERT_EQUAL((int)data[255].b, 0xff);
lolunit_assert_equal((int)data[255].r, 0xff);
lolunit_assert_equal((int)data[255].g, 0xff);
lolunit_assert_equal((int)data[255].b, 0xff);

image.Unlock(data);
}


+ 25
- 25
src/t/math/array2d.cpp View File

@@ -18,13 +18,13 @@
namespace lol
{

LOLUNIT_FIXTURE(Array2DTest)
lolunit_declare_fixture(Array2DTest)
{
void SetUp() {}

void TearDown() {}

LOLUNIT_TEST(Array2DCreate)
lolunit_declare_test(Array2DCreate)
{
array2d<int> a(ivec2(10, 10));

@@ -33,42 +33,42 @@ LOLUNIT_FIXTURE(Array2DTest)
a[0][9] = 6;
a[9][9] = 8;

LOLUNIT_ASSERT_EQUAL(a[0][0], 2);
LOLUNIT_ASSERT_EQUAL(a[9][0], 4);
LOLUNIT_ASSERT_EQUAL(a[0][9], 6);
LOLUNIT_ASSERT_EQUAL(a[9][9], 8);
lolunit_assert_equal(a[0][0], 2);
lolunit_assert_equal(a[9][0], 4);
lolunit_assert_equal(a[0][9], 6);
lolunit_assert_equal(a[9][9], 8);

array2d<int> const &b = a;

LOLUNIT_ASSERT_EQUAL(b[0][0], 2);
LOLUNIT_ASSERT_EQUAL(b[9][0], 4);
LOLUNIT_ASSERT_EQUAL(b[0][9], 6);
LOLUNIT_ASSERT_EQUAL(b[9][9], 8);
lolunit_assert_equal(b[0][0], 2);
lolunit_assert_equal(b[9][0], 4);
lolunit_assert_equal(b[0][9], 6);
lolunit_assert_equal(b[9][9], 8);
}

LOLUNIT_TEST(Array2DInit)
lolunit_declare_test(Array2DInit)
{
array2d<int> a = { { 1, 2, 3, 4 },
{ 5, 6, 7, 8 },
{ 9, 8, 7, 6 } };

LOLUNIT_ASSERT_EQUAL(a.GetSize().x, 4);
LOLUNIT_ASSERT_EQUAL(a.GetSize().y, 3);
lolunit_assert_equal(a.GetSize().x, 4);
lolunit_assert_equal(a.GetSize().y, 3);

LOLUNIT_ASSERT_EQUAL(a[0][0], 1);
LOLUNIT_ASSERT_EQUAL(a[1][0], 2);
LOLUNIT_ASSERT_EQUAL(a[2][0], 3);
LOLUNIT_ASSERT_EQUAL(a[3][0], 4);
lolunit_assert_equal(a[0][0], 1);
lolunit_assert_equal(a[1][0], 2);
lolunit_assert_equal(a[2][0], 3);
lolunit_assert_equal(a[3][0], 4);

LOLUNIT_ASSERT_EQUAL(a[0][1], 5);
LOLUNIT_ASSERT_EQUAL(a[1][1], 6);
LOLUNIT_ASSERT_EQUAL(a[2][1], 7);
LOLUNIT_ASSERT_EQUAL(a[3][1], 8);
lolunit_assert_equal(a[0][1], 5);
lolunit_assert_equal(a[1][1], 6);
lolunit_assert_equal(a[2][1], 7);
lolunit_assert_equal(a[3][1], 8);

LOLUNIT_ASSERT_EQUAL(a[0][2], 9);
LOLUNIT_ASSERT_EQUAL(a[1][2], 8);
LOLUNIT_ASSERT_EQUAL(a[2][2], 7);
LOLUNIT_ASSERT_EQUAL(a[3][2], 6);
lolunit_assert_equal(a[0][2], 9);
lolunit_assert_equal(a[1][2], 8);
lolunit_assert_equal(a[2][2], 7);
lolunit_assert_equal(a[3][2], 6);
}
};



+ 44
- 44
src/t/math/array3d.cpp View File

@@ -18,13 +18,13 @@
namespace lol
{

LOLUNIT_FIXTURE(Array3DTest)
lolunit_declare_fixture(Array3DTest)
{
void SetUp() {}

void TearDown() {}

LOLUNIT_TEST(Array3DCreate)
lolunit_declare_test(Array3DCreate)
{
array3d<int> a(ivec3(10, 10, 10));

@@ -33,20 +33,20 @@ LOLUNIT_FIXTURE(Array3DTest)
a[0][9][9] = 6;
a[9][9][9] = 8;

LOLUNIT_ASSERT_EQUAL(a[0][0][0], 2);
LOLUNIT_ASSERT_EQUAL(a[9][0][0], 4);
LOLUNIT_ASSERT_EQUAL(a[0][9][9], 6);
LOLUNIT_ASSERT_EQUAL(a[9][9][9], 8);
lolunit_assert_equal(a[0][0][0], 2);
lolunit_assert_equal(a[9][0][0], 4);
lolunit_assert_equal(a[0][9][9], 6);
lolunit_assert_equal(a[9][9][9], 8);

array3d<int> const &b = a;

LOLUNIT_ASSERT_EQUAL(b[0][0][0], 2);
LOLUNIT_ASSERT_EQUAL(b[9][0][0], 4);
LOLUNIT_ASSERT_EQUAL(b[0][9][9], 6);
LOLUNIT_ASSERT_EQUAL(b[9][9][9], 8);
lolunit_assert_equal(b[0][0][0], 2);
lolunit_assert_equal(b[9][0][0], 4);
lolunit_assert_equal(b[0][9][9], 6);
lolunit_assert_equal(b[9][9][9], 8);
}

LOLUNIT_TEST(Array3DInit)
lolunit_declare_test(Array3DInit)
{
array3d<int> a = { { { 1, 2, 3, 4 },
{ 5, 6, 7, 8 },
@@ -55,39 +55,39 @@ LOLUNIT_FIXTURE(Array3DTest)
{ -5, -6, -7, -8 },
{ -9, -8, -7, -6 } } };

LOLUNIT_ASSERT_EQUAL(a.GetSize().x, 4);
LOLUNIT_ASSERT_EQUAL(a.GetSize().y, 3);
LOLUNIT_ASSERT_EQUAL(a.GetSize().z, 2);
LOLUNIT_ASSERT_EQUAL(a[0][0][0], 1);
LOLUNIT_ASSERT_EQUAL(a[1][0][0], 2);
LOLUNIT_ASSERT_EQUAL(a[2][0][0], 3);
LOLUNIT_ASSERT_EQUAL(a[3][0][0], 4);
LOLUNIT_ASSERT_EQUAL(a[0][1][0], 5);
LOLUNIT_ASSERT_EQUAL(a[1][1][0], 6);
LOLUNIT_ASSERT_EQUAL(a[2][1][0], 7);
LOLUNIT_ASSERT_EQUAL(a[3][1][0], 8);
LOLUNIT_ASSERT_EQUAL(a[0][2][0], 9);
LOLUNIT_ASSERT_EQUAL(a[1][2][0], 8);
LOLUNIT_ASSERT_EQUAL(a[2][2][0], 7);
LOLUNIT_ASSERT_EQUAL(a[3][2][0], 6);
LOLUNIT_ASSERT_EQUAL(a[0][0][1], -1);
LOLUNIT_ASSERT_EQUAL(a[1][0][1], -2);
LOLUNIT_ASSERT_EQUAL(a[2][0][1], -3);
LOLUNIT_ASSERT_EQUAL(a[3][0][1], -4);
LOLUNIT_ASSERT_EQUAL(a[0][1][1], -5);
LOLUNIT_ASSERT_EQUAL(a[1][1][1], -6);
LOLUNIT_ASSERT_EQUAL(a[2][1][1], -7);
LOLUNIT_ASSERT_EQUAL(a[3][1][1], -8);
LOLUNIT_ASSERT_EQUAL(a[0][2][1], -9);
LOLUNIT_ASSERT_EQUAL(a[1][2][1], -8);
LOLUNIT_ASSERT_EQUAL(a[2][2][1], -7);
LOLUNIT_ASSERT_EQUAL(a[3][2][1], -6);
lolunit_assert_equal(a.GetSize().x, 4);
lolunit_assert_equal(a.GetSize().y, 3);
lolunit_assert_equal(a.GetSize().z, 2);
lolunit_assert_equal(a[0][0][0], 1);
lolunit_assert_equal(a[1][0][0], 2);
lolunit_assert_equal(a[2][0][0], 3);
lolunit_assert_equal(a[3][0][0], 4);
lolunit_assert_equal(a[0][1][0], 5);
lolunit_assert_equal(a[1][1][0], 6);
lolunit_assert_equal(a[2][1][0], 7);
lolunit_assert_equal(a[3][1][0], 8);
lolunit_assert_equal(a[0][2][0], 9);
lolunit_assert_equal(a[1][2][0], 8);
lolunit_assert_equal(a[2][2][0], 7);
lolunit_assert_equal(a[3][2][0], 6);
lolunit_assert_equal(a[0][0][1], -1);
lolunit_assert_equal(a[1][0][1], -2);
lolunit_assert_equal(a[2][0][1], -3);
lolunit_assert_equal(a[3][0][1], -4);
lolunit_assert_equal(a[0][1][1], -5);
lolunit_assert_equal(a[1][1][1], -6);
lolunit_assert_equal(a[2][1][1], -7);
lolunit_assert_equal(a[3][1][1], -8);
lolunit_assert_equal(a[0][2][1], -9);
lolunit_assert_equal(a[1][2][1], -8);
lolunit_assert_equal(a[2][2][1], -7);
lolunit_assert_equal(a[3][2][1], -6);
}
};



+ 49
- 49
src/t/math/arraynd.cpp View File

@@ -20,13 +20,13 @@
namespace lol
{

LOLUNIT_FIXTURE(ArrayNDTest)
lolunit_declare_fixture(ArrayNDTest)
{
void SetUp() {}

void TearDown() {}

LOLUNIT_TEST(Array2D)
lolunit_declare_test(Array2D)
{
arraynd<2, int> a;
a.SetSize(vec_t<int, 2>(2, 2));
@@ -36,20 +36,20 @@ LOLUNIT_FIXTURE(ArrayNDTest)
a[0][1] = 2;
a[1][0] = 3;
a[1][1] = 4;
LOLUNIT_ASSERT_EQUAL(a[0][0], 1);
LOLUNIT_ASSERT_EQUAL(a[0][1], 2);
LOLUNIT_ASSERT_EQUAL(a[1][0], 3);
LOLUNIT_ASSERT_EQUAL(a[1][1], 4);
lolunit_assert_equal(a[0][0], 1);
lolunit_assert_equal(a[0][1], 2);
lolunit_assert_equal(a[1][0], 3);
lolunit_assert_equal(a[1][1], 4);

/* Const accessors */
arraynd<2, int> const &b = a;
LOLUNIT_ASSERT_EQUAL(b[0][0], 1);
LOLUNIT_ASSERT_EQUAL(b[0][1], 2);
LOLUNIT_ASSERT_EQUAL(b[1][0], 3);
LOLUNIT_ASSERT_EQUAL(b[1][1], 4);
lolunit_assert_equal(b[0][0], 1);
lolunit_assert_equal(b[0][1], 2);
lolunit_assert_equal(b[1][0], 3);
lolunit_assert_equal(b[1][1], 4);
}

LOLUNIT_TEST(ArrayNDCreate)
lolunit_declare_test(ArrayNDCreate)
{
arraynd<10, int> a;
arraynd<20, float> b;
@@ -58,44 +58,44 @@ LOLUNIT_FIXTURE(ArrayNDTest)

arraynd<3, int> e = { { {1, 2}, {3, 4} }, { {5, 6}, {7, 8} } };

LOLUNIT_ASSERT_EQUAL(e.GetSize()[0], 2);
LOLUNIT_ASSERT_EQUAL(e.GetSize()[1], 2);
LOLUNIT_ASSERT_EQUAL(e.GetSize()[2], 2);
lolunit_assert_equal(e.GetSize()[0], 2);
lolunit_assert_equal(e.GetSize()[1], 2);
lolunit_assert_equal(e.GetSize()[2], 2);

LOLUNIT_ASSERT_EQUAL(e[0][0][0], 1);
LOLUNIT_ASSERT_EQUAL(e[1][0][0], 2);
LOLUNIT_ASSERT_EQUAL(e[0][1][0], 3);
LOLUNIT_ASSERT_EQUAL(e[1][1][0], 4);
LOLUNIT_ASSERT_EQUAL(e[0][0][1], 5);
LOLUNIT_ASSERT_EQUAL(e[1][0][1], 6);
LOLUNIT_ASSERT_EQUAL(e[0][1][1], 7);
LOLUNIT_ASSERT_EQUAL(e[1][1][1], 8);
lolunit_assert_equal(e[0][0][0], 1);
lolunit_assert_equal(e[1][0][0], 2);
lolunit_assert_equal(e[0][1][0], 3);
lolunit_assert_equal(e[1][1][0], 4);
lolunit_assert_equal(e[0][0][1], 5);
lolunit_assert_equal(e[1][0][1], 6);
lolunit_assert_equal(e[0][1][1], 7);
lolunit_assert_equal(e[1][1][1], 8);

arraynd<3, int> f = { { {1, 2, 3, 4}, {5, 6, 7} }, { {8, 9}, {10} } };

LOLUNIT_ASSERT_EQUAL(f.GetSize()[0], 4);
LOLUNIT_ASSERT_EQUAL(f.GetSize()[1], 2);
LOLUNIT_ASSERT_EQUAL(f.GetSize()[2], 2);
LOLUNIT_ASSERT_EQUAL(f[0][0][0], 1);
LOLUNIT_ASSERT_EQUAL(f[1][0][0], 2);
LOLUNIT_ASSERT_EQUAL(f[2][0][0], 3);
LOLUNIT_ASSERT_EQUAL(f[3][0][0], 4);
LOLUNIT_ASSERT_EQUAL(f[0][1][0], 5);
LOLUNIT_ASSERT_EQUAL(f[1][1][0], 6);
LOLUNIT_ASSERT_EQUAL(f[2][1][0], 7);
LOLUNIT_ASSERT_EQUAL(f[3][1][0], 0);
LOLUNIT_ASSERT_EQUAL(f[0][0][1], 8);
LOLUNIT_ASSERT_EQUAL(f[1][0][1], 9);
LOLUNIT_ASSERT_EQUAL(f[2][0][1], 0);
LOLUNIT_ASSERT_EQUAL(f[3][0][1], 0);
LOLUNIT_ASSERT_EQUAL(f[0][1][1], 10);
LOLUNIT_ASSERT_EQUAL(f[1][1][1], 0);
LOLUNIT_ASSERT_EQUAL(f[2][1][1], 0);
LOLUNIT_ASSERT_EQUAL(f[3][1][1], 0);
lolunit_assert_equal(f.GetSize()[0], 4);
lolunit_assert_equal(f.GetSize()[1], 2);
lolunit_assert_equal(f.GetSize()[2], 2);
lolunit_assert_equal(f[0][0][0], 1);
lolunit_assert_equal(f[1][0][0], 2);
lolunit_assert_equal(f[2][0][0], 3);
lolunit_assert_equal(f[3][0][0], 4);
lolunit_assert_equal(f[0][1][0], 5);
lolunit_assert_equal(f[1][1][0], 6);
lolunit_assert_equal(f[2][1][0], 7);
lolunit_assert_equal(f[3][1][0], 0);
lolunit_assert_equal(f[0][0][1], 8);
lolunit_assert_equal(f[1][0][1], 9);
lolunit_assert_equal(f[2][0][1], 0);
lolunit_assert_equal(f[3][0][1], 0);
lolunit_assert_equal(f[0][1][1], 10);
lolunit_assert_equal(f[1][1][1], 0);
lolunit_assert_equal(f[2][1][1], 0);
lolunit_assert_equal(f[3][1][1], 0);
}

LOLUNIT_TEST(ArrayNDInit)
lolunit_declare_test(ArrayNDInit)
{
int const NDIM = 8;
vec_t<int, NDIM> size;
@@ -104,18 +104,18 @@ LOLUNIT_FIXTURE(ArrayNDTest)

arraynd<NDIM, uint8_t> a(size);
memset(a.Data(), 0, a.Bytes());
LOLUNIT_ASSERT_EQUAL(a[2][3][2][0][1][4][0][1], 0x00);
lolunit_assert_equal(a[2][3][2][0][1][4][0][1], 0x00);

vec_t<int, NDIM> v = { 2, 3, 2, 0, 1, 4, 0, 1 };
LOLUNIT_ASSERT_EQUAL(a[v], 0x00);
lolunit_assert_equal(a[v], 0x00);

a[2][3][2][0][1][4][0][1] = 0xcd;
LOLUNIT_ASSERT_EQUAL(a[2][3][2][0][1][4][0][1], 0xcd);
LOLUNIT_ASSERT_EQUAL(a[v], 0xcd);
lolunit_assert_equal(a[2][3][2][0][1][4][0][1], 0xcd);
lolunit_assert_equal(a[v], 0xcd);

arraynd<NDIM, uint8_t> const &b = a;
LOLUNIT_ASSERT_EQUAL(b[2][3][2][0][1][4][0][1], 0xcd);
LOLUNIT_ASSERT_EQUAL(b[v], 0xcd);
lolunit_assert_equal(b[2][3][2][0][1][4][0][1], 0xcd);
lolunit_assert_equal(b[v], 0xcd);
}
};



+ 9
- 9
src/t/math/box.cpp View File

@@ -18,40 +18,40 @@
namespace lol
{

LOLUNIT_FIXTURE(BoxTest)
lolunit_declare_fixture(BoxTest)
{
void SetUp() {}

void TearDown() {}

LOLUNIT_TEST(Box2DIsect)
lolunit_declare_test(Box2DIsect)
{
box2 b1(vec2(0.f, 0.f), vec2(10.f, 10.f));
box2 b2(vec2(5.f, 8.f), vec2(8.f, 12.f));
box2 b3(vec2(5.f, 11.f), vec2(8.f, 13.f));

LOLUNIT_ASSERT_EQUAL(true, TestAABBVsAABB(b1, b2));
LOLUNIT_ASSERT_EQUAL(false, TestAABBVsAABB(b1, b3));
lolunit_assert_equal(true, TestAABBVsAABB(b1, b2));
lolunit_assert_equal(false, TestAABBVsAABB(b1, b3));

box2 b4(vec2(96.f, 33.f), vec2(144.f, 129.f));
box2 b5(vec2(264.f, 91.f), vec2(244.f, 71.f));

LOLUNIT_ASSERT_EQUAL(false, TestAABBVsAABB(b4, b5));
lolunit_assert_equal(false, TestAABBVsAABB(b4, b5));
}

LOLUNIT_TEST(Box2DMove)
lolunit_declare_test(Box2DMove)
{
box2 b1(vec2(0.f, 0.f), vec2(1.f, 1.f));
box2 b2(vec2(2.f, 2.f), vec2(3.f, 3.f));

b1 += vec2(0.6f, 0.6f);
LOLUNIT_ASSERT_EQUAL(false, TestAABBVsAABB(b1, b2));
lolunit_assert_equal(false, TestAABBVsAABB(b1, b2));

b1 += vec2(0.6f, 0.6f);
LOLUNIT_ASSERT_EQUAL(true, TestAABBVsAABB(b1, b2));
lolunit_assert_equal(true, TestAABBVsAABB(b1, b2));

b1 -= vec2(0.0f, 0.6f);
LOLUNIT_ASSERT_EQUAL(false, TestAABBVsAABB(b1, b2));
lolunit_assert_equal(false, TestAABBVsAABB(b1, b2));
}
};



+ 28
- 28
src/t/math/cmplx.cpp View File

@@ -18,91 +18,91 @@
namespace lol
{

LOLUNIT_FIXTURE(ComplexTest)
lolunit_declare_fixture(ComplexTest)
{
void SetUp() {}

void TearDown() {}

LOLUNIT_TEST(Equality)
lolunit_declare_test(Equality)
{
cmplx a2(1.0f, 2.0f);
cmplx b2(0.0f, 2.0f);
cmplx c2(1.0f, 0.0f);

LOLUNIT_ASSERT_EQUAL(a2, a2);
LOLUNIT_ASSERT_NOT_DIFFERENT(a2, a2);
lolunit_assert_equal(a2, a2);
lolunit_assert_not_different(a2, a2);

LOLUNIT_ASSERT_DIFFERENT(a2, b2);
LOLUNIT_ASSERT_NOT_EQUAL(a2, b2);
LOLUNIT_ASSERT_DIFFERENT(a2, c2);
LOLUNIT_ASSERT_NOT_EQUAL(a2, c2);
lolunit_assert_different(a2, b2);
lolunit_assert_not_equal(a2, b2);
lolunit_assert_different(a2, c2);
lolunit_assert_not_equal(a2, c2);
}

LOLUNIT_TEST(UnaryMinus)
lolunit_declare_test(UnaryMinus)
{
cmplx a(1.0f, 3.0f);
cmplx b(-1.0f, -3.0f);

LOLUNIT_ASSERT_EQUAL(a, -b);
LOLUNIT_ASSERT_EQUAL(-a, b);
lolunit_assert_equal(a, -b);
lolunit_assert_equal(-a, b);
}

LOLUNIT_TEST(Conjugate)
lolunit_declare_test(Conjugate)
{
cmplx a(1.0f, 3.0f);
cmplx b(1.0f, -3.0f);

LOLUNIT_ASSERT_EQUAL(a, ~b);
LOLUNIT_ASSERT_EQUAL(~a, b);
lolunit_assert_equal(a, ~b);
lolunit_assert_equal(~a, b);
}

LOLUNIT_TEST(Norm)
lolunit_declare_test(Norm)
{
cmplx a(3.0f, -4.0f);

LOLUNIT_ASSERT_EQUAL(norm(a), 5.0f);
lolunit_assert_equal(norm(a), 5.0f);

cmplx b = a * ~a;
cmplx c = norm(a) * norm(a);

LOLUNIT_ASSERT_EQUAL(b, c);
lolunit_assert_equal(b, c);

cmplx d(5.0f, 12.0f);

LOLUNIT_ASSERT_EQUAL(norm(d), 13.0f);
LOLUNIT_ASSERT_EQUAL(norm(a * d), norm(a) * norm(d));
lolunit_assert_equal(norm(d), 13.0f);
lolunit_assert_equal(norm(a * d), norm(a) * norm(d));
}

LOLUNIT_TEST(Base)
lolunit_declare_test(Base)
{
cmplx one(1.0f, 0.0f);
cmplx i(0.0f, 1.0f);

LOLUNIT_ASSERT_EQUAL(norm(one), 1.0f);
LOLUNIT_ASSERT_EQUAL(norm(i), 1.0f);
lolunit_assert_equal(norm(one), 1.0f);
lolunit_assert_equal(norm(i), 1.0f);

LOLUNIT_ASSERT_EQUAL(i * i, -one);
lolunit_assert_equal(i * i, -one);
}

LOLUNIT_TEST(Normalize)
lolunit_declare_test(Normalize)
{
cmplx a(3.0f, -4.0f);
cmplx b = normalize(a);

LOLUNIT_ASSERT_DOUBLES_EQUAL(norm(b), 1.0, 1e-8);
lolunit_assert_doubles_equal(norm(b), 1.0, 1e-8);
}

LOLUNIT_TEST(Reciprocal)
lolunit_declare_test(Reciprocal)
{
cmplx a(3.0f, -4.0f);
cmplx b = re(a);

LOLUNIT_ASSERT_EQUAL(a * b, b * a);
lolunit_assert_equal(a * b, b * a);

cmplx c = 1.0f;

LOLUNIT_ASSERT_EQUAL(a * b, c);
lolunit_assert_equal(a * b, c);
}
};



+ 110
- 110
src/t/math/half.cpp View File

@@ -20,140 +20,140 @@
namespace lol
{

LOLUNIT_FIXTURE(HalfTest)
lolunit_declare_fixture(HalfTest)
{
LOLUNIT_TEST(FloatToHalf)
lolunit_declare_test(FloatToHalf)
{
for (size_t i = 0; i < sizeof(pairs) / sizeof(*pairs); i++)
{
half a = (half)pairs[i].f;
uint16_t b = pairs[i].x;
LOLUNIT_SET_CONTEXT(i);
LOLUNIT_ASSERT_EQUAL(a.bits, b);
lolunit_set_context(i);
lolunit_assert_equal(a.bits, b);
}
}

LOLUNIT_TEST(FloatToHalfAccurate)
lolunit_declare_test(FloatToHalfAccurate)
{
for (size_t i = 0; i < sizeof(pairs) / sizeof(*pairs); i++)
{
half a = half::makeaccurate(pairs[i].f);
uint16_t b = pairs[i].x;
LOLUNIT_SET_CONTEXT(i);
LOLUNIT_ASSERT_EQUAL(a.bits, b);
lolunit_set_context(i);
lolunit_assert_equal(a.bits, b);
}
}

LOLUNIT_TEST(BitsToHalf)
lolunit_declare_test(BitsToHalf)
{
for (unsigned int i = 0; i < 0x10000; i++)
{
half a = half::makebits(i);
uint16_t b = i;
LOLUNIT_SET_CONTEXT(i);
LOLUNIT_ASSERT_EQUAL(a.bits, b);
lolunit_set_context(i);
lolunit_assert_equal(a.bits, b);
}
}

LOLUNIT_TEST(HalfIsNaN)
lolunit_declare_test(HalfIsNaN)
{
LOLUNIT_ASSERT(half::makebits(0x7c01).is_nan());
LOLUNIT_ASSERT(half::makebits(0xfc01).is_nan());
LOLUNIT_ASSERT(half::makebits(0x7e00).is_nan());
LOLUNIT_ASSERT(half::makebits(0xfe00).is_nan());
LOLUNIT_ASSERT(!half::makebits(0x7c00).is_nan());
LOLUNIT_ASSERT(!half::makebits(0xfc00).is_nan());
LOLUNIT_ASSERT(!half(0.0f).is_nan());
LOLUNIT_ASSERT(!half(-0.0f).is_nan());
LOLUNIT_ASSERT(!half(2.0f).is_nan());
LOLUNIT_ASSERT(!half(-2.0f).is_nan());
lolunit_assert(half::makebits(0x7c01).is_nan());
lolunit_assert(half::makebits(0xfc01).is_nan());
lolunit_assert(half::makebits(0x7e00).is_nan());
lolunit_assert(half::makebits(0xfe00).is_nan());
lolunit_assert(!half::makebits(0x7c00).is_nan());
lolunit_assert(!half::makebits(0xfc00).is_nan());
lolunit_assert(!half(0.0f).is_nan());
lolunit_assert(!half(-0.0f).is_nan());
lolunit_assert(!half(2.0f).is_nan());
lolunit_assert(!half(-2.0f).is_nan());
}

LOLUNIT_TEST(HalfIsInf)
lolunit_declare_test(HalfIsInf)
{
LOLUNIT_ASSERT(half(65536.0f).is_inf());
LOLUNIT_ASSERT(half(-65536.0f).is_inf());
lolunit_assert(half(65536.0f).is_inf());
lolunit_assert(half(-65536.0f).is_inf());

LOLUNIT_ASSERT(!half(0.0f).is_inf());
LOLUNIT_ASSERT(!half(-0.0f).is_inf());
LOLUNIT_ASSERT(!half(65535.0f).is_inf());
LOLUNIT_ASSERT(!half(-65535.0f).is_inf());
lolunit_assert(!half(0.0f).is_inf());
lolunit_assert(!half(-0.0f).is_inf());
lolunit_assert(!half(65535.0f).is_inf());
lolunit_assert(!half(-65535.0f).is_inf());

LOLUNIT_ASSERT(half::makebits(0x7c00).is_inf());
LOLUNIT_ASSERT(half::makebits(0xfc00).is_inf());
lolunit_assert(half::makebits(0x7c00).is_inf());
lolunit_assert(half::makebits(0xfc00).is_inf());

LOLUNIT_ASSERT(!half::makebits(0x7e00).is_inf());
LOLUNIT_ASSERT(!half::makebits(0xfe00).is_inf());
lolunit_assert(!half::makebits(0x7e00).is_inf());
lolunit_assert(!half::makebits(0xfe00).is_inf());
}

LOLUNIT_TEST(HalfIsFinite)
lolunit_declare_test(HalfIsFinite)
{
LOLUNIT_ASSERT(half(0.0f).is_finite());
LOLUNIT_ASSERT(half(-0.0f).is_finite());
LOLUNIT_ASSERT(half(65535.0f).is_finite());
LOLUNIT_ASSERT(half(-65535.0f).is_finite());
lolunit_assert(half(0.0f).is_finite());
lolunit_assert(half(-0.0f).is_finite());
lolunit_assert(half(65535.0f).is_finite());
lolunit_assert(half(-65535.0f).is_finite());

LOLUNIT_ASSERT(!half(65536.0f).is_finite());
LOLUNIT_ASSERT(!half(-65536.0f).is_finite());
lolunit_assert(!half(65536.0f).is_finite());
lolunit_assert(!half(-65536.0f).is_finite());

LOLUNIT_ASSERT(!half::makebits(0x7c00).is_finite());
LOLUNIT_ASSERT(!half::makebits(0xfc00).is_finite());
lolunit_assert(!half::makebits(0x7c00).is_finite());
lolunit_assert(!half::makebits(0xfc00).is_finite());

LOLUNIT_ASSERT(!half::makebits(0x7e00).is_finite());
LOLUNIT_ASSERT(!half::makebits(0xfe00).is_finite());
lolunit_assert(!half::makebits(0x7e00).is_finite());
lolunit_assert(!half::makebits(0xfe00).is_finite());
}

LOLUNIT_TEST(HalfIsNormal)
lolunit_declare_test(HalfIsNormal)
{
LOLUNIT_ASSERT(half(0.0f).is_normal());
LOLUNIT_ASSERT(half(-0.0f).is_normal());
LOLUNIT_ASSERT(half(65535.0f).is_normal());
LOLUNIT_ASSERT(half(-65535.0f).is_normal());
lolunit_assert(half(0.0f).is_normal());
lolunit_assert(half(-0.0f).is_normal());
lolunit_assert(half(65535.0f).is_normal());
lolunit_assert(half(-65535.0f).is_normal());

LOLUNIT_ASSERT(!half(65536.0f).is_normal());
LOLUNIT_ASSERT(!half(-65536.0f).is_normal());
lolunit_assert(!half(65536.0f).is_normal());
lolunit_assert(!half(-65536.0f).is_normal());

LOLUNIT_ASSERT(!half::makebits(0x7c00).is_normal());
LOLUNIT_ASSERT(!half::makebits(0xfc00).is_normal());
lolunit_assert(!half::makebits(0x7c00).is_normal());
lolunit_assert(!half::makebits(0xfc00).is_normal());

LOLUNIT_ASSERT(!half::makebits(0x7e00).is_normal());
LOLUNIT_ASSERT(!half::makebits(0xfe00).is_normal());
lolunit_assert(!half::makebits(0x7e00).is_normal());
lolunit_assert(!half::makebits(0xfe00).is_normal());
}

LOLUNIT_TEST(HalfClassify)
lolunit_declare_test(HalfClassify)
{
for (uint32_t i = 0; i < 0x10000; i++)
{
LOLUNIT_SET_CONTEXT(i);
lolunit_set_context(i);
half h = half::makebits(i);
if (h.is_nan())
{
LOLUNIT_ASSERT(!h.is_inf());
LOLUNIT_ASSERT(!h.is_normal());
LOLUNIT_ASSERT(!h.is_finite());
lolunit_assert(!h.is_inf());
lolunit_assert(!h.is_normal());
lolunit_assert(!h.is_finite());
}
else if (h.is_inf())
{
LOLUNIT_ASSERT(!h.is_normal());
LOLUNIT_ASSERT(!h.is_finite());
lolunit_assert(!h.is_normal());
lolunit_assert(!h.is_finite());
}
else
{
LOLUNIT_ASSERT(h.is_finite());
lolunit_assert(h.is_finite());
}
}
}

LOLUNIT_TEST(HalfToFloat)
lolunit_declare_test(HalfToFloat)
{
for (size_t i = 0; i < sizeof(pairs) / sizeof(*pairs); i++)
{
float a = (float)half::makebits(pairs[i].x);
float b = pairs[i].f;
LOLUNIT_SET_CONTEXT(i);
LOLUNIT_ASSERT_EQUAL(a, b);
lolunit_set_context(i);
lolunit_assert_equal(a, b);
}

for (uint32_t i = 0; i < 0x10000; i++)
@@ -164,67 +164,67 @@ LOLUNIT_FIXTURE(HalfTest)

float f = (float)h;
half g = (half)f;
LOLUNIT_SET_CONTEXT(i);
LOLUNIT_ASSERT_EQUAL(g.bits, h.bits);
lolunit_set_context(i);
lolunit_assert_equal(g.bits, h.bits);
}
}

LOLUNIT_TEST(HalfToInt)
lolunit_declare_test(HalfToInt)
{
LOLUNIT_ASSERT_EQUAL((int)(half)(0.0f), 0);
LOLUNIT_ASSERT_EQUAL((int)(half)(-0.0f), 0);
LOLUNIT_ASSERT_EQUAL((int)(half)(0.9f), 0);
LOLUNIT_ASSERT_EQUAL((int)(half)(-0.9f), 0);
LOLUNIT_ASSERT_EQUAL((int)(half)(1.0f), 1);
LOLUNIT_ASSERT_EQUAL((int)(half)(-1.0f), -1);
LOLUNIT_ASSERT_EQUAL((int)(half)(1.9f), 1);
LOLUNIT_ASSERT_EQUAL((int)(half)(-1.9f), -1);
LOLUNIT_ASSERT_EQUAL((int)(half)(65504.0f), 65504);
LOLUNIT_ASSERT_EQUAL((int)(half)(-65504.0f), -65504);
lolunit_assert_equal((int)(half)(0.0f), 0);
lolunit_assert_equal((int)(half)(-0.0f), 0);
lolunit_assert_equal((int)(half)(0.9f), 0);
lolunit_assert_equal((int)(half)(-0.9f), 0);
lolunit_assert_equal((int)(half)(1.0f), 1);
lolunit_assert_equal((int)(half)(-1.0f), -1);
lolunit_assert_equal((int)(half)(1.9f), 1);
lolunit_assert_equal((int)(half)(-1.9f), -1);
lolunit_assert_equal((int)(half)(65504.0f), 65504);
lolunit_assert_equal((int)(half)(-65504.0f), -65504);
}

LOLUNIT_TEST(FloatOpHalf)
lolunit_declare_test(FloatOpHalf)
{
half zero = 0;
half one = 1;
half two = 2;

float a = zero + one;
LOLUNIT_ASSERT_EQUAL(1.0f, a);
lolunit_assert_equal(1.0f, a);
a += zero;
LOLUNIT_ASSERT_EQUAL(1.0f, a);
lolunit_assert_equal(1.0f, a);
a -= zero;
LOLUNIT_ASSERT_EQUAL(1.0f, a);
lolunit_assert_equal(1.0f, a);
a *= one;
LOLUNIT_ASSERT_EQUAL(1.0f, a);
lolunit_assert_equal(1.0f, a);
a /= one;
LOLUNIT_ASSERT_EQUAL(1.0f, a);
lolunit_assert_equal(1.0f, a);

float b = one + zero;
LOLUNIT_ASSERT_EQUAL(1.0f, b);
lolunit_assert_equal(1.0f, b);
b += one;
LOLUNIT_ASSERT_EQUAL(2.0f, b);
lolunit_assert_equal(2.0f, b);
b *= two;
LOLUNIT_ASSERT_EQUAL(4.0f, b);
lolunit_assert_equal(4.0f, b);
b -= two;
LOLUNIT_ASSERT_EQUAL(2.0f, b);
lolunit_assert_equal(2.0f, b);
b /= two;
LOLUNIT_ASSERT_EQUAL(1.0f, b);
lolunit_assert_equal(1.0f, b);

float c = one - zero;
LOLUNIT_ASSERT_EQUAL(1.0f, c);
lolunit_assert_equal(1.0f, c);

float d = two - one;
LOLUNIT_ASSERT_EQUAL(1.0f, d);
lolunit_assert_equal(1.0f, d);

float e = two + (-one);
LOLUNIT_ASSERT_EQUAL(1.0f, e);
lolunit_assert_equal(1.0f, e);

float f = (two * two) / (one + one);
LOLUNIT_ASSERT_EQUAL(2.0f, f);
lolunit_assert_equal(2.0f, f);
}

LOLUNIT_TEST(HalfOpFloat)
lolunit_declare_test(HalfOpFloat)
{
half zero = 0;
half one = 1;
@@ -232,38 +232,38 @@ LOLUNIT_FIXTURE(HalfTest)
half four = 4;

half a = one + 0.0f;
LOLUNIT_ASSERT_EQUAL(one.bits, a.bits);
lolunit_assert_equal(one.bits, a.bits);
a += 0.0f;
LOLUNIT_ASSERT_EQUAL(one.bits, a.bits);
lolunit_assert_equal(one.bits, a.bits);
a -= 0.0f;
LOLUNIT_ASSERT_EQUAL(one.bits, a.bits);
lolunit_assert_equal(one.bits, a.bits);
a *= 1.0f;
LOLUNIT_ASSERT_EQUAL(one.bits, a.bits);
lolunit_assert_equal(one.bits, a.bits);
a /= 1.0f;
LOLUNIT_ASSERT_EQUAL(one.bits, a.bits);
lolunit_assert_equal(one.bits, a.bits);

half b = one + 0.0f;
LOLUNIT_ASSERT_EQUAL(one.bits, b.bits);
lolunit_assert_equal(one.bits, b.bits);
b += 1.0f;
LOLUNIT_ASSERT_EQUAL(two.bits, b.bits);
lolunit_assert_equal(two.bits, b.bits);
b *= 2.0f;
LOLUNIT_ASSERT_EQUAL(four.bits, b.bits);
lolunit_assert_equal(four.bits, b.bits);
b -= 2.0f;
LOLUNIT_ASSERT_EQUAL(two.bits, b.bits);
lolunit_assert_equal(two.bits, b.bits);
b /= 2.0f;
LOLUNIT_ASSERT_EQUAL(one.bits, b.bits);
lolunit_assert_equal(one.bits, b.bits);

half c = 1.0f - zero;
LOLUNIT_ASSERT_EQUAL(one.bits, c.bits);
lolunit_assert_equal(one.bits, c.bits);

half d = 2.0f - one;
LOLUNIT_ASSERT_EQUAL(one.bits, d.bits);
lolunit_assert_equal(one.bits, d.bits);

half e = 2.0f + (-one);
LOLUNIT_ASSERT_EQUAL(one.bits, e.bits);
lolunit_assert_equal(one.bits, e.bits);

half f = (2.0f * two) / (1.0f + one);
LOLUNIT_ASSERT_EQUAL(two.bits, f.bits);
lolunit_assert_equal(two.bits, f.bits);
}

struct TestPair { float f; uint16_t x; };


+ 7
- 7
src/t/math/interp.cpp View File

@@ -18,13 +18,13 @@
namespace lol
{

LOLUNIT_FIXTURE(InterpTest)
lolunit_declare_fixture(InterpTest)
{
void SetUp() {}

void TearDown() {}

LOLUNIT_TEST(TimeInterpTest)
lolunit_declare_test(TimeInterpTest)
{
TimeInterp<float> ti;

@@ -32,11 +32,11 @@ LOLUNIT_FIXTURE(InterpTest)
ti.Set(1.f, 20.f);
ti.Set(1.f, 30.f);

LOLUNIT_ASSERT_DOUBLES_EQUAL(0.f, ti.Get(-3.0f), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(10.f, ti.Get(-2.0f), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(20.f, ti.Get(-1.0f), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(30.f, ti.Get(0.0f), 1.e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(40.f, ti.Get(1.0f), 1.e-5f);
lolunit_assert_doubles_equal(0.f, ti.Get(-3.0f), 1.e-5f);
lolunit_assert_doubles_equal(10.f, ti.Get(-2.0f), 1.e-5f);
lolunit_assert_doubles_equal(20.f, ti.Get(-1.0f), 1.e-5f);
lolunit_assert_doubles_equal(30.f, ti.Get(0.0f), 1.e-5f);
lolunit_assert_doubles_equal(40.f, ti.Get(1.0f), 1.e-5f);
}
};



+ 65
- 65
src/t/math/matrix.cpp View File

@@ -18,7 +18,7 @@
namespace lol
{

LOLUNIT_FIXTURE(MatrixTest)
lolunit_declare_fixture(MatrixTest)
{
void SetUp()
{
@@ -49,116 +49,116 @@ LOLUNIT_FIXTURE(MatrixTest)

void TearDown() {}

LOLUNIT_TEST(Determinant)
lolunit_declare_test(Determinant)
{
float d1, d2;

d1 = determinant(tri2);
LOLUNIT_ASSERT_EQUAL(d1, 2.0f);
lolunit_assert_equal(d1, 2.0f);
d2 = determinant(inv2);
LOLUNIT_ASSERT_EQUAL(d2, -1.0f);
lolunit_assert_equal(d2, -1.0f);

d1 = determinant(tri3);
LOLUNIT_ASSERT_EQUAL(d1, 6.0f);
lolunit_assert_equal(d1, 6.0f);
d2 = determinant(inv3);
LOLUNIT_ASSERT_EQUAL(d2, 1.0f);
lolunit_assert_equal(d2, 1.0f);

d1 = determinant(tri4);
LOLUNIT_ASSERT_EQUAL(d1, 24.0f);
lolunit_assert_equal(d1, 24.0f);
d2 = determinant(inv4);
LOLUNIT_ASSERT_EQUAL(d2, -1.0f);
lolunit_assert_equal(d2, -1.0f);
}

LOLUNIT_TEST(Multiplication)
lolunit_declare_test(Multiplication)
{
mat4 m0 = id4;
mat4 m1 = id4;
mat4 m2 = m0 * m1;

LOLUNIT_ASSERT_EQUAL(m2[0][0], 1.0f);
LOLUNIT_ASSERT_EQUAL(m2[1][0], 0.0f);
LOLUNIT_ASSERT_EQUAL(m2[2][0], 0.0f);
LOLUNIT_ASSERT_EQUAL(m2[3][0], 0.0f);
LOLUNIT_ASSERT_EQUAL(m2[0][1], 0.0f);
LOLUNIT_ASSERT_EQUAL(m2[1][1], 1.0f);
LOLUNIT_ASSERT_EQUAL(m2[2][1], 0.0f);
LOLUNIT_ASSERT_EQUAL(m2[3][1], 0.0f);
LOLUNIT_ASSERT_EQUAL(m2[0][2], 0.0f);
LOLUNIT_ASSERT_EQUAL(m2[1][2], 0.0f);
LOLUNIT_ASSERT_EQUAL(m2[2][2], 1.0f);
LOLUNIT_ASSERT_EQUAL(m2[3][2], 0.0f);
LOLUNIT_ASSERT_EQUAL(m2[0][3], 0.0f);
LOLUNIT_ASSERT_EQUAL(m2[1][3], 0.0f);
LOLUNIT_ASSERT_EQUAL(m2[2][3], 0.0f);
LOLUNIT_ASSERT_EQUAL(m2[3][3], 1.0f);
lolunit_assert_equal(m2[0][0], 1.0f);
lolunit_assert_equal(m2[1][0], 0.0f);
lolunit_assert_equal(m2[2][0], 0.0f);
lolunit_assert_equal(m2[3][0], 0.0f);
lolunit_assert_equal(m2[0][1], 0.0f);
lolunit_assert_equal(m2[1][1], 1.0f);
lolunit_assert_equal(m2[2][1], 0.0f);
lolunit_assert_equal(m2[3][1], 0.0f);
lolunit_assert_equal(m2[0][2], 0.0f);
lolunit_assert_equal(m2[1][2], 0.0f);
lolunit_assert_equal(m2[2][2], 1.0f);
lolunit_assert_equal(m2[3][2], 0.0f);
lolunit_assert_equal(m2[0][3], 0.0f);
lolunit_assert_equal(m2[1][3], 0.0f);
lolunit_assert_equal(m2[2][3], 0.0f);
lolunit_assert_equal(m2[3][3], 1.0f);
}

LOLUNIT_TEST(Inverse2x2)
lolunit_declare_test(Inverse2x2)
{
mat2 m0 = inv2;
mat2 m1 = inverse(m0);

mat2 m2 = m0 * m1;

LOLUNIT_ASSERT_EQUAL(m2[0][0], 1.0f);
LOLUNIT_ASSERT_EQUAL(m2[1][0], 0.0f);
lolunit_assert_equal(m2[0][0], 1.0f);
lolunit_assert_equal(m2[1][0], 0.0f);

LOLUNIT_ASSERT_EQUAL(m2[0][1], 0.0f);
LOLUNIT_ASSERT_EQUAL(m2[1][1], 1.0f);
lolunit_assert_equal(m2[0][1], 0.0f);
lolunit_assert_equal(m2[1][1], 1.0f);
}

LOLUNIT_TEST(Inverse3x3)
lolunit_declare_test(Inverse3x3)
{
mat3 m0 = inv3;
mat3 m1 = inverse(m0);

mat3 m2 = m0 * m1;

LOLUNIT_ASSERT_EQUAL(m2[0][0], 1.0f);
LOLUNIT_ASSERT_EQUAL(m2[1][0], 0.0f);
LOLUNIT_ASSERT_EQUAL(m2[2][0], 0.0f);
lolunit_assert_equal(m2[0][0], 1.0f);
lolunit_assert_equal(m2[1][0], 0.0f);
lolunit_assert_equal(m2[2][0], 0.0f);

LOLUNIT_ASSERT_EQUAL(m2[0][1], 0.0f);
LOLUNIT_ASSERT_EQUAL(m2[1][1], 1.0f);
LOLUNIT_ASSERT_EQUAL(m2[2][1], 0.0f);
lolunit_assert_equal(m2[0][1], 0.0f);
lolunit_assert_equal(m2[1][1], 1.0f);
lolunit_assert_equal(m2[2][1], 0.0f);

LOLUNIT_ASSERT_EQUAL(m2[0][2], 0.0f);
LOLUNIT_ASSERT_EQUAL(m2[1][2], 0.0f);
LOLUNIT_ASSERT_EQUAL(m2[2][2], 1.0f);
lolunit_assert_equal(m2[0][2], 0.0f);
lolunit_assert_equal(m2[1][2], 0.0f);
lolunit_assert_equal(m2[2][2], 1.0f);
}

LOLUNIT_TEST(Inverse4x4)
lolunit_declare_test(Inverse4x4)
{
mat4 m0 = inv4;
mat4 m1 = inverse(m0);

mat4 m2 = m0 * m1;

LOLUNIT_ASSERT_EQUAL(m2[0][0], 1.0f);
LOLUNIT_ASSERT_EQUAL(m2[1][0], 0.0f);
LOLUNIT_ASSERT_EQUAL(m2[2][0], 0.0f);
LOLUNIT_ASSERT_EQUAL(m2[3][0], 0.0f);
LOLUNIT_ASSERT_EQUAL(m2[0][1], 0.0f);
LOLUNIT_ASSERT_EQUAL(m2[1][1], 1.0f);
LOLUNIT_ASSERT_EQUAL(m2[2][1], 0.0f);
LOLUNIT_ASSERT_EQUAL(m2[3][1], 0.0f);
LOLUNIT_ASSERT_EQUAL(m2[0][2], 0.0f);
LOLUNIT_ASSERT_EQUAL(m2[1][2], 0.0f);
LOLUNIT_ASSERT_EQUAL(m2[2][2], 1.0f);
LOLUNIT_ASSERT_EQUAL(m2[3][2], 0.0f);
LOLUNIT_ASSERT_EQUAL(m2[0][3], 0.0f);
LOLUNIT_ASSERT_EQUAL(m2[1][3], 0.0f);
LOLUNIT_ASSERT_EQUAL(m2[2][3], 0.0f);
LOLUNIT_ASSERT_EQUAL(m2[3][3], 1.0f);
lolunit_assert_equal(m2[0][0], 1.0f);
lolunit_assert_equal(m2[1][0], 0.0f);
lolunit_assert_equal(m2[2][0], 0.0f);
lolunit_assert_equal(m2[3][0], 0.0f);
lolunit_assert_equal(m2[0][1], 0.0f);
lolunit_assert_equal(m2[1][1], 1.0f);
lolunit_assert_equal(m2[2][1], 0.0f);
lolunit_assert_equal(m2[3][1], 0.0f);
lolunit_assert_equal(m2[0][2], 0.0f);
lolunit_assert_equal(m2[1][2], 0.0f);
lolunit_assert_equal(m2[2][2], 1.0f);
lolunit_assert_equal(m2[3][2], 0.0f);
lolunit_assert_equal(m2[0][3], 0.0f);
lolunit_assert_equal(m2[1][3], 0.0f);
lolunit_assert_equal(m2[2][3], 0.0f);
lolunit_assert_equal(m2[3][3], 1.0f);
}

LOLUNIT_TEST(Kronecker)
lolunit_declare_test(Kronecker)
{
int const COLS1 = 2, ROWS1 = 3;
int const COLS2 = 5, ROWS2 = 7;
@@ -184,7 +184,7 @@ LOLUNIT_FIXTURE(MatrixTest)
int expected = a[i1][j1] * b[i2][j2];
int actual = m[i1 * COLS2 + i2][j1 * ROWS2 + j2];

LOLUNIT_ASSERT_EQUAL(actual, expected);
lolunit_assert_equal(actual, expected);
}
}



+ 184
- 184
src/t/math/quat.cpp View File

@@ -18,7 +18,7 @@
namespace lol
{

LOLUNIT_FIXTURE(QuaternionTest)
lolunit_declare_fixture(QuaternionTest)
{
void SetUp()
{
@@ -47,7 +47,7 @@ LOLUNIT_FIXTURE(QuaternionTest)

void TearDown() {}

LOLUNIT_TEST(Equality)
lolunit_declare_test(Equality)
{
quat a4(1.f, 2.f, 3.f, 4.f);
quat b4(0.f, 2.f, 3.f, 4.f);
@@ -55,154 +55,154 @@ LOLUNIT_FIXTURE(QuaternionTest)
quat d4(1.f, 2.f, 0.f, 4.f);
quat e4(1.f, 2.f, 3.f, 0.f);

LOLUNIT_ASSERT_EQUAL(a4, a4);
LOLUNIT_ASSERT_NOT_DIFFERENT(a4, a4);
LOLUNIT_ASSERT_DIFFERENT(a4, b4);
LOLUNIT_ASSERT_NOT_EQUAL(a4, b4);
LOLUNIT_ASSERT_DIFFERENT(a4, c4);
LOLUNIT_ASSERT_NOT_EQUAL(a4, c4);
LOLUNIT_ASSERT_DIFFERENT(a4, d4);
LOLUNIT_ASSERT_NOT_EQUAL(a4, d4);
LOLUNIT_ASSERT_DIFFERENT(a4, e4);
LOLUNIT_ASSERT_NOT_EQUAL(a4, e4);
lolunit_assert_equal(a4, a4);
lolunit_assert_not_different(a4, a4);
lolunit_assert_different(a4, b4);
lolunit_assert_not_equal(a4, b4);
lolunit_assert_different(a4, c4);
lolunit_assert_not_equal(a4, c4);
lolunit_assert_different(a4, d4);
lolunit_assert_not_equal(a4, d4);
lolunit_assert_different(a4, e4);
lolunit_assert_not_equal(a4, e4);
}

LOLUNIT_TEST(UnaryMinus)
lolunit_declare_test(UnaryMinus)
{
quat a(1.f, 3.f, 2.f, 4.f);
quat b(-1.f, -3.f, -2.f, -4.f);

LOLUNIT_ASSERT_EQUAL(a, -b);
LOLUNIT_ASSERT_EQUAL(-a, b);
lolunit_assert_equal(a, -b);
lolunit_assert_equal(-a, b);
}

LOLUNIT_TEST(Conjugate)
lolunit_declare_test(Conjugate)
{
quat a(1.f, 3.f, 2.f, 4.f);
quat b(1.f, -3.f, -2.f, -4.f);

LOLUNIT_ASSERT_EQUAL(a, ~b);
LOLUNIT_ASSERT_EQUAL(~a, b);
lolunit_assert_equal(a, ~b);
lolunit_assert_equal(~a, b);
}

LOLUNIT_TEST(Norm)
lolunit_declare_test(Norm)
{
quat a(2.f, -2.f, -8.f, 3.f);

LOLUNIT_ASSERT_EQUAL(norm(a), 9.f);
lolunit_assert_equal(norm(a), 9.f);

quat b = a * ~a;
quat c(norm(a) * norm(a), 0.f, 0.f, 0.f);

LOLUNIT_ASSERT_EQUAL(b, c);
lolunit_assert_equal(b, c);

quat d(2.f, 5.f, -4.f, -2.f);

LOLUNIT_ASSERT_EQUAL(norm(a * d), norm(a) * norm(d));
lolunit_assert_equal(norm(a * d), norm(a) * norm(d));
}

LOLUNIT_TEST(Dot)
lolunit_declare_test(Dot)
{
quat a(-1.f, 2.f, -3.f, 4.f);
quat b(8.f, 7.f, 6.f, 5.f);

LOLUNIT_ASSERT_EQUAL(dot(a, b), 8.f);
lolunit_assert_equal(dot(a, b), 8.f);
}

LOLUNIT_TEST(Base)
lolunit_declare_test(Base)
{
quat one(1.f, 0.f, 0.f, 0.f);
quat i(0.f, 1.f, 0.f, 0.f);
quat j(0.f, 0.f, 1.f, 0.f);
quat k(0.f, 0.f, 0.f, 1.f);

LOLUNIT_ASSERT_EQUAL(norm(one), 1.f);
LOLUNIT_ASSERT_EQUAL(norm(i), 1.f);
LOLUNIT_ASSERT_EQUAL(norm(j), 1.f);
LOLUNIT_ASSERT_EQUAL(norm(k), 1.f);
LOLUNIT_ASSERT_EQUAL(i * i, -one);
LOLUNIT_ASSERT_EQUAL(j * j, -one);
LOLUNIT_ASSERT_EQUAL(k * k, -one);
LOLUNIT_ASSERT_EQUAL(i * j * k, -one);
LOLUNIT_ASSERT_EQUAL(i * j, k);
LOLUNIT_ASSERT_EQUAL(j * i, -k);
LOLUNIT_ASSERT_EQUAL(j * k, i);
LOLUNIT_ASSERT_EQUAL(k * j, -i);
LOLUNIT_ASSERT_EQUAL(k * i, j);
LOLUNIT_ASSERT_EQUAL(i * k, -j);
lolunit_assert_equal(norm(one), 1.f);
lolunit_assert_equal(norm(i), 1.f);
lolunit_assert_equal(norm(j), 1.f);
lolunit_assert_equal(norm(k), 1.f);
lolunit_assert_equal(i * i, -one);
lolunit_assert_equal(j * j, -one);
lolunit_assert_equal(k * k, -one);
lolunit_assert_equal(i * j * k, -one);
lolunit_assert_equal(i * j, k);
lolunit_assert_equal(j * i, -k);
lolunit_assert_equal(j * k, i);
lolunit_assert_equal(k * j, -i);
lolunit_assert_equal(k * i, j);
lolunit_assert_equal(i * k, -j);
}

LOLUNIT_TEST(Normalize)
lolunit_declare_test(Normalize)
{
quat a(2.f, -2.f, -8.f, 3.f);
quat b = normalize(a);

LOLUNIT_ASSERT_DOUBLES_EQUAL(norm(b), 1.0, 1e-5);
lolunit_assert_doubles_equal(norm(b), 1.0, 1e-5);
}

LOLUNIT_TEST(Reciprocal)
lolunit_declare_test(Reciprocal)
{
quat a(2.f, -2.f, -8.f, 3.f);
quat b = re(a);
quat c = 1.f / a;

LOLUNIT_ASSERT_DOUBLES_EQUAL(b.w, c.w, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(b.x, c.x, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(b.y, c.y, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(b.z, c.z, 1e-5);
lolunit_assert_doubles_equal(b.w, c.w, 1e-5);
lolunit_assert_doubles_equal(b.x, c.x, 1e-5);
lolunit_assert_doubles_equal(b.y, c.y, 1e-5);
lolunit_assert_doubles_equal(b.z, c.z, 1e-5);

quat m1 = a * b;
quat m2 = b * a;
LOLUNIT_ASSERT_DOUBLES_EQUAL(m1.w, m2.w, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(m1.x, m2.x, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(m1.y, m2.y, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(m1.z, m2.z, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(m1.w, 1.0, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(m1.x, 0.0, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(m1.y, 0.0, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(m1.z, 0.0, 1e-5);
lolunit_assert_doubles_equal(m1.w, m2.w, 1e-5);
lolunit_assert_doubles_equal(m1.x, m2.x, 1e-5);
lolunit_assert_doubles_equal(m1.y, m2.y, 1e-5);
lolunit_assert_doubles_equal(m1.z, m2.z, 1e-5);
lolunit_assert_doubles_equal(m1.w, 1.0, 1e-5);
lolunit_assert_doubles_equal(m1.x, 0.0, 1e-5);
lolunit_assert_doubles_equal(m1.y, 0.0, 1e-5);
lolunit_assert_doubles_equal(m1.z, 0.0, 1e-5);
}

LOLUNIT_TEST(Rotation)
lolunit_declare_test(Rotation)
{
/* Check that rotating 10 degrees twice means rotating 20 degrees */
quat a = quat::rotate(10.f, vec3::axis_x);
quat b = quat::rotate(20.f, vec3::axis_x);
quat c = a * a;

LOLUNIT_ASSERT_DOUBLES_EQUAL(c.w, b.w, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(c.x, b.x, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(c.y, b.y, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(c.z, b.z, 1e-5);
lolunit_assert_doubles_equal(c.w, b.w, 1e-5);
lolunit_assert_doubles_equal(c.x, b.x, 1e-5);
lolunit_assert_doubles_equal(c.y, b.y, 1e-5);
lolunit_assert_doubles_equal(c.z, b.z, 1e-5);

/* Check that rotating 10 degrees then 20 is the same as 20 then 10 */
quat d = a * b;
quat e = b * a;

LOLUNIT_ASSERT_DOUBLES_EQUAL(e.w, d.w, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(e.x, d.x, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(e.y, d.y, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(e.z, d.z, 1e-5);
lolunit_assert_doubles_equal(e.w, d.w, 1e-5);
lolunit_assert_doubles_equal(e.x, d.x, 1e-5);
lolunit_assert_doubles_equal(e.y, d.y, 1e-5);
lolunit_assert_doubles_equal(e.z, d.z, 1e-5);
}

LOLUNIT_TEST(ToAxisAngle)
lolunit_declare_test(ToAxisAngle)
{
quat q = quat::rotate(10.f, vec3::axis_x);
vec3 axis = q.axis();
float angle = q.angle();

LOLUNIT_ASSERT_DOUBLES_EQUAL(1.0, axis.x, 1e-6);
LOLUNIT_ASSERT_DOUBLES_EQUAL(0.0, axis.y, 1e-6);
LOLUNIT_ASSERT_DOUBLES_EQUAL(0.0, axis.z, 1e-6);
lolunit_assert_doubles_equal(1.0, axis.x, 1e-6);
lolunit_assert_doubles_equal(0.0, axis.y, 1e-6);
lolunit_assert_doubles_equal(0.0, axis.z, 1e-6);

LOLUNIT_ASSERT_DOUBLES_EQUAL(10.0, (double)degrees(angle), 1e-6);
lolunit_assert_doubles_equal(10.0, (double)degrees(angle), 1e-6);
}

LOLUNIT_TEST(FromTwoVectors)
lolunit_declare_test(FromTwoVectors)
{
for (auto pair : m_vectorpairs)
{
@@ -214,40 +214,40 @@ LOLUNIT_FIXTURE(QuaternionTest)
quat q = quat::rotate(a, b);

/* Check that q is a unit quaternion */
LOLUNIT_ASSERT_DOUBLES_EQUAL(1.0, (double)norm(q), 1e-5);
lolunit_assert_doubles_equal(1.0, (double)norm(q), 1e-5);

/* Check that q transforms da into db */
vec3 c = q.transform(da);

LOLUNIT_ASSERT_DOUBLES_EQUAL(c.x, db.x, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(c.y, db.y, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(c.z, db.z, 1e-5);
lolunit_assert_doubles_equal(c.x, db.x, 1e-5);
lolunit_assert_doubles_equal(c.y, db.y, 1e-5);
lolunit_assert_doubles_equal(c.z, db.z, 1e-5);

/* Check that ~q transforms db into da */
vec3 d = (~q).transform(db);

LOLUNIT_ASSERT_DOUBLES_EQUAL(d.x, da.x, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(d.y, da.y, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(d.z, da.z, 1e-5);
lolunit_assert_doubles_equal(d.x, da.x, 1e-5);
lolunit_assert_doubles_equal(d.y, da.y, 1e-5);
lolunit_assert_doubles_equal(d.z, da.z, 1e-5);

if (distance(da, db) > 1e-6f)
{
/* If da and db differ, check that the rotation axis is normal to both
* vectors, which is only true if the rotation uses the shortest path. */
vec3 axis = q.axis();
LOLUNIT_ASSERT_DOUBLES_EQUAL(0.0, (double)dot(axis, da), 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(0.0, (double)dot(axis, db), 1e-5);
lolunit_assert_doubles_equal(0.0, (double)dot(axis, da), 1e-5);
lolunit_assert_doubles_equal(0.0, (double)dot(axis, db), 1e-5);
}
else
{
/* If da and db are roughly the same, check that the rotation angle
* is zero. */
LOLUNIT_ASSERT_DOUBLES_EQUAL(0.0, (double)q.angle(), 1e-5);
lolunit_assert_doubles_equal(0.0, (double)q.angle(), 1e-5);
}
}
}

LOLUNIT_TEST(FromEulerNorm)
lolunit_declare_test(FromEulerNorm)
{
for (int i = 0; i < 100; ++i)
{
@@ -255,45 +255,45 @@ LOLUNIT_FIXTURE(QuaternionTest)

/* Tait-Bryan */
quat q1 = quat::fromeuler_xyz(angles);
LOLUNIT_ASSERT_DOUBLES_EQUAL(norm(q1), 1.f, 1e-5);
lolunit_assert_doubles_equal(norm(q1), 1.f, 1e-5);

quat q2 = quat::fromeuler_yzx(angles);
LOLUNIT_ASSERT_DOUBLES_EQUAL(norm(q2), 1.f, 1e-5);
lolunit_assert_doubles_equal(norm(q2), 1.f, 1e-5);

quat q3 = quat::fromeuler_zxy(angles);
LOLUNIT_ASSERT_DOUBLES_EQUAL(norm(q3), 1.f, 1e-5);
lolunit_assert_doubles_equal(norm(q3), 1.f, 1e-5);

quat q4 = quat::fromeuler_xzy(angles);
LOLUNIT_ASSERT_DOUBLES_EQUAL(norm(q4), 1.f, 1e-5);
lolunit_assert_doubles_equal(norm(q4), 1.f, 1e-5);

quat q5 = quat::fromeuler_zyx(angles);
LOLUNIT_ASSERT_DOUBLES_EQUAL(norm(q5), 1.f, 1e-5);
lolunit_assert_doubles_equal(norm(q5), 1.f, 1e-5);

quat q6 = quat::fromeuler_yxz(angles);
LOLUNIT_ASSERT_DOUBLES_EQUAL(norm(q6), 1.f, 1e-5);
lolunit_assert_doubles_equal(norm(q6), 1.f, 1e-5);

/* Euler */
quat q7 = quat::fromeuler_xyx(angles);
LOLUNIT_ASSERT_DOUBLES_EQUAL(norm(q7), 1.f, 1e-5);
lolunit_assert_doubles_equal(norm(q7), 1.f, 1e-5);

quat q8 = quat::fromeuler_yzy(angles);
LOLUNIT_ASSERT_DOUBLES_EQUAL(norm(q8), 1.f, 1e-5);
lolunit_assert_doubles_equal(norm(q8), 1.f, 1e-5);

quat q9 = quat::fromeuler_zxz(angles);
LOLUNIT_ASSERT_DOUBLES_EQUAL(norm(q9), 1.f, 1e-5);
lolunit_assert_doubles_equal(norm(q9), 1.f, 1e-5);

quat q10 = quat::fromeuler_xzx(angles);
LOLUNIT_ASSERT_DOUBLES_EQUAL(norm(q10), 1.f, 1e-5);
lolunit_assert_doubles_equal(norm(q10), 1.f, 1e-5);

quat q11 = quat::fromeuler_zyz(angles);
LOLUNIT_ASSERT_DOUBLES_EQUAL(norm(q11), 1.f, 1e-5);
lolunit_assert_doubles_equal(norm(q11), 1.f, 1e-5);

quat q12 = quat::fromeuler_yxy(angles);
LOLUNIT_ASSERT_DOUBLES_EQUAL(norm(q12), 1.f, 1e-5);
lolunit_assert_doubles_equal(norm(q12), 1.f, 1e-5);
}
}

LOLUNIT_TEST(FirstTwoEulerAngles)
lolunit_declare_test(FirstTwoEulerAngles)
{
for (int i = 0; i < 100; ++i)
{
@@ -305,54 +305,54 @@ LOLUNIT_FIXTURE(QuaternionTest)
q1 = quat::fromeuler_xyz(angles);
q2 = quat::fromeuler_xyx(angles);

LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.w, q2.w, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.x, q2.x, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.y, q2.y, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.z, q2.z, 1e-5);
lolunit_assert_doubles_equal(q1.w, q2.w, 1e-5);
lolunit_assert_doubles_equal(q1.x, q2.x, 1e-5);
lolunit_assert_doubles_equal(q1.y, q2.y, 1e-5);
lolunit_assert_doubles_equal(q1.z, q2.z, 1e-5);

q1 = quat::fromeuler_yzx(angles);
q2 = quat::fromeuler_yzy(angles);

LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.w, q2.w, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.x, q2.x, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.y, q2.y, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.z, q2.z, 1e-5);
lolunit_assert_doubles_equal(q1.w, q2.w, 1e-5);
lolunit_assert_doubles_equal(q1.x, q2.x, 1e-5);
lolunit_assert_doubles_equal(q1.y, q2.y, 1e-5);
lolunit_assert_doubles_equal(q1.z, q2.z, 1e-5);

q1 = quat::fromeuler_zxy(angles);
q2 = quat::fromeuler_zxz(angles);

LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.w, q2.w, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.x, q2.x, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.y, q2.y, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.z, q2.z, 1e-5);
lolunit_assert_doubles_equal(q1.w, q2.w, 1e-5);
lolunit_assert_doubles_equal(q1.x, q2.x, 1e-5);
lolunit_assert_doubles_equal(q1.y, q2.y, 1e-5);
lolunit_assert_doubles_equal(q1.z, q2.z, 1e-5);

q1 = quat::fromeuler_xzy(angles);
q2 = quat::fromeuler_xzx(angles);

LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.w, q2.w, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.x, q2.x, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.y, q2.y, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.z, q2.z, 1e-5);
lolunit_assert_doubles_equal(q1.w, q2.w, 1e-5);
lolunit_assert_doubles_equal(q1.x, q2.x, 1e-5);
lolunit_assert_doubles_equal(q1.y, q2.y, 1e-5);
lolunit_assert_doubles_equal(q1.z, q2.z, 1e-5);

q1 = quat::fromeuler_zyx(angles);
q2 = quat::fromeuler_zyz(angles);

LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.w, q2.w, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.x, q2.x, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.y, q2.y, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.z, q2.z, 1e-5);
lolunit_assert_doubles_equal(q1.w, q2.w, 1e-5);
lolunit_assert_doubles_equal(q1.x, q2.x, 1e-5);
lolunit_assert_doubles_equal(q1.y, q2.y, 1e-5);
lolunit_assert_doubles_equal(q1.z, q2.z, 1e-5);

q1 = quat::fromeuler_yxz(angles);
q2 = quat::fromeuler_yxy(angles);

LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.w, q2.w, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.x, q2.x, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.y, q2.y, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.z, q2.z, 1e-5);
lolunit_assert_doubles_equal(q1.w, q2.w, 1e-5);
lolunit_assert_doubles_equal(q1.x, q2.x, 1e-5);
lolunit_assert_doubles_equal(q1.y, q2.y, 1e-5);
lolunit_assert_doubles_equal(q1.z, q2.z, 1e-5);
}
}

LOLUNIT_TEST(LastTwoEulerAngles)
lolunit_declare_test(LastTwoEulerAngles)
{
for (int i = 0; i < 100; ++i)
{
@@ -364,54 +364,54 @@ LOLUNIT_FIXTURE(QuaternionTest)
q1 = quat::fromeuler_xyz(angles);
q2 = quat::fromeuler_zyz(angles);

LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.w, q2.w, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.x, q2.x, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.y, q2.y, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.z, q2.z, 1e-5);
lolunit_assert_doubles_equal(q1.w, q2.w, 1e-5);
lolunit_assert_doubles_equal(q1.x, q2.x, 1e-5);
lolunit_assert_doubles_equal(q1.y, q2.y, 1e-5);
lolunit_assert_doubles_equal(q1.z, q2.z, 1e-5);

q1 = quat::fromeuler_yzx(angles);
q2 = quat::fromeuler_xzx(angles);

LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.w, q2.w, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.x, q2.x, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.y, q2.y, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.z, q2.z, 1e-5);
lolunit_assert_doubles_equal(q1.w, q2.w, 1e-5);
lolunit_assert_doubles_equal(q1.x, q2.x, 1e-5);
lolunit_assert_doubles_equal(q1.y, q2.y, 1e-5);
lolunit_assert_doubles_equal(q1.z, q2.z, 1e-5);

q1 = quat::fromeuler_zxy(angles);
q2 = quat::fromeuler_yxy(angles);

LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.w, q2.w, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.x, q2.x, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.y, q2.y, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.z, q2.z, 1e-5);
lolunit_assert_doubles_equal(q1.w, q2.w, 1e-5);
lolunit_assert_doubles_equal(q1.x, q2.x, 1e-5);
lolunit_assert_doubles_equal(q1.y, q2.y, 1e-5);
lolunit_assert_doubles_equal(q1.z, q2.z, 1e-5);

q1 = quat::fromeuler_xzy(angles);
q2 = quat::fromeuler_yzy(angles);

LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.w, q2.w, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.x, q2.x, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.y, q2.y, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.z, q2.z, 1e-5);
lolunit_assert_doubles_equal(q1.w, q2.w, 1e-5);
lolunit_assert_doubles_equal(q1.x, q2.x, 1e-5);
lolunit_assert_doubles_equal(q1.y, q2.y, 1e-5);
lolunit_assert_doubles_equal(q1.z, q2.z, 1e-5);

q1 = quat::fromeuler_zyx(angles);
q2 = quat::fromeuler_xyx(angles);

LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.w, q2.w, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.x, q2.x, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.y, q2.y, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.z, q2.z, 1e-5);
lolunit_assert_doubles_equal(q1.w, q2.w, 1e-5);
lolunit_assert_doubles_equal(q1.x, q2.x, 1e-5);
lolunit_assert_doubles_equal(q1.y, q2.y, 1e-5);
lolunit_assert_doubles_equal(q1.z, q2.z, 1e-5);

q1 = quat::fromeuler_yxz(angles);
q2 = quat::fromeuler_zxz(angles);

LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.w, q2.w, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.x, q2.x, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.y, q2.y, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.z, q2.z, 1e-5);
lolunit_assert_doubles_equal(q1.w, q2.w, 1e-5);
lolunit_assert_doubles_equal(q1.x, q2.x, 1e-5);
lolunit_assert_doubles_equal(q1.y, q2.y, 1e-5);
lolunit_assert_doubles_equal(q1.z, q2.z, 1e-5);
}
}

LOLUNIT_TEST(TaitBryanAngles)
lolunit_declare_test(TaitBryanAngles)
{
for (int i = 0; i < 100; ++i)
{
@@ -427,53 +427,53 @@ LOLUNIT_FIXTURE(QuaternionTest)
quat q1 = quat::fromeuler_xyz(vec3::toeuler_xyz(q0));
vec3 p1 = q1.transform(p);

LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.x, p0.x, 1e-4);
LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.y, p0.y, 1e-4);
LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.z, p0.z, 1e-4);
lolunit_assert_doubles_equal(p1.x, p0.x, 1e-4);
lolunit_assert_doubles_equal(p1.y, p0.y, 1e-4);
lolunit_assert_doubles_equal(p1.z, p0.z, 1e-4);

/* y-z-x */
q1 = quat::fromeuler_yzx(vec3::toeuler_yzx(q0));
p1 = q1.transform(p);

LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.x, p0.x, 1e-4);
LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.y, p0.y, 1e-4);
LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.z, p0.z, 1e-4);
lolunit_assert_doubles_equal(p1.x, p0.x, 1e-4);
lolunit_assert_doubles_equal(p1.y, p0.y, 1e-4);
lolunit_assert_doubles_equal(p1.z, p0.z, 1e-4);

/* z-x-y */
q1 = quat::fromeuler_zxy(vec3::toeuler_zxy(q0));
p1 = q1.transform(p);

LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.x, p0.x, 1e-4);
LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.y, p0.y, 1e-4);
LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.z, p0.z, 1e-4);
lolunit_assert_doubles_equal(p1.x, p0.x, 1e-4);
lolunit_assert_doubles_equal(p1.y, p0.y, 1e-4);
lolunit_assert_doubles_equal(p1.z, p0.z, 1e-4);

/* x-z-y */
q1 = quat::fromeuler_xzy(vec3::toeuler_xzy(q0));
p1 = q1.transform(p);

LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.x, p0.x, 1e-4);
LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.y, p0.y, 1e-4);
LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.z, p0.z, 1e-4);
lolunit_assert_doubles_equal(p1.x, p0.x, 1e-4);
lolunit_assert_doubles_equal(p1.y, p0.y, 1e-4);
lolunit_assert_doubles_equal(p1.z, p0.z, 1e-4);

/* z-y-x */
q1 = quat::fromeuler_zyx(vec3::toeuler_zyx(q0));
p1 = q1.transform(p);

LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.x, p0.x, 1e-4);
LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.y, p0.y, 1e-4);
LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.z, p0.z, 1e-4);
lolunit_assert_doubles_equal(p1.x, p0.x, 1e-4);
lolunit_assert_doubles_equal(p1.y, p0.y, 1e-4);
lolunit_assert_doubles_equal(p1.z, p0.z, 1e-4);

/* y-x-z */
q1 = quat::fromeuler_yxz(vec3::toeuler_yxz(q0));
p1 = q1.transform(p);

LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.x, p0.x, 1e-4);
LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.y, p0.y, 1e-4);
LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.z, p0.z, 1e-4);
lolunit_assert_doubles_equal(p1.x, p0.x, 1e-4);
lolunit_assert_doubles_equal(p1.y, p0.y, 1e-4);
lolunit_assert_doubles_equal(p1.z, p0.z, 1e-4);
}
}

LOLUNIT_TEST(EulerAngles)
lolunit_declare_test(EulerAngles)
{
for (int i = 0; i < 100; ++i)
{
@@ -489,49 +489,49 @@ LOLUNIT_FIXTURE(QuaternionTest)
quat q1 = quat::fromeuler_xyx(vec3::toeuler_xyx(q0));
vec3 p1 = q1.transform(p);

LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.x, p0.x, 1e-4);
LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.y, p0.y, 1e-4);
LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.z, p0.z, 1e-4);
lolunit_assert_doubles_equal(p1.x, p0.x, 1e-4);
lolunit_assert_doubles_equal(p1.y, p0.y, 1e-4);
lolunit_assert_doubles_equal(p1.z, p0.z, 1e-4);

/* y-z-y */
q1 = quat::fromeuler_yzy(vec3::toeuler_yzy(q0));
p1 = q1.transform(p);

LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.x, p0.x, 1e-4);
LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.y, p0.y, 1e-4);
LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.z, p0.z, 1e-4);
lolunit_assert_doubles_equal(p1.x, p0.x, 1e-4);
lolunit_assert_doubles_equal(p1.y, p0.y, 1e-4);
lolunit_assert_doubles_equal(p1.z, p0.z, 1e-4);

/* z-x-z */
q1 = quat::fromeuler_zxz(vec3::toeuler_zxz(q0));
p1 = q1.transform(p);

LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.x, p0.x, 1e-4);
LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.y, p0.y, 1e-4);
LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.z, p0.z, 1e-4);
lolunit_assert_doubles_equal(p1.x, p0.x, 1e-4);
lolunit_assert_doubles_equal(p1.y, p0.y, 1e-4);
lolunit_assert_doubles_equal(p1.z, p0.z, 1e-4);

/* x-z-x */
q1 = quat::fromeuler_xzx(vec3::toeuler_xzx(q0));
p1 = q1.transform(p);

LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.x, p0.x, 1e-4);
LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.y, p0.y, 1e-4);
LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.z, p0.z, 1e-4);
lolunit_assert_doubles_equal(p1.x, p0.x, 1e-4);
lolunit_assert_doubles_equal(p1.y, p0.y, 1e-4);
lolunit_assert_doubles_equal(p1.z, p0.z, 1e-4);

/* z-y-z */
q1 = quat::fromeuler_zyz(vec3::toeuler_zyz(q0));
p1 = q1.transform(p);

LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.x, p0.x, 1e-4);
LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.y, p0.y, 1e-4);
LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.z, p0.z, 1e-4);
lolunit_assert_doubles_equal(p1.x, p0.x, 1e-4);
lolunit_assert_doubles_equal(p1.y, p0.y, 1e-4);
lolunit_assert_doubles_equal(p1.z, p0.z, 1e-4);

/* y-x-y */
q1 = quat::fromeuler_yxy(vec3::toeuler_yxy(q0));
p1 = q1.transform(p);

LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.x, p0.x, 1e-4);
LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.y, p0.y, 1e-4);
LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.z, p0.z, 1e-4);
lolunit_assert_doubles_equal(p1.x, p0.x, 1e-4);
lolunit_assert_doubles_equal(p1.y, p0.y, 1e-4);
lolunit_assert_doubles_equal(p1.z, p0.z, 1e-4);
}
}



+ 19
- 19
src/t/math/rand.cpp View File

@@ -18,13 +18,13 @@
namespace lol
{

LOLUNIT_FIXTURE(RandTest)
lolunit_declare_fixture(RandTest)
{
void SetUp() {}

void TearDown() {}

LOLUNIT_TEST(Int32Bits)
lolunit_declare_test(Int32Bits)
{
int const rolls = 2000;

@@ -35,7 +35,7 @@ LOLUNIT_FIXTURE(RandTest)
{
int32_t r = rand<int32_t>();

LOLUNIT_ASSERT_GEQUAL(r, 0);
lolunit_assert_gequal(r, 0);

for (int k = 0; k < 31; k++)
{
@@ -46,14 +46,14 @@ LOLUNIT_FIXTURE(RandTest)

for (int k = 0; k < 31; k++)
{
LOLUNIT_SET_CONTEXT(k);
LOLUNIT_ASSERT_GEQUAL(bits[k], rolls / 3);
LOLUNIT_ASSERT_LEQUAL(bits[k], rolls * 2 / 3);
LOLUNIT_UNSET_CONTEXT(k);
lolunit_set_context(k);
lolunit_assert_gequal(bits[k], rolls / 3);
lolunit_assert_lequal(bits[k], rolls * 2 / 3);
lolunit_unset_context(k);
}
}

LOLUNIT_TEST(Int16Bits)
lolunit_declare_test(Int16Bits)
{
int const rolls = 2000;

@@ -64,7 +64,7 @@ LOLUNIT_FIXTURE(RandTest)
{
int16_t r = rand<int16_t>();

LOLUNIT_ASSERT_GEQUAL(r, 0);
lolunit_assert_gequal(r, 0);

for (int k = 0; k < 15; k++)
{
@@ -75,14 +75,14 @@ LOLUNIT_FIXTURE(RandTest)

for (int k = 0; k < 15; k++)
{
LOLUNIT_SET_CONTEXT(k);
LOLUNIT_ASSERT_GEQUAL(bits[k], rolls / 3);
LOLUNIT_ASSERT_LEQUAL(bits[k], rolls * 2 / 3);
LOLUNIT_UNSET_CONTEXT(k);
lolunit_set_context(k);
lolunit_assert_gequal(bits[k], rolls / 3);
lolunit_assert_lequal(bits[k], rolls * 2 / 3);
lolunit_unset_context(k);
}
}

LOLUNIT_TEST(Int8Bits)
lolunit_declare_test(Int8Bits)
{
int const rolls = 2000;

@@ -93,7 +93,7 @@ LOLUNIT_FIXTURE(RandTest)
{
int8_t r = rand<int8_t>();

LOLUNIT_ASSERT_GEQUAL(r, 0);
lolunit_assert_gequal(r, 0);

for (int k = 0; k < 7; k++)
{
@@ -104,10 +104,10 @@ LOLUNIT_FIXTURE(RandTest)

for (int k = 0; k < 7; k++)
{
LOLUNIT_SET_CONTEXT(k);
LOLUNIT_ASSERT_GEQUAL(bits[k], rolls / 3);
LOLUNIT_ASSERT_LEQUAL(bits[k], rolls * 2 / 3);
LOLUNIT_UNSET_CONTEXT(k);
lolunit_set_context(k);
lolunit_assert_gequal(bits[k], rolls / 3);
lolunit_assert_lequal(bits[k], rolls * 2 / 3);
lolunit_unset_context(k);
}
}
};


+ 117
- 117
src/t/math/real.cpp View File

@@ -20,56 +20,56 @@
namespace lol
{

LOLUNIT_FIXTURE(RealTest)
lolunit_declare_fixture(RealTest)
{
LOLUNIT_TEST(Constants)
lolunit_declare_test(Constants)
{
double a0 = real::R_0();
double a1 = real::R_1();
double a2 = real::R_2();
double a10 = real::R_10();

LOLUNIT_ASSERT_EQUAL(a0, 0.0);
LOLUNIT_ASSERT_EQUAL(a1, 1.0);
LOLUNIT_ASSERT_EQUAL(a2, 2.0);
LOLUNIT_ASSERT_EQUAL(a10, 10.0);
lolunit_assert_equal(a0, 0.0);
lolunit_assert_equal(a1, 1.0);
lolunit_assert_equal(a2, 2.0);
lolunit_assert_equal(a10, 10.0);

double b1 = log(real::R_E());
double b2 = log2(real::R_2());
LOLUNIT_ASSERT_EQUAL(b1, 1.0);
LOLUNIT_ASSERT_EQUAL(b2, 1.0);
lolunit_assert_equal(b1, 1.0);
lolunit_assert_equal(b2, 1.0);

double c1 = exp(re(real::R_LOG2E()));
double c2 = log(exp2(real::R_LOG2E()));
LOLUNIT_ASSERT_EQUAL(c1, 2.0);
LOLUNIT_ASSERT_EQUAL(c2, 1.0);
lolunit_assert_equal(c1, 2.0);
lolunit_assert_equal(c2, 1.0);

double d1 = exp(re(real::R_LOG10E()));
LOLUNIT_ASSERT_EQUAL(d1, 10.0);
lolunit_assert_equal(d1, 10.0);

double e1 = exp(real::R_LN2());
LOLUNIT_ASSERT_EQUAL(e1, 2.0);
lolunit_assert_equal(e1, 2.0);

double f1 = exp(real::R_LN10());
LOLUNIT_ASSERT_EQUAL(f1, 10.0);
lolunit_assert_equal(f1, 10.0);

double g1 = sin(real::R_PI());
double g2 = cos(real::R_PI());
LOLUNIT_ASSERT_DOUBLES_EQUAL(g1, 0.0, 1e-100);
LOLUNIT_ASSERT_EQUAL(g2, -1.0);
lolunit_assert_doubles_equal(g1, 0.0, 1e-100);
lolunit_assert_equal(g2, -1.0);

double h1 = sin(real::R_PI_2());
double h2 = cos(real::R_PI_2());
LOLUNIT_ASSERT_EQUAL(h1, 1.0);
LOLUNIT_ASSERT_DOUBLES_EQUAL(h2, 0.0, 1e-100);
lolunit_assert_equal(h1, 1.0);
lolunit_assert_doubles_equal(h2, 0.0, 1e-100);

double i1 = sin(real::R_PI_4()) * sin(real::R_PI_4());
double i2 = cos(real::R_PI_4()) * cos(real::R_PI_4());
LOLUNIT_ASSERT_EQUAL(i1, 0.5);
LOLUNIT_ASSERT_EQUAL(i2, 0.5);
lolunit_assert_equal(i1, 0.5);
lolunit_assert_equal(i2, 0.5);
}

LOLUNIT_TEST(FloatToReal)
lolunit_declare_test(FloatToReal)
{
float a1 = real(0.0f);
float a2 = real(-0.0f);
@@ -78,15 +78,15 @@ LOLUNIT_FIXTURE(RealTest)
float a5 = real(1.5f);
float a6 = real(12345678.0f);

LOLUNIT_ASSERT_EQUAL(a1, 0.0f);
LOLUNIT_ASSERT_EQUAL(a2, -0.0f);
LOLUNIT_ASSERT_EQUAL(a3, 1.0f);
LOLUNIT_ASSERT_EQUAL(a4, -1.0f);
LOLUNIT_ASSERT_EQUAL(a5, 1.5f);
LOLUNIT_ASSERT_EQUAL(a6, 12345678.0f);
lolunit_assert_equal(a1, 0.0f);
lolunit_assert_equal(a2, -0.0f);
lolunit_assert_equal(a3, 1.0f);
lolunit_assert_equal(a4, -1.0f);
lolunit_assert_equal(a5, 1.5f);
lolunit_assert_equal(a6, 12345678.0f);
}

LOLUNIT_TEST(DoubleToReal)
lolunit_declare_test(DoubleToReal)
{
double a1 = real(0.0);
double a2 = real(-0.0);
@@ -95,30 +95,30 @@ LOLUNIT_FIXTURE(RealTest)
double a5 = real(1.5);
double a6 = real(1234567876543210.0);

LOLUNIT_ASSERT_DOUBLES_EQUAL(a1, 0.0, 0.0);
LOLUNIT_ASSERT_DOUBLES_EQUAL(a2, -0.0, 0.0);
LOLUNIT_ASSERT_DOUBLES_EQUAL(a3, 1.0, 0.0);
LOLUNIT_ASSERT_DOUBLES_EQUAL(a4, -1.0, 0.0);
LOLUNIT_ASSERT_DOUBLES_EQUAL(a5, 1.5, 0.0);
LOLUNIT_ASSERT_DOUBLES_EQUAL(a6, 1234567876543210.0, 0.0);
lolunit_assert_doubles_equal(a1, 0.0, 0.0);
lolunit_assert_doubles_equal(a2, -0.0, 0.0);
lolunit_assert_doubles_equal(a3, 1.0, 0.0);
lolunit_assert_doubles_equal(a4, -1.0, 0.0);
lolunit_assert_doubles_equal(a5, 1.5, 0.0);
lolunit_assert_doubles_equal(a6, 1234567876543210.0, 0.0);
}

LOLUNIT_TEST(Init)
lolunit_declare_test(Init)
{
real r;
float f1 = (float)r;

LOLUNIT_ASSERT_EQUAL(f1, 0.0f);
lolunit_assert_equal(f1, 0.0f);

rcmplx q;
float f2 = (float)q.x;
float f3 = (float)q.y;

LOLUNIT_ASSERT_EQUAL(f2, 0.0f);
LOLUNIT_ASSERT_EQUAL(f3, 0.0f);
lolunit_assert_equal(f2, 0.0f);
lolunit_assert_equal(f3, 0.0f);
}

LOLUNIT_TEST(StringToReal)
lolunit_declare_test(StringToReal)
{
float a1 = real("0");
float a2 = real("1");
@@ -129,47 +129,47 @@ LOLUNIT_FIXTURE(RealTest)
"6569604314863681793212890625")
* real("340282366920938463463374607431768211456");

LOLUNIT_ASSERT_EQUAL(a1, 0.0f);
LOLUNIT_ASSERT_EQUAL(a2, 1.0f);
LOLUNIT_ASSERT_EQUAL(a3, -1.0f);
LOLUNIT_ASSERT_EQUAL(a4, 1.0f);
lolunit_assert_equal(a1, 0.0f);
lolunit_assert_equal(a2, 1.0f);
lolunit_assert_equal(a3, -1.0f);
lolunit_assert_equal(a4, 1.0f);
}

LOLUNIT_TEST(UnaryMinus)
lolunit_declare_test(UnaryMinus)
{
float a1 = - real(1.0f);
float a2 = - real(-1.0f);
float a3 = - real(0.0f);
float a4 = - real(-0.0f);

LOLUNIT_ASSERT_EQUAL(a1, -1.0f);
LOLUNIT_ASSERT_EQUAL(a2, 1.0f);
LOLUNIT_ASSERT_EQUAL(a3, -0.0f);
LOLUNIT_ASSERT_EQUAL(a4, 0.0f);
lolunit_assert_equal(a1, -1.0f);
lolunit_assert_equal(a2, 1.0f);
lolunit_assert_equal(a3, -0.0f);
lolunit_assert_equal(a4, 0.0f);
}

LOLUNIT_TEST(Comparison)
lolunit_declare_test(Comparison)
{
LOLUNIT_ASSERT(real(1.0f) > real(0.5f));
LOLUNIT_ASSERT(real(1.0f) >= real(0.5f));
LOLUNIT_ASSERT(real(1.0f) >= real(1.0f));
LOLUNIT_ASSERT(real(-1.0f) < real(-0.5f));
LOLUNIT_ASSERT(real(-1.0f) <= real(-0.5f));
LOLUNIT_ASSERT(real(-1.0f) <= real(-1.0f));
LOLUNIT_ASSERT(real(-1.0f) < real(0.5f));
LOLUNIT_ASSERT(real(-0.5f) < real(1.0f));
LOLUNIT_ASSERT(real(-1.0f) <= real(0.5f));
LOLUNIT_ASSERT(real(-0.5f) <= real(1.0f));
LOLUNIT_ASSERT(real(1.0f) > real(-0.5f));
LOLUNIT_ASSERT(real(0.5f) > real(-1.0f));
LOLUNIT_ASSERT(real(1.0f) >= real(-0.5f));
LOLUNIT_ASSERT(real(0.5f) >= real(-1.0f));
lolunit_assert(real(1.0f) > real(0.5f));
lolunit_assert(real(1.0f) >= real(0.5f));
lolunit_assert(real(1.0f) >= real(1.0f));
lolunit_assert(real(-1.0f) < real(-0.5f));
lolunit_assert(real(-1.0f) <= real(-0.5f));
lolunit_assert(real(-1.0f) <= real(-1.0f));
lolunit_assert(real(-1.0f) < real(0.5f));
lolunit_assert(real(-0.5f) < real(1.0f));
lolunit_assert(real(-1.0f) <= real(0.5f));
lolunit_assert(real(-0.5f) <= real(1.0f));
lolunit_assert(real(1.0f) > real(-0.5f));
lolunit_assert(real(0.5f) > real(-1.0f));
lolunit_assert(real(1.0f) >= real(-0.5f));
lolunit_assert(real(0.5f) >= real(-1.0f));
}

LOLUNIT_TEST(Addition)
lolunit_declare_test(Addition)
{
float a1 = real(1.0f) + real(0.0f);
float a2 = real(0.0f) + real(1.0f);
@@ -181,24 +181,24 @@ LOLUNIT_FIXTURE(RealTest)
float a7 = real(1.0f) + real(-0.125f);
double a8 = real(0.10000000002) + real(-2.0e-11);

LOLUNIT_ASSERT_EQUAL(a1, 1.0f);
LOLUNIT_ASSERT_EQUAL(a2, 1.0f);
LOLUNIT_ASSERT_EQUAL(a3, 2.0f);
LOLUNIT_ASSERT_EQUAL(a4, -2.0f);
LOLUNIT_ASSERT_EQUAL(a5, 1.125f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(a6, 3.1361579, 0.000001);
LOLUNIT_ASSERT_EQUAL(a7, 0.875f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(a8, 0.1, 1.0e-13);
lolunit_assert_equal(a1, 1.0f);
lolunit_assert_equal(a2, 1.0f);
lolunit_assert_equal(a3, 2.0f);
lolunit_assert_equal(a4, -2.0f);
lolunit_assert_equal(a5, 1.125f);
lolunit_assert_doubles_equal(a6, 3.1361579, 0.000001);
lolunit_assert_equal(a7, 0.875f);
lolunit_assert_doubles_equal(a8, 0.1, 1.0e-13);
}

LOLUNIT_TEST(Subtraction)
lolunit_declare_test(Subtraction)
{
float a1 = real(1.0f) + real(1e20f) - real(1e20f);

LOLUNIT_ASSERT_EQUAL(a1, 1.0f);
lolunit_assert_equal(a1, 1.0f);
}

LOLUNIT_TEST(Multiplication)
lolunit_declare_test(Multiplication)
{
real x(1.25f);
real y(1.5f);
@@ -210,13 +210,13 @@ LOLUNIT_FIXTURE(RealTest)
float m3 = z * z;
float m4 = w * w;

LOLUNIT_ASSERT_EQUAL(m1, 1.25f * 1.25f);
LOLUNIT_ASSERT_EQUAL(m2, 1.5f * 1.5f);
LOLUNIT_ASSERT_EQUAL(m3, 1.99999f * 1.99999f);
LOLUNIT_ASSERT_EQUAL(m4, -1.5f * -1.5f);
lolunit_assert_equal(m1, 1.25f * 1.25f);
lolunit_assert_equal(m2, 1.5f * 1.5f);
lolunit_assert_equal(m3, 1.99999f * 1.99999f);
lolunit_assert_equal(m4, -1.5f * -1.5f);
}

LOLUNIT_TEST(ExactDivision)
lolunit_declare_test(ExactDivision)
{
float m1 = real::R_1() / real::R_1();
float m2 = real::R_2() / real::R_1();
@@ -224,65 +224,65 @@ LOLUNIT_FIXTURE(RealTest)
float m4 = real::R_2() / real::R_2();
float m5 = real::R_1() / -real::R_2();

LOLUNIT_ASSERT_EQUAL(m1, 1.0f);
LOLUNIT_ASSERT_EQUAL(m2, 2.0f);
LOLUNIT_ASSERT_EQUAL(m3, 0.5f);
LOLUNIT_ASSERT_EQUAL(m4, 1.0f);
LOLUNIT_ASSERT_EQUAL(m5, -0.5f);
lolunit_assert_equal(m1, 1.0f);
lolunit_assert_equal(m2, 2.0f);
lolunit_assert_equal(m3, 0.5f);
lolunit_assert_equal(m4, 1.0f);
lolunit_assert_equal(m5, -0.5f);
}

LOLUNIT_TEST(InexactDivision)
lolunit_declare_test(InexactDivision)
{
/* 1 / 3 * 3 should be close to 1... check that it does not differ
* by more than 2^-k where k is the number of bits in the mantissa. */
real a = real::R_1() / real::R_3() * real::R_3();
real b = ldexp(real::R_1() - a, real::BIGITS * real::BIGIT_BITS);

LOLUNIT_ASSERT_LEQUAL((double)fabs(b), 1.0);
lolunit_assert_lequal((double)fabs(b), 1.0);
}

LOLUNIT_TEST(LoadExp)
lolunit_declare_test(LoadExp)
{
real a1(1.5);
real a2(-1.5);
real a3(0.0);

LOLUNIT_ASSERT_EQUAL((double)ldexp(a1, 7), 192.0);
LOLUNIT_ASSERT_EQUAL((double)ldexp(a1, -7), 0.01171875);
lolunit_assert_equal((double)ldexp(a1, 7), 192.0);
lolunit_assert_equal((double)ldexp(a1, -7), 0.01171875);

LOLUNIT_ASSERT_EQUAL((double)ldexp(a2, 7), -192.0);
LOLUNIT_ASSERT_EQUAL((double)ldexp(a2, -7), -0.01171875);
lolunit_assert_equal((double)ldexp(a2, 7), -192.0);
lolunit_assert_equal((double)ldexp(a2, -7), -0.01171875);

LOLUNIT_ASSERT_EQUAL((double)ldexp(a3, 7), 0.0);
LOLUNIT_ASSERT_EQUAL((double)ldexp(a3, -7), 0.0);
lolunit_assert_equal((double)ldexp(a3, 7), 0.0);
lolunit_assert_equal((double)ldexp(a3, -7), 0.0);
}

LOLUNIT_TEST(Ulp)
lolunit_declare_test(Ulp)
{
real a1 = real::R_PI();

LOLUNIT_ASSERT_NOT_EQUAL((double)(a1 + ulp(a1) - a1), 0.0);
LOLUNIT_ASSERT_EQUAL((double)(a1 + ulp(a1) / 2 - a1), 0.0);
lolunit_assert_not_equal((double)(a1 + ulp(a1) - a1), 0.0);
lolunit_assert_equal((double)(a1 + ulp(a1) / 2 - a1), 0.0);
}

LOLUNIT_TEST(Bool)
lolunit_declare_test(Bool)
{
real a = 0.0;
LOLUNIT_ASSERT(!a);
lolunit_assert(!a);

a = -0.0;
LOLUNIT_ASSERT(!a);
lolunit_assert(!a);

a = 1234.0;
LOLUNIT_ASSERT(a);
LOLUNIT_ASSERT(!!a);
lolunit_assert(a);
lolunit_assert(!!a);

a = -1234.0;
LOLUNIT_ASSERT(a);
LOLUNIT_ASSERT(!!a);
lolunit_assert(a);
lolunit_assert(!!a);
}

LOLUNIT_TEST(AsinAcos)
lolunit_declare_test(AsinAcos)
{
double tests[] =
{
@@ -296,13 +296,13 @@ LOLUNIT_FIXTURE(RealTest)
double b = sin(asin((real)a));
double c = cos(acos((real)a));

LOLUNIT_SET_CONTEXT(a);
LOLUNIT_ASSERT_DOUBLES_EQUAL(b, a, 1e-100);
LOLUNIT_ASSERT_DOUBLES_EQUAL(c, a, 1e-100);
lolunit_set_context(a);
lolunit_assert_doubles_equal(b, a, 1e-100);
lolunit_assert_doubles_equal(c, a, 1e-100);
}
}

LOLUNIT_TEST(FloorCeilEtc)
lolunit_declare_test(FloorCeilEtc)
{
double tests[] =
{
@@ -338,21 +338,21 @@ LOLUNIT_FIXTURE(RealTest)
double a2 = round((real)tests[n]);
double b2 = tests[n + 3];

LOLUNIT_ASSERT_EQUAL(b0, a0);
LOLUNIT_ASSERT_EQUAL(b1, a1);
LOLUNIT_ASSERT_EQUAL(b2, a2);
lolunit_assert_equal(b0, a0);
lolunit_assert_equal(b1, a1);
lolunit_assert_equal(b2, a2);
}
}

LOLUNIT_TEST(Pow)
lolunit_declare_test(Pow)
{
double a1 = pow(-real::R_2(), real::R_2());
double b1 = 4.0;
LOLUNIT_ASSERT_DOUBLES_EQUAL(a1, b1, 1.0e-13);
lolunit_assert_doubles_equal(a1, b1, 1.0e-13);

double a2 = pow(-real::R_2(), real::R_3());
double b2 = -8.0;
LOLUNIT_ASSERT_DOUBLES_EQUAL(a2, b2, 1.0e-13);
lolunit_assert_doubles_equal(a2, b2, 1.0e-13);
}
};



+ 72
- 72
src/t/math/rotation.cpp View File

@@ -18,13 +18,13 @@
namespace lol
{

LOLUNIT_FIXTURE(RotationTest)
lolunit_declare_fixture(RotationTest)
{
void SetUp() {}

void TearDown() {}

LOLUNIT_TEST(Rotate2D)
lolunit_declare_test(Rotate2D)
{
/* Rotations must be CCW */
mat2 m90 = mat2::rotate(90.f);
@@ -32,29 +32,29 @@ LOLUNIT_FIXTURE(RotationTest)
vec2 a(2.f, 3.f);
vec2 b = m90 * a;

LOLUNIT_ASSERT_DOUBLES_EQUAL(b.x, -a.y, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(b.y, a.x, 1e-5);
lolunit_assert_doubles_equal(b.x, -a.y, 1e-5);
lolunit_assert_doubles_equal(b.y, a.x, 1e-5);

float d = determinant(m90);

LOLUNIT_ASSERT_DOUBLES_EQUAL(d, 1.0, 1e-5);
lolunit_assert_doubles_equal(d, 1.0, 1e-5);
}

LOLUNIT_TEST(Compose2D)
lolunit_declare_test(Compose2D)
{
/* Rotating 20 degrees twice must equal rotating 40 degrees */
mat2 m20 = mat2::rotate(20.f);
mat2 m40 = mat2::rotate(40.f);
mat2 m20x20 = m20 * m20;

LOLUNIT_ASSERT_DOUBLES_EQUAL(m20x20[0][0], m40[0][0], 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(m20x20[1][0], m40[1][0], 1e-5);
lolunit_assert_doubles_equal(m20x20[0][0], m40[0][0], 1e-5);
lolunit_assert_doubles_equal(m20x20[1][0], m40[1][0], 1e-5);

LOLUNIT_ASSERT_DOUBLES_EQUAL(m20x20[0][1], m40[0][1], 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(m20x20[1][1], m40[1][1], 1e-5);
lolunit_assert_doubles_equal(m20x20[0][1], m40[0][1], 1e-5);
lolunit_assert_doubles_equal(m20x20[1][1], m40[1][1], 1e-5);
}

LOLUNIT_TEST(Rotate3D)
lolunit_declare_test(Rotate3D)
{
/* Rotations must be CCW along each axis */
mat3 m90x = mat3::rotate(90.f, 1.f, 0.f, 0.f);
@@ -66,48 +66,48 @@ LOLUNIT_FIXTURE(RotationTest)
vec3 c = m90y * a;
vec3 d = m90z * a;

LOLUNIT_ASSERT_DOUBLES_EQUAL(b.x, a.x, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(b.y, -a.z, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(b.z, a.y, 1e-5);
lolunit_assert_doubles_equal(b.x, a.x, 1e-5);
lolunit_assert_doubles_equal(b.y, -a.z, 1e-5);
lolunit_assert_doubles_equal(b.z, a.y, 1e-5);

LOLUNIT_ASSERT_DOUBLES_EQUAL(c.x, a.z, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(c.y, a.y, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(c.z, -a.x, 1e-5);
lolunit_assert_doubles_equal(c.x, a.z, 1e-5);
lolunit_assert_doubles_equal(c.y, a.y, 1e-5);
lolunit_assert_doubles_equal(c.z, -a.x, 1e-5);

LOLUNIT_ASSERT_DOUBLES_EQUAL(d.x, -a.y, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(d.y, a.x, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(d.z, a.z, 1e-5);
lolunit_assert_doubles_equal(d.x, -a.y, 1e-5);
lolunit_assert_doubles_equal(d.y, a.x, 1e-5);
lolunit_assert_doubles_equal(d.z, a.z, 1e-5);

float dx = determinant(m90x);
float dy = determinant(m90y);
float dz = determinant(m90z);

LOLUNIT_ASSERT_DOUBLES_EQUAL(dx, 1.0, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(dy, 1.0, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(dz, 1.0, 1e-5);
lolunit_assert_doubles_equal(dx, 1.0, 1e-5);
lolunit_assert_doubles_equal(dy, 1.0, 1e-5);
lolunit_assert_doubles_equal(dz, 1.0, 1e-5);
}

LOLUNIT_TEST(Compose3D)
lolunit_declare_test(Compose3D)
{
/* Rotating 20 degrees twice must equal rotating 40 degrees */
mat3 m20 = mat3::rotate(20.f, 1.f, 2.f, 3.f);
mat3 m40 = mat3::rotate(40.f, 1.f, 2.f, 3.f);
mat3 m20x20 = m20 * m20;

LOLUNIT_ASSERT_DOUBLES_EQUAL(m20x20[0][0], m40[0][0], 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(m20x20[1][0], m40[1][0], 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(m20x20[2][0], m40[2][0], 1e-5);
lolunit_assert_doubles_equal(m20x20[0][0], m40[0][0], 1e-5);
lolunit_assert_doubles_equal(m20x20[1][0], m40[1][0], 1e-5);
lolunit_assert_doubles_equal(m20x20[2][0], m40[2][0], 1e-5);

LOLUNIT_ASSERT_DOUBLES_EQUAL(m20x20[0][1], m40[0][1], 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(m20x20[1][1], m40[1][1], 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(m20x20[2][1], m40[2][1], 1e-5);
lolunit_assert_doubles_equal(m20x20[0][1], m40[0][1], 1e-5);
lolunit_assert_doubles_equal(m20x20[1][1], m40[1][1], 1e-5);
lolunit_assert_doubles_equal(m20x20[2][1], m40[2][1], 1e-5);

LOLUNIT_ASSERT_DOUBLES_EQUAL(m20x20[0][2], m40[0][2], 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(m20x20[1][2], m40[1][2], 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(m20x20[2][2], m40[2][2], 1e-5);
lolunit_assert_doubles_equal(m20x20[0][2], m40[0][2], 1e-5);
lolunit_assert_doubles_equal(m20x20[1][2], m40[1][2], 1e-5);
lolunit_assert_doubles_equal(m20x20[2][2], m40[2][2], 1e-5);
}

LOLUNIT_TEST(QuaternionTransform)
lolunit_declare_test(QuaternionTransform)
{
/* Rotating using a quaternion must equal rotating using a matrix */
mat3 m20 = mat3::rotate(20.f, 1.f, 2.f, 3.f);
@@ -117,61 +117,61 @@ LOLUNIT_FIXTURE(RotationTest)
vec3 b = m20 * a;
vec3 c = q20.transform(a);

LOLUNIT_ASSERT_DOUBLES_EQUAL(c.x, b.x, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(c.y, b.y, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(c.z, b.z, 1e-5);
lolunit_assert_doubles_equal(c.x, b.x, 1e-5);
lolunit_assert_doubles_equal(c.y, b.y, 1e-5);
lolunit_assert_doubles_equal(c.z, b.z, 1e-5);

float n = norm(q20);

LOLUNIT_ASSERT_DOUBLES_EQUAL(n, 1.0, 1e-5);
lolunit_assert_doubles_equal(n, 1.0, 1e-5);
}

LOLUNIT_TEST(QuaternionFromMatrix)
lolunit_declare_test(QuaternionFromMatrix)
{
/* A rotation matrix converted to a quaternion should match the
* quaternion built with the same parameters */
quat q1 = quat::rotate(20.f, 1.f, 2.f, 3.f);
quat q2 = quat(mat3::rotate(20.f, 1.f, 2.f, 3.f));

LOLUNIT_ASSERT_DOUBLES_EQUAL(q2.w, q1.w, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q2.x, q1.x, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q2.y, q1.y, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q2.z, q1.z, 1e-5);
lolunit_assert_doubles_equal(q2.w, q1.w, 1e-5);
lolunit_assert_doubles_equal(q2.x, q1.x, 1e-5);
lolunit_assert_doubles_equal(q2.y, q1.y, 1e-5);
lolunit_assert_doubles_equal(q2.z, q1.z, 1e-5);

float n1 = norm(q1);
float n2 = norm(q2);

LOLUNIT_ASSERT_DOUBLES_EQUAL(n1, 1.0, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(n2, 1.0, 1e-5);
lolunit_assert_doubles_equal(n1, 1.0, 1e-5);
lolunit_assert_doubles_equal(n2, 1.0, 1e-5);
}

LOLUNIT_TEST(MatrixFromQuaternion)
lolunit_declare_test(MatrixFromQuaternion)
{
/* A quaternion converted to a rotation matrix should match the
* rotation matrix built with the same parameters */
mat3 m1 = mat3::rotate(60.f, 1.f, -2.f, 3.f);
mat3 m2 = mat3(quat::rotate(60.f, 1.f, -2.f, 3.f));

LOLUNIT_ASSERT_DOUBLES_EQUAL(m2[0][0], m1[0][0], 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(m2[1][0], m1[1][0], 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(m2[2][0], m1[2][0], 1e-5);
lolunit_assert_doubles_equal(m2[0][0], m1[0][0], 1e-5);
lolunit_assert_doubles_equal(m2[1][0], m1[1][0], 1e-5);
lolunit_assert_doubles_equal(m2[2][0], m1[2][0], 1e-5);

LOLUNIT_ASSERT_DOUBLES_EQUAL(m2[0][1], m1[0][1], 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(m2[1][1], m1[1][1], 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(m2[2][1], m1[2][1], 1e-5);
lolunit_assert_doubles_equal(m2[0][1], m1[0][1], 1e-5);
lolunit_assert_doubles_equal(m2[1][1], m1[1][1], 1e-5);
lolunit_assert_doubles_equal(m2[2][1], m1[2][1], 1e-5);

LOLUNIT_ASSERT_DOUBLES_EQUAL(m2[0][2], m1[0][2], 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(m2[1][2], m1[1][2], 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(m2[2][2], m1[2][2], 1e-5);
lolunit_assert_doubles_equal(m2[0][2], m1[0][2], 1e-5);
lolunit_assert_doubles_equal(m2[1][2], m1[1][2], 1e-5);
lolunit_assert_doubles_equal(m2[2][2], m1[2][2], 1e-5);

float d1 = determinant(m1);
float d2 = determinant(m2);

LOLUNIT_ASSERT_DOUBLES_EQUAL(d1, 1.0, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(d2, 1.0, 1e-5);
lolunit_assert_doubles_equal(d1, 1.0, 1e-5);
lolunit_assert_doubles_equal(d2, 1.0, 1e-5);
}

LOLUNIT_TEST(MatrixCompositionThroughQuaternions)
lolunit_declare_test(MatrixCompositionThroughQuaternions)
{
/* Combining two rotation matrices should match the matrix created
* from the combination of the two equivalent quaternions */
@@ -181,20 +181,20 @@ LOLUNIT_FIXTURE(RotationTest)
mat3 m3 = m2 * m1;
mat3 m4(quat(m2) * quat(m1));

LOLUNIT_ASSERT_DOUBLES_EQUAL(m4[0][0], m3[0][0], 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(m4[1][0], m3[1][0], 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(m4[2][0], m3[2][0], 1e-5);
lolunit_assert_doubles_equal(m4[0][0], m3[0][0], 1e-5);
lolunit_assert_doubles_equal(m4[1][0], m3[1][0], 1e-5);
lolunit_assert_doubles_equal(m4[2][0], m3[2][0], 1e-5);

LOLUNIT_ASSERT_DOUBLES_EQUAL(m4[0][1], m3[0][1], 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(m4[1][1], m3[1][1], 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(m4[2][1], m3[2][1], 1e-5);
lolunit_assert_doubles_equal(m4[0][1], m3[0][1], 1e-5);
lolunit_assert_doubles_equal(m4[1][1], m3[1][1], 1e-5);
lolunit_assert_doubles_equal(m4[2][1], m3[2][1], 1e-5);

LOLUNIT_ASSERT_DOUBLES_EQUAL(m4[0][2], m3[0][2], 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(m4[1][2], m3[1][2], 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(m4[2][2], m3[2][2], 1e-5);
lolunit_assert_doubles_equal(m4[0][2], m3[0][2], 1e-5);
lolunit_assert_doubles_equal(m4[1][2], m3[1][2], 1e-5);
lolunit_assert_doubles_equal(m4[2][2], m3[2][2], 1e-5);
}

LOLUNIT_TEST(QuaternionCompositionThroughMatrices)
lolunit_declare_test(QuaternionCompositionThroughMatrices)
{
/* Combining two quaternions should match the quaternion created
* from the combination of the two equivalent rotation matrices */
@@ -204,10 +204,10 @@ LOLUNIT_FIXTURE(RotationTest)
quat q3 = q2 * q1;
quat q4(mat3(q2) * mat3(q1));

LOLUNIT_ASSERT_DOUBLES_EQUAL(q4.w, q3.w, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q4.x, q3.x, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q4.y, q3.y, 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(q4.z, q3.z, 1e-5);
lolunit_assert_doubles_equal(q4.w, q3.w, 1e-5);
lolunit_assert_doubles_equal(q4.x, q3.x, 1e-5);
lolunit_assert_doubles_equal(q4.y, q3.y, 1e-5);
lolunit_assert_doubles_equal(q4.z, q3.z, 1e-5);
}
};



+ 36
- 36
src/t/math/trig.cpp View File

@@ -20,24 +20,24 @@
namespace lol
{

LOLUNIT_FIXTURE(TrigTest)
lolunit_declare_fixture(TrigTest)
{
LOLUNIT_TEST(AngleConversions)
lolunit_declare_test(AngleConversions)
{
LOLUNIT_ASSERT_DOUBLES_EQUAL(D_PI, radians(180.0), 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(D_PI_2, radians(90.0), 1e-5);
lolunit_assert_doubles_equal(D_PI, radians(180.0), 1e-5);
lolunit_assert_doubles_equal(D_PI_2, radians(90.0), 1e-5);

LOLUNIT_ASSERT_DOUBLES_EQUAL(F_PI, radians(180.0f), 1e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(F_PI_2, radians(90.0f), 1e-5f);
lolunit_assert_doubles_equal(F_PI, radians(180.0f), 1e-5f);
lolunit_assert_doubles_equal(F_PI_2, radians(90.0f), 1e-5f);

LOLUNIT_ASSERT_DOUBLES_EQUAL(180.0, degrees(D_PI), 1e-5);
LOLUNIT_ASSERT_DOUBLES_EQUAL(90.0, degrees(D_PI_2), 1e-5);
lolunit_assert_doubles_equal(180.0, degrees(D_PI), 1e-5);
lolunit_assert_doubles_equal(90.0, degrees(D_PI_2), 1e-5);

LOLUNIT_ASSERT_DOUBLES_EQUAL(180.0f, degrees(F_PI), 1e-5f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(90.0f, degrees(F_PI_2), 1e-5f);
lolunit_assert_doubles_equal(180.0f, degrees(F_PI), 1e-5f);
lolunit_assert_doubles_equal(90.0f, degrees(F_PI_2), 1e-5f);
}

LOLUNIT_TEST(Sin)
lolunit_declare_test(Sin)
{
using std::fabs;

@@ -50,8 +50,8 @@ LOLUNIT_FIXTURE(TrigTest)
double a = std::sin(f);
#endif
double b = lol_sin(f);
LOLUNIT_SET_CONTEXT(f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(a, b, fabs(f) * 1e-11);
lolunit_set_context(f);
lolunit_assert_doubles_equal(a, b, fabs(f) * 1e-11);
}

for (int i = -10000; i < 10000; i++)
@@ -63,12 +63,12 @@ LOLUNIT_FIXTURE(TrigTest)
double a = std::sin(f);
#endif
double b = lol_sin(f);
LOLUNIT_SET_CONTEXT(f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(a, b, fabs(f) * 1e-11);
lolunit_set_context(f);
lolunit_assert_doubles_equal(a, b, fabs(f) * 1e-11);
}
}

LOLUNIT_TEST(Cos)
lolunit_declare_test(Cos)
{
using std::fabs;

@@ -81,8 +81,8 @@ LOLUNIT_FIXTURE(TrigTest)
double a = std::cos(f);
#endif
double b = lol_cos(f);
LOLUNIT_SET_CONTEXT(f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(a, b, fabs(f) * 1e-11);
lolunit_set_context(f);
lolunit_assert_doubles_equal(a, b, fabs(f) * 1e-11);
}

for (int i = -10000; i < 10000; i++)
@@ -94,12 +94,12 @@ LOLUNIT_FIXTURE(TrigTest)
double a = std::cos(f);
#endif
double b = lol_cos(f);
LOLUNIT_SET_CONTEXT(f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(a, b, fabs(f) * 1e-11);
lolunit_set_context(f);
lolunit_assert_doubles_equal(a, b, fabs(f) * 1e-11);
}
}

LOLUNIT_TEST(SinCos)
lolunit_declare_test(SinCos)
{
using std::fabs;

@@ -115,9 +115,9 @@ LOLUNIT_FIXTURE(TrigTest)
#endif
double b1, b2;
lol_sincos(f, &b1, &b2);
LOLUNIT_SET_CONTEXT(f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(a1, b1, fabs(f) * 1e-11);
LOLUNIT_ASSERT_DOUBLES_EQUAL(a2, b2, fabs(f) * 1e-11);
lolunit_set_context(f);
lolunit_assert_doubles_equal(a1, b1, fabs(f) * 1e-11);
lolunit_assert_doubles_equal(a2, b2, fabs(f) * 1e-11);
}

for (int i = -10000; i < 10000; i++)
@@ -132,13 +132,13 @@ LOLUNIT_FIXTURE(TrigTest)
#endif
double b1, b2;
lol_sincos(f, &b1, &b2);
LOLUNIT_SET_CONTEXT(f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(a1, b1, fabs(f) * 1e-11);
LOLUNIT_ASSERT_DOUBLES_EQUAL(a2, b2, fabs(f) * 1e-11);
lolunit_set_context(f);
lolunit_assert_doubles_equal(a1, b1, fabs(f) * 1e-11);
lolunit_assert_doubles_equal(a2, b2, fabs(f) * 1e-11);
}
}

LOLUNIT_TEST(Tan)
lolunit_declare_test(Tan)
{
using std::fabs;

@@ -151,13 +151,13 @@ LOLUNIT_FIXTURE(TrigTest)
double a = std::tan(f);
#endif
double b = lol_tan(f);
LOLUNIT_SET_CONTEXT(f);
lolunit_set_context(f);
if (fabs(a) > 1e4)
LOLUNIT_ASSERT_DOUBLES_EQUAL(a, b, fabs(a) * fabs(a) * 1e-11);
lolunit_assert_doubles_equal(a, b, fabs(a) * fabs(a) * 1e-11);
else if (fabs(a) > 1.0)
LOLUNIT_ASSERT_DOUBLES_EQUAL(a, b, fabs(a) * 1e-11);
lolunit_assert_doubles_equal(a, b, fabs(a) * 1e-11);
else
LOLUNIT_ASSERT_DOUBLES_EQUAL(a, b, fabs(f) * 1e-11);
lolunit_assert_doubles_equal(a, b, fabs(f) * 1e-11);
}

for (int i = -10000; i < 10000; i++)
@@ -169,13 +169,13 @@ LOLUNIT_FIXTURE(TrigTest)
double a = std::tan(f);
#endif
double b = lol_tan(f);
LOLUNIT_SET_CONTEXT(f);
lolunit_set_context(f);
if (fabs(a) > 1e4)
LOLUNIT_ASSERT_DOUBLES_EQUAL(a, b, fabs(a) * fabs(a) * 1e-11);
lolunit_assert_doubles_equal(a, b, fabs(a) * fabs(a) * 1e-11);
else if (fabs(a) > 1.0)
LOLUNIT_ASSERT_DOUBLES_EQUAL(a, b, fabs(a) * 1e-11);
lolunit_assert_doubles_equal(a, b, fabs(a) * 1e-11);
else
LOLUNIT_ASSERT_DOUBLES_EQUAL(a, b, fabs(f) * 1e-11);
lolunit_assert_doubles_equal(a, b, fabs(f) * 1e-11);
}
}
};


+ 138
- 138
src/t/math/vector.cpp View File

@@ -18,40 +18,40 @@
namespace lol
{

LOLUNIT_FIXTURE(VectorTest)
lolunit_declare_fixture(VectorTest)
{
void SetUp() {}

void TearDown() {}

LOLUNIT_TEST(VectorEquality)
lolunit_declare_test(VectorEquality)
{
vec2 a2(1.0f, 2.0f);
vec2 b2(0.0f, 2.0f);
vec2 c2(1.0f, 0.0f);

LOLUNIT_ASSERT_EQUAL(a2, a2);
LOLUNIT_ASSERT_NOT_DIFFERENT(a2, a2);
lolunit_assert_equal(a2, a2);
lolunit_assert_not_different(a2, a2);

LOLUNIT_ASSERT_DIFFERENT(a2, b2);
LOLUNIT_ASSERT_NOT_EQUAL(a2, b2);
LOLUNIT_ASSERT_DIFFERENT(a2, c2);
LOLUNIT_ASSERT_NOT_EQUAL(a2, c2);
lolunit_assert_different(a2, b2);
lolunit_assert_not_equal(a2, b2);
lolunit_assert_different(a2, c2);
lolunit_assert_not_equal(a2, c2);

vec3 a3(1.0f, 2.0f, 3.0f);
vec3 b3(0.0f, 2.0f, 3.0f);
vec3 c3(1.0f, 0.0f, 3.0f);
vec3 d3(1.0f, 2.0f, 0.0f);

LOLUNIT_ASSERT_EQUAL(a3, a3);
LOLUNIT_ASSERT_NOT_DIFFERENT(a3, a3);
lolunit_assert_equal(a3, a3);
lolunit_assert_not_different(a3, a3);

LOLUNIT_ASSERT_DIFFERENT(a3, b3);
LOLUNIT_ASSERT_NOT_EQUAL(a3, b3);
LOLUNIT_ASSERT_DIFFERENT(a3, c3);
LOLUNIT_ASSERT_NOT_EQUAL(a3, c3);
LOLUNIT_ASSERT_DIFFERENT(a3, d3);
LOLUNIT_ASSERT_NOT_EQUAL(a3, d3);
lolunit_assert_different(a3, b3);
lolunit_assert_not_equal(a3, b3);
lolunit_assert_different(a3, c3);
lolunit_assert_not_equal(a3, c3);
lolunit_assert_different(a3, d3);
lolunit_assert_not_equal(a3, d3);

vec4 a4(1.0f, 2.0f, 3.0f, 4.0f);
vec4 b4(0.0f, 2.0f, 3.0f, 4.0f);
@@ -59,20 +59,20 @@ LOLUNIT_FIXTURE(VectorTest)
vec4 d4(1.0f, 2.0f, 0.0f, 4.0f);
vec4 e4(1.0f, 2.0f, 3.0f, 0.0f);

LOLUNIT_ASSERT_EQUAL(a4, a4);
LOLUNIT_ASSERT_NOT_DIFFERENT(a4, a4);
LOLUNIT_ASSERT_DIFFERENT(a4, b4);
LOLUNIT_ASSERT_NOT_EQUAL(a4, b4);
LOLUNIT_ASSERT_DIFFERENT(a4, c4);
LOLUNIT_ASSERT_NOT_EQUAL(a4, c4);
LOLUNIT_ASSERT_DIFFERENT(a4, d4);
LOLUNIT_ASSERT_NOT_EQUAL(a4, d4);
LOLUNIT_ASSERT_DIFFERENT(a4, e4);
LOLUNIT_ASSERT_NOT_EQUAL(a4, e4);
lolunit_assert_equal(a4, a4);
lolunit_assert_not_different(a4, a4);
lolunit_assert_different(a4, b4);
lolunit_assert_not_equal(a4, b4);
lolunit_assert_different(a4, c4);
lolunit_assert_not_equal(a4, c4);
lolunit_assert_different(a4, d4);
lolunit_assert_not_equal(a4, d4);
lolunit_assert_different(a4, e4);
lolunit_assert_not_equal(a4, e4);
}

LOLUNIT_TEST(VectorInequality)
lolunit_declare_test(VectorInequality)
{
vec2 a2(1.0f, 3.0f);
vec2 b2(0.0f, 0.0f);
@@ -81,52 +81,52 @@ LOLUNIT_FIXTURE(VectorTest)
vec2 e2(3.0f, 3.0f);
vec2 f2(4.0f, 4.0f);

LOLUNIT_ASSERT_LEQUAL(a2, a2);
LOLUNIT_ASSERT_NOT_LESS(a2, a2);
LOLUNIT_ASSERT_NOT_LEQUAL(a2, b2);
LOLUNIT_ASSERT_NOT_LESS(a2, b2);
LOLUNIT_ASSERT_NOT_LEQUAL(a2, c2);
LOLUNIT_ASSERT_NOT_LESS(a2, c2);
LOLUNIT_ASSERT_NOT_LEQUAL(a2, d2);
LOLUNIT_ASSERT_NOT_LESS(a2, d2);
LOLUNIT_ASSERT_LEQUAL(a2, e2);
LOLUNIT_ASSERT_NOT_LESS(a2, e2);
LOLUNIT_ASSERT_LEQUAL(a2, f2);
LOLUNIT_ASSERT_LESS(a2, f2);
lolunit_assert_lequal(a2, a2);
lolunit_assert_not_less(a2, a2);
lolunit_assert_not_lequal(a2, b2);
lolunit_assert_not_less(a2, b2);
lolunit_assert_not_lequal(a2, c2);
lolunit_assert_not_less(a2, c2);
lolunit_assert_not_lequal(a2, d2);
lolunit_assert_not_less(a2, d2);
lolunit_assert_lequal(a2, e2);
lolunit_assert_not_less(a2, e2);
lolunit_assert_lequal(a2, f2);
lolunit_assert_less(a2, f2);
}

LOLUNIT_TEST(VectorInit)
lolunit_declare_test(VectorInit)
{
vec2 a { 1.f, 2.f };
LOLUNIT_ASSERT_EQUAL(1.f, a.x);
LOLUNIT_ASSERT_EQUAL(2.f, a.y);
lolunit_assert_equal(1.f, a.x);
lolunit_assert_equal(2.f, a.y);

vec3 b { 1.f, 2.f, 3.f };
LOLUNIT_ASSERT_EQUAL(1.f, b.x);
LOLUNIT_ASSERT_EQUAL(2.f, b.y);
LOLUNIT_ASSERT_EQUAL(3.f, b.z);
lolunit_assert_equal(1.f, b.x);
lolunit_assert_equal(2.f, b.y);
lolunit_assert_equal(3.f, b.z);

vec4 c { 1.f, 2.f, 3.f, 4.f };
LOLUNIT_ASSERT_EQUAL(1.f, c.x);
LOLUNIT_ASSERT_EQUAL(2.f, c.y);
LOLUNIT_ASSERT_EQUAL(3.f, c.z);
LOLUNIT_ASSERT_EQUAL(4.f, c.w);
lolunit_assert_equal(1.f, c.x);
lolunit_assert_equal(2.f, c.y);
lolunit_assert_equal(3.f, c.z);
lolunit_assert_equal(4.f, c.w);

vec_t<float, 10> d { 1.f, 2.f, 3.f, 4.f, 5.f };
LOLUNIT_ASSERT_EQUAL(1.f, d[0]);
LOLUNIT_ASSERT_EQUAL(2.f, d[1]);
LOLUNIT_ASSERT_EQUAL(3.f, d[2]);
LOLUNIT_ASSERT_EQUAL(4.f, d[3]);
LOLUNIT_ASSERT_EQUAL(5.f, d[4]);
LOLUNIT_ASSERT_EQUAL(0.f, d[5]);
LOLUNIT_ASSERT_EQUAL(0.f, d[6]);
LOLUNIT_ASSERT_EQUAL(0.f, d[7]);
LOLUNIT_ASSERT_EQUAL(0.f, d[8]);
LOLUNIT_ASSERT_EQUAL(0.f, d[9]);
lolunit_assert_equal(1.f, d[0]);
lolunit_assert_equal(2.f, d[1]);
lolunit_assert_equal(3.f, d[2]);
lolunit_assert_equal(4.f, d[3]);
lolunit_assert_equal(5.f, d[4]);
lolunit_assert_equal(0.f, d[5]);
lolunit_assert_equal(0.f, d[6]);
lolunit_assert_equal(0.f, d[7]);
lolunit_assert_equal(0.f, d[8]);
lolunit_assert_equal(0.f, d[9]);
}

LOLUNIT_TEST(VectorSwizzle)
lolunit_declare_test(VectorSwizzle)
{
vec3 a(1.0f, 2.0f, 3.0f);
vec3 b(4.0f, 5.0f, 6.0f);
@@ -134,134 +134,134 @@ LOLUNIT_FIXTURE(VectorTest)

c = a;
c.x = b.y;
LOLUNIT_ASSERT_EQUAL(c.x, 5.0f);
LOLUNIT_ASSERT_EQUAL(c.y, 2.0f);
LOLUNIT_ASSERT_EQUAL(c.z, 3.0f);
lolunit_assert_equal(c.x, 5.0f);
lolunit_assert_equal(c.y, 2.0f);
lolunit_assert_equal(c.z, 3.0f);

c = a.zyx;
LOLUNIT_ASSERT_EQUAL(c.x, 3.0f);
LOLUNIT_ASSERT_EQUAL(c.y, 2.0f);
LOLUNIT_ASSERT_EQUAL(c.z, 1.0f);
lolunit_assert_equal(c.x, 3.0f);
lolunit_assert_equal(c.y, 2.0f);
lolunit_assert_equal(c.z, 1.0f);

#if 0 /* Visual Studio doesn't support these yet. */
c = a;
c.xy = b.yz;
LOLUNIT_ASSERT_EQUAL(c.x, 5.0f);
LOLUNIT_ASSERT_EQUAL(c.y, 6.0f);
LOLUNIT_ASSERT_EQUAL(c.z, 3.0f);
lolunit_assert_equal(c.x, 5.0f);
lolunit_assert_equal(c.y, 6.0f);
lolunit_assert_equal(c.z, 3.0f);

c = a;
c.xy = b.zz;
LOLUNIT_ASSERT_EQUAL(c.x, 6.0f);
LOLUNIT_ASSERT_EQUAL(c.y, 6.0f);
LOLUNIT_ASSERT_EQUAL(c.z, 3.0f);
lolunit_assert_equal(c.x, 6.0f);
lolunit_assert_equal(c.y, 6.0f);
lolunit_assert_equal(c.z, 3.0f);

c = a;
c.xz = b.xy;
LOLUNIT_ASSERT_EQUAL(c.x, 4.0f);
LOLUNIT_ASSERT_EQUAL(c.y, 2.0f);
LOLUNIT_ASSERT_EQUAL(c.z, 5.0f);
lolunit_assert_equal(c.x, 4.0f);
lolunit_assert_equal(c.y, 2.0f);
lolunit_assert_equal(c.z, 5.0f);

c = a;
c.xz = b.xz;
LOLUNIT_ASSERT_EQUAL(c.x, 4.0f);
LOLUNIT_ASSERT_EQUAL(c.y, 2.0f);
LOLUNIT_ASSERT_EQUAL(c.z, 6.0f);
lolunit_assert_equal(c.x, 4.0f);
lolunit_assert_equal(c.y, 2.0f);
lolunit_assert_equal(c.z, 6.0f);

c = a;
c.xz = c.zy = b.yx;
LOLUNIT_ASSERT_EQUAL(c.x, 5.0f);
LOLUNIT_ASSERT_EQUAL(c.y, 4.0f);
LOLUNIT_ASSERT_EQUAL(c.z, 4.0f);
lolunit_assert_equal(c.x, 5.0f);
lolunit_assert_equal(c.y, 4.0f);
lolunit_assert_equal(c.z, 4.0f);
#endif
}

LOLUNIT_TEST(VectorSwizzleMul)
lolunit_declare_test(VectorSwizzleMul)
{
ivec3 a(1, 2, 3);

ivec3 b = a * 2;
LOLUNIT_ASSERT_EQUAL(b.x, 2);
LOLUNIT_ASSERT_EQUAL(b.y, 4);
LOLUNIT_ASSERT_EQUAL(b.z, 6);
lolunit_assert_equal(b.x, 2);
lolunit_assert_equal(b.y, 4);
lolunit_assert_equal(b.z, 6);

ivec3 c = (ivec3)a.zyx * 2;
LOLUNIT_ASSERT_EQUAL(c.x, 6);
LOLUNIT_ASSERT_EQUAL(c.y, 4);
LOLUNIT_ASSERT_EQUAL(c.z, 2);
lolunit_assert_equal(c.x, 6);
lolunit_assert_equal(c.y, 4);
lolunit_assert_equal(c.z, 2);

ivec3 d = 2 * (ivec3)a.zyx;
LOLUNIT_ASSERT_EQUAL(d.x, 6);
LOLUNIT_ASSERT_EQUAL(d.y, 4);
LOLUNIT_ASSERT_EQUAL(d.z, 2);
lolunit_assert_equal(d.x, 6);
lolunit_assert_equal(d.y, 4);
lolunit_assert_equal(d.z, 2);

ivec3 e = a.zyx * 2;
LOLUNIT_ASSERT_EQUAL(e.x, 6);
LOLUNIT_ASSERT_EQUAL(e.y, 4);
LOLUNIT_ASSERT_EQUAL(e.z, 2);
lolunit_assert_equal(e.x, 6);
lolunit_assert_equal(e.y, 4);
lolunit_assert_equal(e.z, 2);

ivec3 f = 2 * a.zyx;
LOLUNIT_ASSERT_EQUAL(f.x, 6);
LOLUNIT_ASSERT_EQUAL(f.y, 4);
LOLUNIT_ASSERT_EQUAL(f.z, 2);
lolunit_assert_equal(f.x, 6);
lolunit_assert_equal(f.y, 4);
lolunit_assert_equal(f.z, 2);
}

LOLUNIT_TEST(VectorUnaryMinus)
lolunit_declare_test(VectorUnaryMinus)
{
vec2 a(1.0f, 3.0f);
vec2 b(-1.0f, -3.0f);

LOLUNIT_ASSERT_EQUAL(a, -b);
LOLUNIT_ASSERT_EQUAL(-a, b);
lolunit_assert_equal(a, -b);
lolunit_assert_equal(-a, b);
}

LOLUNIT_TEST(CastVector)
lolunit_declare_test(CastVector)
{
vec2 a1(1.0f, 3.0f);

vec3 b(a1, 0.0f);
vec2 a2(b.xy);
LOLUNIT_ASSERT_EQUAL(b.x, a1.x);
LOLUNIT_ASSERT_EQUAL(b.y, a1.y);
LOLUNIT_ASSERT_EQUAL(b.z, 0.0f);
LOLUNIT_ASSERT_EQUAL(a2, a1);
lolunit_assert_equal(b.x, a1.x);
lolunit_assert_equal(b.y, a1.y);
lolunit_assert_equal(b.z, 0.0f);
lolunit_assert_equal(a2, a1);

vec4 c(a1, 0.0f, 0.0f);
vec2 a3(c.xy);
LOLUNIT_ASSERT_EQUAL(c.x, a1.x);
LOLUNIT_ASSERT_EQUAL(c.y, a1.y);
LOLUNIT_ASSERT_EQUAL(c.z, 0.0f);
LOLUNIT_ASSERT_EQUAL(c.w, 0.0f);
LOLUNIT_ASSERT_EQUAL(a3, a1);
lolunit_assert_equal(c.x, a1.x);
lolunit_assert_equal(c.y, a1.y);
lolunit_assert_equal(c.z, 0.0f);
lolunit_assert_equal(c.w, 0.0f);
lolunit_assert_equal(a3, a1);
}

LOLUNIT_TEST(Orthogonal)
lolunit_declare_test(Orthogonal)
{
vec3 a(1.f, 0.f, 0.f);
vec3 b(0.f, 1.f, 0.f);
vec3 c(0.f, 0.f, 1.f);

LOLUNIT_ASSERT_DOUBLES_EQUAL(dot(orthogonal(a), a), 0.f, 1e-6f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(dot(orthogonal(b), b), 0.f, 1e-6f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(dot(orthogonal(c), c), 0.f, 1e-6f);
lolunit_assert_doubles_equal(dot(orthogonal(a), a), 0.f, 1e-6f);
lolunit_assert_doubles_equal(dot(orthogonal(b), b), 0.f, 1e-6f);
lolunit_assert_doubles_equal(dot(orthogonal(c), c), 0.f, 1e-6f);

/* The length of the orthogonal vector should be at least
* sqrt(2)/2 times the length of the original vector. */
LOLUNIT_ASSERT_GREATER(length(orthogonal(a)), 0.7f);
LOLUNIT_ASSERT_GREATER(length(orthogonal(b)), 0.7f);
LOLUNIT_ASSERT_GREATER(length(orthogonal(c)), 0.7f);
lolunit_assert_greater(length(orthogonal(a)), 0.7f);
lolunit_assert_greater(length(orthogonal(b)), 0.7f);
lolunit_assert_greater(length(orthogonal(c)), 0.7f);

LOLUNIT_ASSERT_DOUBLES_EQUAL(dot(orthonormal(a), a), 0.f, 1e-6f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(dot(orthonormal(b), b), 0.f, 1e-6f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(dot(orthonormal(c), c), 0.f, 1e-6f);
lolunit_assert_doubles_equal(dot(orthonormal(a), a), 0.f, 1e-6f);
lolunit_assert_doubles_equal(dot(orthonormal(b), b), 0.f, 1e-6f);
lolunit_assert_doubles_equal(dot(orthonormal(c), c), 0.f, 1e-6f);

/* The length of the orthonormal vector should be 1. */
LOLUNIT_ASSERT_DOUBLES_EQUAL(length(orthonormal(a)), 1.f, 1e-6f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(length(orthonormal(b)), 1.f, 1e-6f);
LOLUNIT_ASSERT_DOUBLES_EQUAL(length(orthonormal(c)), 1.f, 1e-6f);
lolunit_assert_doubles_equal(length(orthonormal(a)), 1.f, 1e-6f);
lolunit_assert_doubles_equal(length(orthonormal(b)), 1.f, 1e-6f);
lolunit_assert_doubles_equal(length(orthonormal(c)), 1.f, 1e-6f);
}

LOLUNIT_TEST(LargeVectors)
lolunit_declare_test(LargeVectors)
{
vec_t<int, 50> v0(0);
vec_t<int, 50> v1(1);
@@ -270,43 +270,43 @@ LOLUNIT_FIXTURE(VectorTest)

auto va = v0 + v3;
auto vb = v1 + v2;
LOLUNIT_ASSERT(va == vb);
lolunit_assert(va == vb);
}

#if !LOL_FEATURE_VISUAL_STUDIO_THAT_FUCKING_PIECE_OF_SHIT_COMPILER
LOLUNIT_TEST(VectorIterator)
lolunit_declare_test(VectorIterator)
{
vec4 v4(1.125f, 1.25f, 1.375f, 1.25f);

for (auto x : v4)
{
LOLUNIT_ASSERT_GREATER(x, 1.0f);
LOLUNIT_ASSERT_LESS(x, 1.5f);
lolunit_assert_greater(x, 1.0f);
lolunit_assert_less(x, 1.5f);
}

for (auto &x : v4)
{
LOLUNIT_ASSERT_GREATER(x, 1.0f);
LOLUNIT_ASSERT_LESS(x, 1.5f);
lolunit_assert_greater(x, 1.0f);
lolunit_assert_less(x, 1.5f);
}

for (auto x : v4.zywx)
{
LOLUNIT_ASSERT_GREATER(x, 1.0f);
LOLUNIT_ASSERT_LESS(x, 1.5f);
lolunit_assert_greater(x, 1.0f);
lolunit_assert_less(x, 1.5f);
}

vec4 const &v4c = v4;
for (auto x : v4c)
{
LOLUNIT_ASSERT_GREATER(x, 1.0f);
LOLUNIT_ASSERT_LESS(x, 1.5f);
lolunit_assert_greater(x, 1.0f);
lolunit_assert_less(x, 1.5f);
}

for (auto &x : v4c)
{
LOLUNIT_ASSERT_GREATER(x, 1.0f);
LOLUNIT_ASSERT_LESS(x, 1.5f);
lolunit_assert_greater(x, 1.0f);
lolunit_assert_less(x, 1.5f);
}
}
#endif


+ 9
- 9
src/t/sys/thread.cpp View File

@@ -18,24 +18,24 @@
namespace lol
{

LOLUNIT_FIXTURE(ThreadTest)
lolunit_declare_fixture(ThreadTest)
{
void SetUp() {}

void TearDown() {}

LOLUNIT_TEST(QueueTryPush)
lolunit_declare_test(QueueTryPush)
{
Queue<int, 1> q;

bool b1 = q.TryPush(0);
LOLUNIT_ASSERT_EQUAL(true, b1);
lolunit_assert_equal(true, b1);

bool b2 = q.TryPush(1);
LOLUNIT_ASSERT_EQUAL(false, b2);
lolunit_assert_equal(false, b2);
}

LOLUNIT_TEST(QueueTryPop)
lolunit_declare_test(QueueTryPop)
{
Queue<int, 1> q;
int tmp;
@@ -43,12 +43,12 @@ LOLUNIT_FIXTURE(ThreadTest)
q.Push(42);

bool b1 = q.TryPop(tmp);
LOLUNIT_ASSERT_EQUAL(true, b1);
LOLUNIT_ASSERT_EQUAL(42, tmp);
lolunit_assert_equal(true, b1);
lolunit_assert_equal(42, tmp);

bool b2 = q.TryPop(tmp);
LOLUNIT_ASSERT_EQUAL(false, b2);
LOLUNIT_ASSERT_EQUAL(42, tmp);
lolunit_assert_equal(false, b2);
lolunit_assert_equal(42, tmp);
}
};



+ 105
- 102
tools/lolunit/lolunit.h View File

@@ -26,7 +26,7 @@ namespace lol

/*
* This is the base class for all fixtures. It keeps track of all
* fixtures registered through the LOLUNIT_FIXTURE macro and puts them
* fixtures registered through the lolunit_declare_fixture macro and puts them
* in a linked list.
*/
class FixtureBase
@@ -81,7 +81,7 @@ private:

/*
* This template specialises FixtureBase and provides registration of
* test cases in a linked list through the LOLUNIT_TEST macro.
* test cases in a linked list through the lolunit_declare_test macro.
*/
template<class T> class Fixture : protected FixtureBase
{
@@ -93,9 +93,15 @@ public:
void (FixtureClass::* m_fun)();
char const *m_testname;
TestCase *m_next;

protected:
static inline std::string make_msg(std::string const str)
{
return "- " + str + "\n";
}
};

Fixture<T>()
Fixture()
{
AddFixture(this);
}
@@ -198,61 +204,61 @@ public:
testcases += f->m_testcases;
failcases += f->m_failcases;
}
std::cout << std::endl;
std::cout << "\n";

std::cout << std::endl << std::endl;
std::cout << "\n\n";
if (failcases)
{
std::cout << "!!!FAILURES!!!" << std::endl;
std::cout << "Test Results:" << std::endl;
std::cout << "!!!FAILURES!!!\n";
std::cout << "Test Results:\n";
std::cout << "Run: " << testcases
<< " Failures: " << failcases
<< " Errors: 0" << std::endl; /* TODO: handle errors */
<< " Errors: 0\n"; /* TODO: handle errors */

std::cout << errors.str();
ret = false;
}
else
{
std::cout << "OK (" << testcases << " tests)" << std::endl;
std::cout << "OK (" << testcases << " tests)\n";
}
std::cout << std::endl << std::endl;
std::cout << "\n\n";

return ret;
}
};

#define LOLUNIT_ASSERT_GENERIC(msg, cond) \
#define lolunit_assert_generic(msg, cond) \
do { \
m_asserts++; \
if (True() && !(cond)) \
{ \
m_errorlog << std::endl << std::endl; \
m_errorlog << "\n\n"; \
m_errorlog << ++m_failcases << ") test: " \
<< lol_unit_helper_name(this) << "::" << m_currentname \
<< " (F) line: " << __LINE__ << " " \
<< __FILE__ << std::endl; \
m_errorlog << "assertion failed" << std::endl; \
m_errorlog << "- Expression: " << #cond << std::endl; \
<< __FILE__ << "\n"; \
m_errorlog << "assertion failed\n"; \
m_errorlog << "- Expression: " << #cond << "\n"; \
m_errorlog << msg; \
m_failure = true; \
return; \
} \
} while (!True())

#define LOLUNIT_ASSERT_OP(op, modifier, opdesc, msg, a, b) \
#define lolunit_assert_op(op, modifier, opdesc, msg, a, b) \
do { \
m_asserts++; \
if (True() && !modifier((a) op (b))) \
{ \
m_errorlog << std::endl << std::endl; \
m_errorlog << "\n\n"; \
m_errorlog << ++m_failcases << ") test: " \
<< lol_unit_helper_name(this) << "::" << m_currentname \
<< " (F) line: " << __LINE__ << " " \
<< __FILE__ << std::endl; \
m_errorlog << opdesc << " assertion failed" << std::endl; \
m_errorlog << "- Expected: " << #a << " = " << (a) << std::endl; \
m_errorlog << "- Actual : " << #b << " = " << (b) << std::endl; \
<< __FILE__ << "\n"; \
m_errorlog << opdesc << " assertion failed\n"; \
m_errorlog << "- Expected: " << #a << " = " << (a) << "\n"; \
m_errorlog << "- Actual : " << #b << " = " << (b) << "\n"; \
m_errorlog << msg; \
m_errorlog << m_context.str(); \
m_failure = true; \
@@ -260,26 +266,23 @@ public:
} \
} while (!True())

#define LOLUNIT_MSG(msg) \
"- " << msg << std::endl

#define LOLUNIT_ASSERT_DOUBLES_EQUAL_GENERIC(msg, a, b, t) \
#define lolunit_assert_doubles_equal_generic(msg, a, b, t) \
do { \
m_asserts++; \
using std::fabs; \
if (True() && fabs((a) - (b)) > fabs((t))) \
{ \
m_errorlog << std::endl << std::endl; \
m_errorlog << "\n\n"; \
m_errorlog << ++m_failcases << ") test: " \
<< lol_unit_helper_name(this) << "::" << m_currentname \
<< " (F) line: " << __LINE__ << " " \
<< __FILE__ << std::endl; \
m_errorlog << "double equality assertion failed" << std::endl; \
<< __FILE__ << "\n"; \
m_errorlog << "double equality assertion failed\n"; \
std::streamsize old_prec = m_errorlog.precision(); \
m_errorlog << std::setprecision(16); \
m_errorlog << "- Expected: " << #a << " = " << (a) << std::endl; \
m_errorlog << "- Actual : " << #b << " = " << (b) << std::endl; \
m_errorlog << "- Delta : " << (t) << std::endl; \
m_errorlog << "- Expected: " << #a << " = " << (a) << "\n"; \
m_errorlog << "- Actual : " << #b << " = " << (b) << "\n"; \
m_errorlog << "- Delta : " << (t) << "\n"; \
m_errorlog << std::setprecision(old_prec); \
m_errorlog << msg; \
m_errorlog << m_context.str(); \
@@ -292,7 +295,7 @@ public:
* Public helper macros
*/

#define LOLUNIT_FIXTURE(N) \
#define lolunit_declare_fixture(N) \
class N; \
/* This pattern allows us to statically create a Fixture instance \
* before its exact implementation was defined. */ \
@@ -313,7 +316,7 @@ public:
/* Now the user can define the implementation */ \
class N : public lol::Fixture<N>

#define LOLUNIT_TEST(N) \
#define lolunit_declare_test(N) \
/* For each test in the fixture, we create an object that will \
* automatically register the test method in a list global to the \
* specialised fixture. */ \
@@ -333,95 +336,95 @@ public:
* Provide context for error messages
*/

#define LOLUNIT_SET_CONTEXT(n) \
#define lolunit_set_context(n) \
do { \
m_context.str(""); \
m_context << "- Context : " << #n << " = " << (n) << std::endl; \
m_context << "- Context : " << #n << " = " << (n) << "\n"; \
} while (!True())

#define LOLUNIT_UNSET_CONTEXT(n) \
#define lolunit_unset_context(n) \
m_context.str("")

/*
* Public assert macros
*/

#define LOLUNIT_FAIL(msg) \
#define lolunit_fail(msg) \
do { \
m_asserts++; \
m_errorlog << std::endl << std::endl; \
m_errorlog << "\n\n"; \
m_errorlog << ++m_failcases << ") test: " \
<< lol_unit_helper_name(this) << "::" << m_currentname \
<< " (F) line: " << __LINE__ << " " \
<< __FILE__ << std::endl; \
m_errorlog << "forced failure" << std::endl; \
m_errorlog << LOLUNIT_MSG(msg); \
<< __FILE__ << "\n"; \
m_errorlog << "forced failure\n"; \
m_errorlog << make_msg(msg); \
m_errorlog << m_context.str(); \
m_failure = true; \
return; \
} while (!True())

#define LOLUNIT_ASSERT(cond) \
LOLUNIT_ASSERT_GENERIC("", cond)
#define LOLUNIT_ASSERT_MESSAGE(m, cond) \
LOLUNIT_ASSERT_GENERIC(LOLUNIT_MSG(m), cond)
#define LOLUNIT_ASSERT_EQUAL(a, b) \
LOLUNIT_ASSERT_OP(==, (bool), "equality", "", a, b)
#define LOLUNIT_ASSERT_EQUAL_MESSAGE(m, a, b) \
LOLUNIT_ASSERT_OP(==, (bool), "equality", LOLUNIT_MSG(m), a, b)
#define LOLUNIT_ASSERT_DIFFERENT(a, b) \
LOLUNIT_ASSERT_OP(!=, (bool), "inequality", "", a, b)
#define LOLUNIT_ASSERT_DIFFERENT_MESSAGE(m, a, b) \
LOLUNIT_ASSERT_OP(!=, (bool), "inequality", LOLUNIT_MSG(m), a, b)
#define LOLUNIT_ASSERT_LESS(a, b) \
LOLUNIT_ASSERT_OP(<, (bool), "less than", "", a, b)
#define LOLUNIT_ASSERT_LESS_MESSAGE(m, a, b) \
LOLUNIT_ASSERT_OP(<, (bool), "less than", LOLUNIT_MSG(m), a, b)
#define LOLUNIT_ASSERT_LEQUAL(a, b) \
LOLUNIT_ASSERT_OP(<=, (bool), "less than or equal", "", a, b)
#define LOLUNIT_ASSERT_LEQUAL_MESSAGE(m, a, b) \
LOLUNIT_ASSERT_OP(<=, (bool), "less than or equal", LOLUNIT_MSG(m), a, b)
#define LOLUNIT_ASSERT_GREATER(a, b) \
LOLUNIT_ASSERT_OP(>, (bool), "greater than", "", a, b)
#define LOLUNIT_ASSERT_GREATER_MESSAGE(m, a, b) \
LOLUNIT_ASSERT_OP(>, (bool), "greater than", LOLUNIT_MSG(m), a, b)
#define LOLUNIT_ASSERT_GEQUAL(a, b) \
LOLUNIT_ASSERT_OP(>=, (bool), "greater than or equal", "", a, b)
#define LOLUNIT_ASSERT_GEQUAL_MESSAGE(m, a, b) \
LOLUNIT_ASSERT_OP(>=, (bool), "greater than or equal", LOLUNIT_MSG(m), a, b)
#define LOLUNIT_ASSERT_NOT_EQUAL(a, b) \
LOLUNIT_ASSERT_OP(==, !, "not equality", "", a, b)
#define LOLUNIT_ASSERT_NOT_EQUAL_MESSAGE(m, a, b) \
LOLUNIT_ASSERT_OP(==, !, "not equality", LOLUNIT_MSG(m), a, b)
#define LOLUNIT_ASSERT_NOT_DIFFERENT(a, b) \
LOLUNIT_ASSERT_OP(!=, !, "not inequality", "", a, b)
#define LOLUNIT_ASSERT_NOT_DIFFERENT_MESSAGE(m, a, b) \
LOLUNIT_ASSERT_OP(!=, !, "not inequality", LOLUNIT_MSG(m), a, b)
#define LOLUNIT_ASSERT_NOT_LESS(a, b) \
LOLUNIT_ASSERT_OP(<, !, "not less than", "", a, b)
#define LOLUNIT_ASSERT_NOT_LESS_MESSAGE(m, a, b) \
LOLUNIT_ASSERT_OP(<, !, "not less than", LOLUNIT_MSG(m), a, b)
#define LOLUNIT_ASSERT_NOT_LEQUAL(a, b) \
LOLUNIT_ASSERT_OP(<=, !, "not less than or equal", "", a, b)
#define LOLUNIT_ASSERT_NOT_LEQUAL_MESSAGE(m, a, b) \
LOLUNIT_ASSERT_OP(<=, !, "not less than or equal", LOLUNIT_MSG(m), a, b)
#define LOLUNIT_ASSERT_NOT_GREATER(a, b) \
LOLUNIT_ASSERT_OP(>, !, "not greater than", "", a, b)
#define LOLUNIT_ASSERT_NOT_GREATER_MESSAGE(m, a, b) \
LOLUNIT_ASSERT_OP(>, !, "not greater than", LOLUNIT_MSG(m), a, b)
#define LOLUNIT_ASSERT_NOT_GEQUAL(a, b) \
LOLUNIT_ASSERT_OP(>=, !, "not greater than or equal", "", a, b)
#define LOLUNIT_ASSERT_NOT_GEQUAL_MESSAGE(m, a, b) \
LOLUNIT_ASSERT_OP(>=, !, "not greater than or equal", LOLUNIT_MSG(m), a, b)
#define LOLUNIT_ASSERT_DOUBLES_EQUAL(a, b, t) \
LOLUNIT_ASSERT_DOUBLES_EQUAL_GENERIC("", a, b, t)
#define LOLUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE(msg, a, b, t) \
LOLUNIT_ASSERT_DOUBLES_EQUAL_GENERIC(LOLUNIT_MSG(msg), a, b, t)
#define lolunit_assert(cond) \
lolunit_assert_generic("", cond)
#define lolunit_assert_message(m, cond) \
lolunit_assert_generic(make_msg(m), cond)
#define lolunit_assert_equal(a, b) \
lolunit_assert_op(==, (bool), "equality", "", a, b)
#define lolunit_assert_equal_message(m, a, b) \
lolunit_assert_op(==, (bool), "equality", make_msg(m), a, b)
#define lolunit_assert_different(a, b) \
lolunit_assert_op(!=, (bool), "inequality", "", a, b)
#define lolunit_assert_different_message(m, a, b) \
lolunit_assert_op(!=, (bool), "inequality", make_msg(m), a, b)
#define lolunit_assert_less(a, b) \
lolunit_assert_op(<, (bool), "less than", "", a, b)
#define lolunit_assert_less_message(m, a, b) \
lolunit_assert_op(<, (bool), "less than", make_msg(m), a, b)
#define lolunit_assert_lequal(a, b) \
lolunit_assert_op(<=, (bool), "less than or equal", "", a, b)
#define lolunit_assert_lequal_message(m, a, b) \
lolunit_assert_op(<=, (bool), "less than or equal", make_msg(m), a, b)
#define lolunit_assert_greater(a, b) \
lolunit_assert_op(>, (bool), "greater than", "", a, b)
#define lolunit_assert_greater_message(m, a, b) \
lolunit_assert_op(>, (bool), "greater than", make_msg(m), a, b)
#define lolunit_assert_gequal(a, b) \
lolunit_assert_op(>=, (bool), "greater than or equal", "", a, b)
#define lolunit_assert_gequal_message(m, a, b) \
lolunit_assert_op(>=, (bool), "greater than or equal", make_msg(m), a, b)
#define lolunit_assert_not_equal(a, b) \
lolunit_assert_op(==, !, "not equality", "", a, b)
#define lolunit_assert_not_equal_message(m, a, b) \
lolunit_assert_op(==, !, "not equality", make_msg(m), a, b)
#define lolunit_assert_not_different(a, b) \
lolunit_assert_op(!=, !, "not inequality", "", a, b)
#define lolunit_assert_not_different_message(m, a, b) \
lolunit_assert_op(!=, !, "not inequality", make_msg(m), a, b)
#define lolunit_assert_not_less(a, b) \
lolunit_assert_op(<, !, "not less than", "", a, b)
#define lolunit_assert_not_less_message(m, a, b) \
lolunit_assert_op(<, !, "not less than", make_msg(m), a, b)
#define lolunit_assert_not_lequal(a, b) \
lolunit_assert_op(<=, !, "not less than or equal", "", a, b)
#define lolunit_assert_not_lequal_message(m, a, b) \
lolunit_assert_op(<=, !, "not less than or equal", make_msg(m), a, b)
#define lolunit_assert_not_greater(a, b) \
lolunit_assert_op(>, !, "not greater than", "", a, b)
#define lolunit_assert_not_greater_message(m, a, b) \
lolunit_assert_op(>, !, "not greater than", make_msg(m), a, b)
#define lolunit_assert_not_gequal(a, b) \
lolunit_assert_op(>=, !, "not greater than or equal", "", a, b)
#define lolunit_assert_not_gequal_message(m, a, b) \
lolunit_assert_op(>=, !, "not greater than or equal", make_msg(m), a, b)
#define lolunit_assert_doubles_equal(a, b, t) \
lolunit_assert_doubles_equal_generic("", a, b, t)
#define lolunit_assert_doubles_equal_message(msg, a, b, t) \
lolunit_assert_doubles_equal_generic(make_msg(msg), a, b, t)

} /* namespace lol */



+ 5
- 0
tools/vimlol/vimlol.vim View File

@@ -46,6 +46,11 @@ au Syntax cpp
\ syn match cConstant
\ "\<\(F\|D\|LD\)_\(PI\|PI_[234]\|[12]_PI\|SQRT_[23]\|SQRT_1_2\)\>"

" Unit testing
au Syntax cpp
\ syn match cOperator
\ "\<lolunit_\(fail\|assert\)[a-z_]*\>"

" Global keywords
au Syntax cpp
\ syn keyword cConstant


Write Preview
Loading…
Cancel
Save