void TestLocRotScaleLevel1(Transform& parent, Transform& child) {
Transform p = parent;
// Location
child.set_local_pos(RandomVec());
CheckPos(parent, child, "Translation effect on child");
AssertEquals(parent, p, "Child's translation has no effect parent");
// Rotation
parent.set_rot(RandomQuat());
CheckPos(parent, child, "Rotation effect on child");
AssertEquals(parent.pos(), p.pos(), "Rotation invariant on local_pos");
p = parent;
child.set_rot(parent.rot());
AssertEquals(parent, p, "Child's rotation has no effect parent");
// Scale
parent.set_local_scale(RandomVec());
CheckPos(parent, child, "Scale effect on child's position");
AssertEquals(parent.pos(), p.pos(), "Scale invariant on local_pos");
p = parent;
child.set_scale(parent.scale());
AssertEquals(parent, p, "Child's scaling has no effect parent");
}
/**
* Test removing
*/
void TestVector::TestRemove()
{
// Test insertion on simple data
Vector<int> v1;
for(int i = 0; i < 3; ++i)
{
v1.PushBack(i);
}
// Validate data
AssertEquals(3u, v1.Size());
AssertEquals(4u, v1.Capacity());
for(int i = 0; i < 3; ++i)
{
AssertEquals(i, v1[i]);
}
// Remove data
for(int i = 0; i < 3; ++i)
{
v1.PopBack();
}
AssertEquals(0u, v1.Size());
AssertEquals(4u, v1.Capacity());
}
void TestParentChild(Transform& parent,
Transform& child,
Transform& grand_child) {
AssertEquals(&parent, child.getParent(), "Setting up parent relation");
AssertEquals(&child, parent.getChildren()[0], "Setting up child relation");
AssertEquals(parent.pos(), child.pos(), "Location inheriting");
AssertEquals(child.pos(), grand_child.pos(), "Two levels Location inheriting");
}
static void TestScale() {
Vector2i a(2,4);
AssertEquals(2*a,Vector2i(4,8));
Vector2i b(2,4);
b *= 2;
AssertEquals(b,Vector2i(4,8));
}
virtual void unpack(const std::vector<uint8_t>& bytes)
{
int32_t unpackedInt;
uint32_t unpackedUint;
float unpackedFloat;
unpack_int32(&(bytes[0]), unpackedInt);
unpack_uint32(&(bytes[4]), unpackedUint);
unpack_float32(&(bytes[8]), unpackedFloat);
AssertEquals(testInt, unpackedInt);
AssertEquals(testUint, unpackedUint);
AssertEquals(testFloat, unpackedFloat);
}
static void TestPlusEquals() {
Vector2i a(2,4);
a += Vector2i(4,6);
AssertEquals(a,Vector2i(6,10));
}
static void TestMinusEquals() {
Vector2i a(2,4);
a -= Vector2i(4,7);
AssertEquals(a,Vector2i(-2,-3));
}
/**
* Test insertion
*/
void TestVector::TestInsertion()
{
// Test insertion on simple data
Vector<int> v1;
for(int i = 0; i < 3; ++i)
{
v1.PushBack(i);
}
AssertEquals(3u, v1.Size());
AssertEquals(4u, v1.Capacity());
for(int i = 0; i < 3; ++i)
{
AssertEquals(i, v1[i]);
}
// TODO: Add case for simple class
}
static void TestEquals() {
Vector2i a(1,1);
Vector2i b(1,1);
Vector2i c(2,1);
Vector2i d(1,2);
AssertEquals(a,b);
AssertNotEquals(a,c);
AssertNotEquals(a,d);
}
void DirectionTest() {
Transform t;
AssertEquals(t.forward(), glm::dvec3(0, 0, -1), "Forward");
AssertEquals(t.up(), glm::dvec3(0, 1, 0), "Up");
AssertEquals(t.right(), glm::dvec3(1, 0, 0), "Right");
t.set_rot(glm::quat_cast(glm::rotate(glm::dmat4(), M_PI_2, glm::dvec3(1, 0, 0))));
AssertEquals(t.forward(), glm::dvec3(0, 1, 0), "Forward");
AssertEquals(t.up(), glm::dvec3(0, 0, 1), "Up");
AssertEquals(t.right(), glm::dvec3(1, 0, 0), "Right");
for (int i = 0; i < 1000; ++i) {
t.set_rot(RandomQuat());
AssertEquals(glm::dot(t.forward(), t.right()), 0.0, "Forward and right should be ortho");
AssertEquals(glm::dot(t.forward(), t.up()), 0.0, "Forward and up should be ortho");
AssertEquals(glm::dot(t.right(), t.up()), 0.0, "Right and up should be ortho");
}
}
void GlobalSettings(Transform& t) {
glm::dvec3 v{RandomVec()}, u{RandomVec()};
glm::dquat q{RandomQuat()};
int pnum = GetParentsNum(&t);
std::string prnts = " on a transform with " + std::to_string(pnum) + " parents";
t.set_pos(v);
AssertEquals(t.pos(), v, "Setting global position" + prnts);
t.set_rot(q);
AssertEquals(t.rot(), q, "Setting global rotation" + prnts);
t.set_scale(v);
AssertEquals(t.scale(), v, "Setting global scaling" + prnts);
v = RandomVec();
t.set_forward(v);
AssertEquals(t.forward(), glm::normalize(v), "Setting global forward" + prnts);
v = RandomVec();
t.set_right(v);
AssertEquals(t.right(), glm::normalize(v), "Setting global right" + prnts);
v = RandomVec();
t.set_up(v);
AssertEquals(t.up(), glm::normalize(v), "Setting global up" + prnts);
for (int i = 0; i < 1000; ++i) {
t.set_rot(v = glm::normalize(RandomVec()), u = glm::normalize(RandomVec()));
AssertEquals(t.rot()*v, u, "Setting rot with 'v', 'u'" + prnts);
}
// There are special cases for rot
t.set_rot(v, v);
AssertEquals(t.rot()*v, v, "Setting rot with 'v', 'v'" + prnts);
t.set_rot(v, -v);
AssertEquals(t.rot()*v, -v, "Setting rot with 'v', '-v'" + prnts);
}
static void TestNegation() {
Vector2i v(-1,2);
Vector2i expected(1,-2);
AssertEquals(-v,expected);
}
static void TestSub() {
Vector2i a(7,2);
Vector2i b(-2,2);
AssertEquals(a-b,Vector2i(9,0));
}
void AssertEquals(const Transform& a, const Transform& b, const std::string& msg) {
AssertEquals(a.getParent(), b.getParent(), msg);
AssertEquals(a.local_pos(), b.local_pos(), msg);
AssertEquals(a.local_rot(), b.local_rot(), msg);
AssertEquals(a.local_scale(), b.local_scale(), msg);
}
/**
* Test constructing and destructing a vector
*/
void TestVector::TestConstructor()
{
// Plain Old Data
//---------------
// Default constructor
Vector<int> v1;
AssertEquals(0u, v1.Size());
// Fill constructor
Vector<int> v2(3u);
AssertEquals(3u, v2.Size());
AssertEquals(3u, v2.Capacity());
for(uint i = 0; i < 3; ++i)
{
AssertEquals(0, v2[i]);
}
// Fill constructor with value
Vector<int> v3(3u, 3);
AssertEquals(3u, v3.Size());
AssertEquals(3u, v3.Capacity());
for(uint i = 0; i < 3; ++i)
{
AssertEquals(3, v3[i]);
}
// Copy constructor
Vector<int> v4(v3);
AssertEquals(3u, v4.Size());
AssertEquals(3u, v4.Capacity());
for(uint i = 0; i < 3; ++i)
{
AssertEquals(3, v4[i]);
}
// Assignment
Vector<int> v5 = v4;
AssertEquals(3u, v5.Size());
AssertEquals(3u, v5.Capacity());
for(uint i = 0; i < 3; ++i)
{
AssertEquals(3, v5[i]);
}
// Class
//------
// Default simple object
SimpleClass c1 = SimpleClass();
SimpleClass c2 = SimpleClass(1, 2);
// Default constructor
Vector<SimpleClass> v6;
AssertEquals(0u, v6.Size());
// Fill constructor
Vector<SimpleClass> v7(3u);
AssertEquals(3u, v7.Size());
AssertEquals(3u, v7.Capacity());
for(uint i = 0; i < 3; ++i)
{
AssertEquals(c1, v7[i]);
}
// Fill constructor with value
Vector<SimpleClass> v8(3u, c2);
AssertEquals(3u, v8.Size());
AssertEquals(3u, v8.Capacity());
for(uint i = 0; i < 3; ++i)
{
AssertEquals(c2, v8[i]);
}
// Copy constructor
Vector<SimpleClass> v9(v8);
AssertEquals(3u, v9.Size());
AssertEquals(3u, v9.Capacity());
for(uint i = 0; i < 3; ++i)
{
AssertEquals(c2, v9[i]);
}
// Assignment
Vector<SimpleClass> v10 = v9;
AssertEquals(3u, v10.Size());
AssertEquals(3u, v10.Capacity());
for(uint i = 0; i < 3; ++i)
{
AssertEquals(c2, v10[i]);
}
}
void CheckPos(Transform& parent, Transform& child, const std::string& msg) {
AssertEquals(
child.pos(), parent.pos() + parent.rotateAndScale() * child.local_pos(), msg
);
}
static void TestAdd() {
Vector2i a(1,3);
Vector2i b(-1,2);
AssertEquals(a+b, Vector2i(0,5));
}
static void TestDict(DictPtr dict) {
Optional<DictEntry> entry;
entry = dict->MatchPrefix("BYVoid");
AssertTrue(!entry.IsNull());
AssertEquals("BYVoid", entry.Get().key);
AssertEquals("byv", entry.Get().GetDefault());
entry = dict->MatchPrefix("BYVoid123");
AssertTrue(!entry.IsNull());
AssertEquals("BYVoid", entry.Get().key);
AssertEquals("byv", entry.Get().GetDefault());
entry = dict->MatchPrefix(utf8("積羽沉舟"));
AssertTrue(!entry.IsNull());
AssertEquals(utf8("積羽沉舟"), entry.Get().key);
AssertEquals(utf8("羣輕折軸"), entry.Get().GetDefault());
entry = dict->MatchPrefix("Unknown");
AssertTrue(entry.IsNull());
const vector<DictEntry> matches = dict->MatchAllPrefixes(utf8("清華大學計算機系"));
AssertEquals(3, matches.size());
AssertEquals(utf8("清華大學"), matches.at(0).key);
AssertEquals("TsinghuaUniversity", matches.at(0).GetDefault());
AssertEquals(utf8("清華"), matches.at(1).key);
AssertEquals("Tsinghua", matches.at(1).GetDefault());
AssertEquals(utf8("清"), matches.at(2).key);
AssertEquals("Tsing", matches.at(2).GetDefault());
}
