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()); }