test/math/QuaternionTestCase.cpp

#include "math/QuaternionTestCase.hpp"

// Registers the fixture into the 'registry'
CPPUNIT_TEST_SUITE_REGISTRATION( QuaternionTestCase );


void QuaternionTestCase::setUp(){
    q1[0] = 1.0;
    q1[1] = 0.0;
    q1[2] = 0.0;
    q1[3] = 0.0;

    q2[0] = 0.0;
    q2[1] = 0.6;
    q2[2] = 0.0;
    q2[3] = 0.8;

    q3[0] = 0.5;
    q3[1] = 0.5;
    q3[2] = 0.5;
    q3[3] = 0.5;

    q4[0] = 0.0;
    q4[1] = -0.6;
    q4[2] = 0.0;
    q4[3] = -0.8;
        
}

void QuaternionTestCase::testConstructors(){
    Vec4 v;
    v[0] = 0.0;
    v[1] = 0.6;
    v[2] = 0.0;
    v[3] = 0.8;

    //construct from a vector
    Quat4d tmp1(v);

    CPPUNIT_ASSERT(tmp1 == q2);

    //copy constructor
    Quat4d tmp2(q1);
    CPPUNIT_ASSERT(tmp2 == q1);

    //copy assignment
    Quat4d tmp3;
    tmp3 = q4;
    CPPUNIT_ASSERT(tmp3 == q4);

    //construct from w, x, y, z
    Quat4d tmp4(0.0, -0.6, 0.0, -0.8);

    CPPUNIT_ASSERT(tmp4 == q4);
    
}

void QuaternionTestCase::testArithmetic(){
    Quat4d qd3(1, 1, 2, 1);
    Quat4d qd4(1, 1, 1, 2);
    
    //test mul
    Quat4d qda3L = qd3;
    qda3L.mul(2.0);
    CPPUNIT_ASSERT_EQUAL( Quat4d(2,2,4,2) , qda3L );
    
    Quat4d qda5R = 2.0  * qd4;
    qda5R.div(qd4);
    CPPUNIT_ASSERT_EQUAL( Quat4d(2.0, 0.0, 0.0, 0.0) , qda5R );    

}

void QuaternionTestCase::testOperators(){

    Quat4d qd0(1, 1, 1, 1);
    Quat4d qd1(2, 1, 1, 1);
    Quat4d qd2(1, 2, 1, 1);
    Quat4d qd3(1, 1, 2, 1);
    Quat4d qd4(1, 1, 1, 2);


    Quat4d qda2Q = qd2 - qd0;
    Quat4d qda3L = qd3 * 2.0;
    Quat4d qda3R = 2.0 * qd3;
    Quat4d qda3Q = qd3 * qd0;
    Quat4d qda4L = qd4 / 2.0;
    Quat4d qda4R = 2.0 / qd4;
    Quat4d qda4Q = qd4 / qd0;
    Quat4d qda5L = qda4L * 2.0;
    Quat4d qda5R = qda4R * qd4;
    Quat4d qda5Q = qda4Q * qd0;    
    
    CPPUNIT_ASSERT_EQUAL( Quat4d(0,1,0,0) , qda2Q );
    CPPUNIT_ASSERT_EQUAL( Quat4d(2,2,4,2) , qda3L );
    CPPUNIT_ASSERT_EQUAL( Quat4d(2,2,4,2) , qda3R );
    CPPUNIT_ASSERT_EQUAL( Quat4d(-3,3,3,1) , qda3Q );
    CPPUNIT_ASSERT_EQUAL( Quat4d(0.5,0.5,0.5,1) , qda4L );
    //CPPUNIT_ASSERT_EQUAL( 2.0 * qd4.inverse() , qda4R );
    CPPUNIT_ASSERT_EQUAL( Quat4d(1.25,0.25,-0.25,0.25) , qda4Q );
    CPPUNIT_ASSERT_EQUAL( qd4 , qda5L );
    CPPUNIT_ASSERT_EQUAL( Quat4d(2.0, 0.0, 0.0, 0.0) , qda5R );
    CPPUNIT_ASSERT_EQUAL( qd4 , qda5Q );

    Quat4d quat0(1, 1, 1, 1);

    Quat4d quat1a = quat0;
    Quat4d quat1s = quat0;
    Quat4d quat1p = quat0;
    Quat4d quat1d = quat0;
    
    quat1a += 2.0;
    quat1s -= 2.0;
    quat1p *= 2.0;
    quat1d /= 2.0;
    
    CPPUNIT_ASSERT_EQUAL( Quat4d(3,1,1,1) , quat1a );
    CPPUNIT_ASSERT_EQUAL( Quat4d(-1,1,1,1) , quat1s );
    CPPUNIT_ASSERT_EQUAL( Quat4d(2,2,2,2) , quat1p );
    CPPUNIT_ASSERT_EQUAL( Quat4d(0.5,0.5,0.5,0.5) , quat1d );

}

void QuaternionTestCase::testAccessEntries(){
    CPPUNIT_ASSERT_DOUBLES_EQUAL(q1.w(), 1.0, oopse::epsilon);
    CPPUNIT_ASSERT_DOUBLES_EQUAL(q2.x(), 0.6, oopse::epsilon);
    CPPUNIT_ASSERT_DOUBLES_EQUAL(q3.y(), 0.5, oopse::epsilon);
    CPPUNIT_ASSERT_DOUBLES_EQUAL(q4.z(), -0.8, oopse::epsilon);

    Quat4d tmp;

    tmp.w() = 0.0;
    tmp.x() = -0.6;
    tmp.y() = 0.0;
    tmp.z() = -0.8;
    
    CPPUNIT_ASSERT(tmp == q4);


}

void QuaternionTestCase::testOtherMemberFunctions(){        
    //test inverse
    CPPUNIT_ASSERT(q2.inverse() == q4);

    //test conjugate
    CPPUNIT_ASSERT(q2 == q4.conjugate());

    //test toRotationMatrix3
    SquareMatrix<double, 3> rotMat;

    rotMat(0,0) = -0.28;
    rotMat(0,1) =  0;
    rotMat(0,2) =  0.96;

    rotMat(1,0) =  0.0;
    rotMat(1,1) = -1.0;
    rotMat(1,2) =  0.0;

    rotMat(2,0) = 0.96;
    rotMat(2,1) = 0;
    rotMat(2,2) = 0.28;

    CPPUNIT_ASSERT(rotMat == q4.toRotationMatrix3());

}
Revision:	110
Committed:	Tue Oct 19 21:28:55 2004 UTC (20 years, 6 months ago) by tim
File size:	3749 byte(s)
Log Message:	more bugs get fixed at math library
#	User	Rev	Content
1	tim	100	#include "math/QuaternionTestCase.hpp"
2
3			// Registers the fixture into the 'registry'
4			CPPUNIT_TEST_SUITE_REGISTRATION( QuaternionTestCase );
5
6
7			void QuaternionTestCase::setUp(){
8	tim	110	q1[0] = 1.0;
9			q1[1] = 0.0;
10			q1[2] = 0.0;
11			q1[3] = 0.0;
12	tim	100
13	tim	110	q2[0] = 0.0;
14			q2[1] = 0.6;
15			q2[2] = 0.0;
16			q2[3] = 0.8;
17
18			q3[0] = 0.5;
19			q3[1] = 0.5;
20			q3[2] = 0.5;
21			q3[3] = 0.5;
22
23			q4[0] = 0.0;
24			q4[1] = -0.6;
25			q4[2] = 0.0;
26			q4[3] = -0.8;
27
28	tim	100	}
29
30			void QuaternionTestCase::testConstructors(){
31	tim	110	Vec4 v;
32			v[0] = 0.0;
33			v[1] = 0.6;
34			v[2] = 0.0;
35			v[3] = 0.8;
36
37			//construct from a vector
38			Quat4d tmp1(v);
39
40			CPPUNIT_ASSERT(tmp1 == q2);
41
42			//copy constructor
43			Quat4d tmp2(q1);
44			CPPUNIT_ASSERT(tmp2 == q1);
45
46			//copy assignment
47			Quat4d tmp3;
48			tmp3 = q4;
49			CPPUNIT_ASSERT(tmp3 == q4);
50
51			//construct from w, x, y, z
52			Quat4d tmp4(0.0, -0.6, 0.0, -0.8);
53
54			CPPUNIT_ASSERT(tmp4 == q4);
55
56	tim	100	}
57
58			void QuaternionTestCase::testArithmetic(){
59	tim	110	Quat4d qd3(1, 1, 2, 1);
60			Quat4d qd4(1, 1, 1, 2);
61
62			//test mul
63			Quat4d qda3L = qd3;
64			qda3L.mul(2.0);
65			CPPUNIT_ASSERT_EQUAL( Quat4d(2,2,4,2) , qda3L );
66
67			Quat4d qda5R = 2.0 * qd4;
68			qda5R.div(qd4);
69			CPPUNIT_ASSERT_EQUAL( Quat4d(2.0, 0.0, 0.0, 0.0) , qda5R );
70
71	tim	100	}
72
73			void QuaternionTestCase::testOperators(){
74	tim	110
75			Quat4d qd0(1, 1, 1, 1);
76			Quat4d qd1(2, 1, 1, 1);
77			Quat4d qd2(1, 2, 1, 1);
78			Quat4d qd3(1, 1, 2, 1);
79			Quat4d qd4(1, 1, 1, 2);
80
81
82			Quat4d qda2Q = qd2 - qd0;
83			Quat4d qda3L = qd3 * 2.0;
84			Quat4d qda3R = 2.0 * qd3;
85			Quat4d qda3Q = qd3 * qd0;
86			Quat4d qda4L = qd4 / 2.0;
87			Quat4d qda4R = 2.0 / qd4;
88			Quat4d qda4Q = qd4 / qd0;
89			Quat4d qda5L = qda4L * 2.0;
90			Quat4d qda5R = qda4R * qd4;
91			Quat4d qda5Q = qda4Q * qd0;
92
93			CPPUNIT_ASSERT_EQUAL( Quat4d(0,1,0,0) , qda2Q );
94			CPPUNIT_ASSERT_EQUAL( Quat4d(2,2,4,2) , qda3L );
95			CPPUNIT_ASSERT_EQUAL( Quat4d(2,2,4,2) , qda3R );
96			CPPUNIT_ASSERT_EQUAL( Quat4d(-3,3,3,1) , qda3Q );
97			CPPUNIT_ASSERT_EQUAL( Quat4d(0.5,0.5,0.5,1) , qda4L );
98			//CPPUNIT_ASSERT_EQUAL( 2.0 * qd4.inverse() , qda4R );
99			CPPUNIT_ASSERT_EQUAL( Quat4d(1.25,0.25,-0.25,0.25) , qda4Q );
100			CPPUNIT_ASSERT_EQUAL( qd4 , qda5L );
101			CPPUNIT_ASSERT_EQUAL( Quat4d(2.0, 0.0, 0.0, 0.0) , qda5R );
102			CPPUNIT_ASSERT_EQUAL( qd4 , qda5Q );
103
104			Quat4d quat0(1, 1, 1, 1);
105
106			Quat4d quat1a = quat0;
107			Quat4d quat1s = quat0;
108			Quat4d quat1p = quat0;
109			Quat4d quat1d = quat0;
110
111			quat1a += 2.0;
112			quat1s -= 2.0;
113			quat1p *= 2.0;
114			quat1d /= 2.0;
115
116			CPPUNIT_ASSERT_EQUAL( Quat4d(3,1,1,1) , quat1a );
117			CPPUNIT_ASSERT_EQUAL( Quat4d(-1,1,1,1) , quat1s );
118			CPPUNIT_ASSERT_EQUAL( Quat4d(2,2,2,2) , quat1p );
119			CPPUNIT_ASSERT_EQUAL( Quat4d(0.5,0.5,0.5,0.5) , quat1d );
120
121	tim	100	}
122
123			void QuaternionTestCase::testAccessEntries(){
124	tim	110	CPPUNIT_ASSERT_DOUBLES_EQUAL(q1.w(), 1.0, oopse::epsilon);
125			CPPUNIT_ASSERT_DOUBLES_EQUAL(q2.x(), 0.6, oopse::epsilon);
126			CPPUNIT_ASSERT_DOUBLES_EQUAL(q3.y(), 0.5, oopse::epsilon);
127			CPPUNIT_ASSERT_DOUBLES_EQUAL(q4.z(), -0.8, oopse::epsilon);
128
129			Quat4d tmp;
130
131			tmp.w() = 0.0;
132			tmp.x() = -0.6;
133			tmp.y() = 0.0;
134			tmp.z() = -0.8;
135
136			CPPUNIT_ASSERT(tmp == q4);
137
138
139	tim	100	}
140
141	tim	110	void QuaternionTestCase::testOtherMemberFunctions(){
142			//test inverse
143			CPPUNIT_ASSERT(q2.inverse() == q4);
144	tim	100
145	tim	110	//test conjugate
146			CPPUNIT_ASSERT(q2 == q4.conjugate());
147
148			//test toRotationMatrix3
149			SquareMatrix<double, 3> rotMat;
150
151			rotMat(0,0) = -0.28;
152			rotMat(0,1) = 0;
153			rotMat(0,2) = 0.96;
154
155			rotMat(1,0) = 0.0;
156			rotMat(1,1) = -1.0;
157			rotMat(1,2) = 0.0;
158
159			rotMat(2,0) = 0.96;
160			rotMat(2,1) = 0;
161			rotMat(2,2) = 0.28;
162
163			CPPUNIT_ASSERT(rotMat == q4.toRotationMatrix3());
164
165	tim	100	}