← Back to branch summary

~stapostol/opentk/develop

« back to all changes in this revision

Viewing changes to Source/OpenTK.Tests/Matrix4Test.cs

  • Committer: Harry
  • Author(s): William Deich
  • Date: 2016-04-21 15:28:37 UTC
  • Revision ID: git-v1:8e3986174efd39be9d5bf75402da090032968be3
NUnit Tests from Manuli and Wcdeich4 (#373)

* NUnit Tests from Manuli and Wcdeich4

Show diffs side-by-side

added added

removed removed

Lines of Context:
Source/OpenTK.Tests/Matrix4Test.cs
 
1
using System;
 
2
using NUnit.Framework;
 
3
using OpenTK;
 
4
 
 
5
namespace OpenTK.Tests
 
6
{
 
7
    [TestFixture]
 
8
    public class Matrix4Test
 
9
    {
 
10
        [Test]
 
11
        public void Matrix4_SixteenValueConstructor()
 
12
        {
 
13
            Matrix4 A = new Matrix4( 0,  1,  2,  3,
 
14
                                     4,  5,  6,  7,
 
15
                                     8,  9, 10, 11,
 
16
                                    12, 13, 14, 15);
 
17
 
 
18
            Assert.AreEqual(0, A.M11);
 
19
            Assert.AreEqual(1, A.M12);
 
20
            Assert.AreEqual(2, A.M13);
 
21
            Assert.AreEqual(3, A.M14);
 
22
 
 
23
            Assert.AreEqual(4, A.M21);
 
24
            Assert.AreEqual(5, A.M22);
 
25
            Assert.AreEqual(6, A.M23);
 
26
            Assert.AreEqual(7, A.M24);
 
27
 
 
28
            Assert.AreEqual(8, A.M31);
 
29
            Assert.AreEqual(9, A.M32);
 
30
            Assert.AreEqual(10, A.M33);
 
31
            Assert.AreEqual(11, A.M34);
 
32
 
 
33
            Assert.AreEqual(12, A.M41);
 
34
            Assert.AreEqual(13, A.M42);
 
35
            Assert.AreEqual(14, A.M43);
 
36
            Assert.AreEqual(15, A.M44);
 
37
        }
 
38
 
 
39
        [Test]
 
40
        public void Matrix4_Matrix3Constructor()
 
41
        {
 
42
            Matrix3 B = new Matrix3( 1, 2, 3,
 
43
                                     4, 5, 6,
 
44
                                     7, 8, 9);
 
45
 
 
46
            Matrix4 A = new Matrix4(B);
 
47
 
 
48
            Assert.AreEqual(B.M11, A.M11);
 
49
            Assert.AreEqual(B.M12, A.M12);
 
50
            Assert.AreEqual(B.M13, A.M13);
 
51
 
 
52
            Assert.AreEqual(B.M21, A.M21);
 
53
            Assert.AreEqual(B.M22, A.M22);
 
54
            Assert.AreEqual(B.M23, A.M23);
 
55
 
 
56
            Assert.AreEqual(B.M31, A.M31);
 
57
            Assert.AreEqual(B.M32, A.M32);
 
58
            Assert.AreEqual(B.M33, A.M33);
 
59
        }
 
60
 
 
61
        [Test]
 
62
        public void Matrix4_FourVector4Constructor()
 
63
        {
 
64
            Vector4 V = new Vector4(1, 2, 3, 4);
 
65
            Vector4 U = new Vector4(5, 6, 7, 8);
 
66
            Vector4 S = new Vector4(9, 10, 11, 12);
 
67
            Vector4 T = new Vector4(13, 14, 15, 16);
 
68
 
 
69
            Matrix4 A = new Matrix4(V, U, S, T);
 
70
 
 
71
            Assert.AreEqual(V.X, A.M11);
 
72
            Assert.AreEqual(V.Y, A.M12);
 
73
            Assert.AreEqual(V.Z, A.M13);
 
74
            Assert.AreEqual(V.W, A.M14);
 
75
 
 
76
            Assert.AreEqual(U.X, A.M21);
 
77
            Assert.AreEqual(U.Y, A.M22);
 
78
            Assert.AreEqual(U.Z, A.M23);
 
79
            Assert.AreEqual(U.W, A.M24);
 
80
 
 
81
            Assert.AreEqual(S.X, A.M31);
 
82
            Assert.AreEqual(S.Y, A.M32);
 
83
            Assert.AreEqual(S.Z, A.M33);
 
84
            Assert.AreEqual(S.W, A.M34);
 
85
 
 
86
            Assert.AreEqual(T.X, A.M41);
 
87
            Assert.AreEqual(T.Y, A.M42);
 
88
            Assert.AreEqual(T.Z, A.M43);
 
89
            Assert.AreEqual(T.W, A.M44);
 
90
 
 
91
        }
 
92
 
 
93
        [Test]
 
94
        public void Matrix4_Equal_operator()
 
95
        {
 
96
            Matrix4 A = new Matrix4( 0,  1,  2,  3,
 
97
                                     4,  5,  6,  7,
 
98
                                     8,  9, 10, 11,
 
99
                                    12, 13, 14, 15);
 
100
 
 
101
            Matrix4 B = new Matrix4( 0,  1,  2,  3,
 
102
                                     4,  5,  6,  7,
 
103
                                     8,  9, 10, 11,
 
104
                                    12, 13, 14, 15);
 
105
 
 
106
            Assert.IsTrue(A == B);
 
107
        }
 
108
 
 
109
        [Test]
 
110
        public void Matrix4_Matrix4TimesMatrix4_operator()
 
111
        {
 
112
            Matrix4 A = new Matrix4( 0,  1,  2,  3,
 
113
                                     4,  5,  6,  7,
 
114
                                     8,  9, 10, 11,
 
115
                                    12, 13, 14, 15);
 
116
 
 
117
            Matrix4 B = new Matrix4( 0,  1,  2,  3,
 
118
                                     4,  5,  6,  7,
 
119
                                     8,  9, 10, 11,
 
120
                                    12, 13, 14, 15);
 
121
 
 
122
            Matrix4 expected = new Matrix4( 56,  62,  68,  74,
 
123
                                           152, 174, 196, 218,
 
124
                                           248, 286, 324, 362,
 
125
                                           344, 398, 452, 506);
 
126
 
 
127
            Matrix4 result = A * B;
 
128
            Assert.IsTrue(expected == result);
 
129
        }
 
130
 
 
131
        [Test]
 
132
        public void Matrix4_Matrix4PlusMatrix4_operator()
 
133
        {
 
134
            Matrix4 A = new Matrix4( 0,  1,  2,  3,
 
135
                                     4,  5,  6,  7,
 
136
                                     8,  9, 10, 11,
 
137
                                    12, 13, 14, 15);
 
138
 
 
139
            Matrix4 B = new Matrix4( 0,  1,  2,  3,
 
140
                                     4,  5,  6,  7,
 
141
                                     8,  9, 10, 11,
 
142
                                    12, 13, 14, 15);
 
143
 
 
144
            Matrix4 expected = new Matrix4( 0,  2,  4,  6,
 
145
                                            8, 10, 12, 14,
 
146
                                           16, 18, 20, 22,
 
147
                                           24, 26, 28, 30);
 
148
 
 
149
            Matrix4 result = A + B;
 
150
            Assert.IsTrue(expected == result);
 
151
        }
 
152
 
 
153
        [Test]
 
154
        public void Matrix4_Matrix4MinusMatrix4_operator()
 
155
        {
 
156
            Matrix4 A = new Matrix4( 0,  1,  2,  3,
 
157
                                     4,  5,  6,  7,
 
158
                                     8,  9, 10, 11,
 
159
                                    12, 13, 14, 15);
 
160
 
 
161
            Matrix4 B = new Matrix4( 0,  1,  2,  3,
 
162
                                     4,  5,  6,  7,
 
163
                                     8,  9, 10, 11,
 
164
                                    12, 13, 14, 15);
 
165
 
 
166
            Matrix4 expected = new Matrix4( 0, 0, 0, 0,
 
167
                                            0, 0, 0, 0,
 
168
                                            0, 0, 0, 0,
 
169
                                            0, 0, 0, 0);
 
170
 
 
171
            Matrix4 result = A - B;
 
172
            Assert.IsTrue(expected == result);
 
173
        }
 
174
 
 
175
        [Test]
 
176
        public void Matrix4_Index_Operator()
 
177
        {
 
178
            Matrix4 A = new Matrix4();
 
179
            A[0, 0] = 0;
 
180
            A[0, 1] = 1;
 
181
            A[0, 2] = 2;
 
182
            A[0, 3] = 3;
 
183
            A[1, 0] = 4;
 
184
            A[1, 1] = 5;
 
185
            A[1, 2] = 6;
 
186
            A[1, 3] = 7;
 
187
            A[2, 0] = 8;
 
188
            A[2, 1] = 9;
 
189
            A[2, 2] = 10;
 
190
            A[2, 3] = 11;
 
191
            A[3, 0] = 12;
 
192
            A[3, 1] = 13;
 
193
            A[3, 2] = 14;
 
194
            A[3, 3] = 15;
 
195
            Assert.AreEqual(0, A[0, 0]);
 
196
            Assert.AreEqual(1, A[0, 1]);
 
197
            Assert.AreEqual(2, A[0, 2]);
 
198
            Assert.AreEqual(3, A[0, 3]);
 
199
            Assert.AreEqual(4, A[1, 0]);
 
200
            Assert.AreEqual(5, A[1, 1]);
 
201
            Assert.AreEqual(6, A[1, 2]);
 
202
            Assert.AreEqual(7, A[1, 3]);
 
203
            Assert.AreEqual(8, A[2, 0]);
 
204
            Assert.AreEqual(9, A[2, 1]);
 
205
            Assert.AreEqual(10, A[2, 2]);
 
206
            Assert.AreEqual(11, A[2, 3]);
 
207
            Assert.AreEqual(12, A[3, 0]);
 
208
            Assert.AreEqual(13, A[3, 1]);
 
209
            Assert.AreEqual(14, A[3, 2]);
 
210
            Assert.AreEqual(15, A[3, 3]);
 
211
        }
 
212
 
 
213
        [Test]
 
214
        public void Matrix4_Index_NegativeIndexException()
 
215
        {
 
216
            Matrix4 A = new Matrix4();
 
217
            bool negativeIndexException = false;
 
218
            try
 
219
            {
 
220
                A[-1, 2] = 0;
 
221
            }
 
222
            catch(Exception)
 
223
            {
 
224
                negativeIndexException = true;
 
225
            }
 
226
            Assert.IsTrue(negativeIndexException);
 
227
 
 
228
            negativeIndexException = false;
 
229
            try
 
230
            {
 
231
                A[1, -2] = 0;
 
232
            }
 
233
            catch (Exception)
 
234
            {
 
235
                negativeIndexException = true;
 
236
            }
 
237
            Assert.IsTrue(negativeIndexException);
 
238
 
 
239
            negativeIndexException = false;
 
240
            try
 
241
            {
 
242
                A[-1, -2] = 0;
 
243
            }
 
244
            catch (Exception)
 
245
            {
 
246
                negativeIndexException = true;
 
247
            }
 
248
            Assert.IsTrue(negativeIndexException);
 
249
        }
 
250
 
 
251
        [Test]
 
252
        public void Matrix4_Index_LargeIndexException()
 
253
        {
 
254
            Matrix4 A = new Matrix4();
 
255
            bool largeIndexException = false;
 
256
            try
 
257
            {
 
258
                A[5, 2] = 0;
 
259
            }
 
260
            catch (Exception)
 
261
            {
 
262
                largeIndexException = true;
 
263
            }
 
264
            Assert.IsTrue(largeIndexException);
 
265
 
 
266
            largeIndexException = false;
 
267
            try
 
268
            {
 
269
                A[1, 6] = 0;
 
270
            }
 
271
            catch (Exception)
 
272
            {
 
273
                largeIndexException = true;
 
274
            }
 
275
            Assert.IsTrue(largeIndexException);
 
276
 
 
277
            largeIndexException = false;
 
278
            try
 
279
            {
 
280
                A[7, 12] = 0;
 
281
            }
 
282
            catch (Exception)
 
283
            {
 
284
                largeIndexException = true;
 
285
            }
 
286
            Assert.IsTrue(largeIndexException);
 
287
        }
 
288
    }
 
289
}