1 //
2 // Copyright 2016 The ANGLE Project Authors. All rights reserved.
3 // Use of this source code is governed by a BSD-style license that can be
4 // found in the LICENSE file.
5 //
6 // vector_utils_unittests.cpp: Unit tests for the vector utils.
7 //
8
9 #include "vector_utils.h"
10
11 #include <gtest/gtest.h>
12
13 using namespace angle;
14
15 namespace
16 {
17
18 // First test that comparing vectors work
TEST(VectorUtilsTest,Comparison)19 TEST(VectorUtilsTest, Comparison)
20 {
21 // Don't use ASSERT_EQ at first because the == is more hidden
22 ASSERT_TRUE(Vector2(2.0, 3.0) == Vector2(2.0, 3.0));
23 ASSERT_TRUE(Vector2(2.0, 3.0) != Vector2(2.0, 4.0));
24
25 // Check ASSERT_EQ and ASSERT_NE work correctly
26 ASSERT_EQ(Vector2(2.0, 3.0), Vector2(2.0, 3.0));
27 ASSERT_NE(Vector2(2.0, 3.0), Vector2(2.0, 4.0));
28
29 // Check comparison works on all elements
30 ASSERT_EQ(Vector4(0.0), Vector4(0.0));
31 ASSERT_NE(Vector4(1.0, 0.0, 0.0, 0.0), Vector4(0.0));
32 ASSERT_NE(Vector4(0.0, 1.0, 0.0, 0.0), Vector4(0.0));
33 ASSERT_NE(Vector4(0.0, 0.0, 1.0, 0.0), Vector4(0.0));
34 ASSERT_NE(Vector4(0.0, 0.0, 0.0, 1.0), Vector4(0.0));
35 }
36
37 // Test indexing
TEST(VectorUtilsTest,Indexing)38 TEST(VectorUtilsTest, Indexing)
39 {
40 Vector2 vec(1.0, 2.0);
41 ASSERT_EQ(1.0, vec[0]);
42 ASSERT_EQ(2.0, vec[1]);
43
44 vec[0] = 3.0;
45 vec[1] = 4.0;
46 ASSERT_EQ(Vector2(3.0, 4.0), vec);
47 }
48
49 // Test for the various constructors
TEST(VectorUtilsTest,Constructors)50 TEST(VectorUtilsTest, Constructors)
51 {
52 // Constructor initializing all to a single element
53 {
54 Vector2 vec(3.0);
55 ASSERT_EQ(3.0, vec[0]);
56 ASSERT_EQ(3.0, vec[1]);
57 }
58
59 // Constructor initializing from another Vector
60 {
61 Vector2 vec(Vector2(1.0, 2.0));
62 ASSERT_EQ(1.0, vec[0]);
63 ASSERT_EQ(2.0, vec[1]);
64 }
65
66 // Mixed constructor
67 {
68 Vector4 vec(1.0, Vector2(2.0, 3.0), 4.0);
69 ASSERT_EQ(1.0, vec[0]);
70 ASSERT_EQ(2.0, vec[1]);
71 ASSERT_EQ(3.0, vec[2]);
72 ASSERT_EQ(4.0, vec[3]);
73 }
74 }
75
76 // Test accessing the data directly
TEST(VectorUtilsTest,DataAccess)77 TEST(VectorUtilsTest, DataAccess)
78 {
79 Vector2 vec(1.0, 2.0);
80 ASSERT_EQ(2u, vec.size());
81
82 ASSERT_EQ(1.0, vec.data()[0]);
83 ASSERT_EQ(2.0, vec.data()[1]);
84
85 vec.data()[0] = 3.0;
86 vec.data()[1] = 4.0;
87
88 ASSERT_EQ(Vector2(3.0, 4.0), vec);
89 }
90
91 // Test accessing the data directly
TEST(VectorUtilsTest,LoadStore)92 TEST(VectorUtilsTest, LoadStore)
93 {
94 float data[] = {1.0, 2.0};
95
96 Vector2 vec = Vector2::Load(data);
97
98 ASSERT_EQ(1.0, vec.data()[0]);
99 ASSERT_EQ(2.0, vec.data()[1]);
100
101 vec = Vector2(3.0, 4.0);
102 Vector2::Store(vec, data);
103
104 ASSERT_EQ(3.0, data[0]);
105 ASSERT_EQ(4.0, data[1]);
106 }
107
108 // Test basic arithmetic operations
TEST(VectorUtilsTest,BasicArithmetic)109 TEST(VectorUtilsTest, BasicArithmetic)
110 {
111 ASSERT_EQ(Vector2(2.0, 3.0), +Vector2(2.0, 3.0));
112 ASSERT_EQ(Vector2(-2.0, -3.0), -Vector2(2.0, 3.0));
113 ASSERT_EQ(Vector2(4.0, 6.0), Vector2(1.0, 2.0) + Vector2(3.0, 4.0));
114 ASSERT_EQ(Vector2(-2.0, -2.0), Vector2(1.0, 2.0) - Vector2(3.0, 4.0));
115 ASSERT_EQ(Vector2(3.0, 8.0), Vector2(1.0, 2.0) * Vector2(3.0, 4.0));
116 ASSERT_EQ(Vector2(3.0, 2.0), Vector2(3.0, 4.0) / Vector2(1.0, 2.0));
117
118 ASSERT_EQ(Vector2(2.0, 4.0), Vector2(1.0, 2.0) * 2);
119 ASSERT_EQ(Vector2(2.0, 4.0), 2 * Vector2(1.0, 2.0));
120 ASSERT_EQ(Vector2(0.5, 1.0), Vector2(1.0, 2.0) / 2);
121 }
122
123 // Test compound arithmetic operations
TEST(VectorUtilsTest,CompoundArithmetic)124 TEST(VectorUtilsTest, CompoundArithmetic)
125 {
126 {
127 Vector2 vec(1.0, 2.0);
128 vec += Vector2(3.0, 4.0);
129 ASSERT_EQ(Vector2(4.0, 6.0), vec);
130 }
131 {
132 Vector2 vec(1.0, 2.0);
133 vec -= Vector2(3.0, 4.0);
134 ASSERT_EQ(Vector2(-2.0, -2.0), vec);
135 }
136 {
137 Vector2 vec(1.0, 2.0);
138 vec *= Vector2(3.0, 4.0);
139 ASSERT_EQ(Vector2(3.0, 8.0), vec);
140 }
141 {
142 Vector2 vec(3.0, 4.0);
143 vec /= Vector2(1.0, 2.0);
144 ASSERT_EQ(Vector2(3.0, 2.0), vec);
145 }
146 {
147 Vector2 vec(1.0, 2.0);
148 vec *= 2.0;
149 ASSERT_EQ(Vector2(2.0, 4.0), vec);
150 }
151 {
152 Vector2 vec(1.0, 2.0);
153 vec /= 2.0;
154 ASSERT_EQ(Vector2(0.5, 1.0), vec);
155 }
156 }
157
158 // Test other arithmetic operations
TEST(VectorUtilsTest,OtherArithmeticOperations)159 TEST(VectorUtilsTest, OtherArithmeticOperations)
160 {
161 Vector2 vec(3.0, 4.0);
162
163 ASSERT_EQ(25.0, vec.lengthSquared());
164 ASSERT_EQ(5.0, vec.length());
165 ASSERT_EQ(Vector2(0.6, 0.8), vec.normalized());
166
167 ASSERT_EQ(11.0, vec.dot(Vector2(1.0, 2.0)));
168 }
169
170 // Test element shortcuts
TEST(VectorUtilsTest,ElementShortcuts)171 TEST(VectorUtilsTest, ElementShortcuts)
172 {
173 Vector2 vec2(1.0, 2.0);
174 Vector3 vec3(1.0, 2.0, 3.0);
175 Vector4 vec4(1.0, 2.0, 3.0, 4.0);
176
177 ASSERT_EQ(1.0, vec2.x());
178 ASSERT_EQ(1.0, vec3.x());
179 ASSERT_EQ(1.0, vec4.x());
180
181 ASSERT_EQ(2.0, vec2.y());
182 ASSERT_EQ(2.0, vec3.y());
183 ASSERT_EQ(2.0, vec4.y());
184
185 ASSERT_EQ(3.0, vec3.z());
186 ASSERT_EQ(3.0, vec4.z());
187
188 ASSERT_EQ(4.0, vec4.w());
189
190 vec2.x() = 0.0;
191 ASSERT_EQ(Vector2(0.0, 2.0), vec2);
192 }
193
194 // Test the cross product
TEST(VectorUtilsTest,CrossProduct)195 TEST(VectorUtilsTest, CrossProduct)
196 {
197 ASSERT_EQ(Vector3(0.0, 0.0, 1.0), Vector3(1.0, 0.0, 0.0).cross(Vector3(0.0, 1.0, 0.0)));
198 ASSERT_EQ(Vector3(-3.0, 6.0, -3.0), Vector3(1.0, 2.0, 3.0).cross(Vector3(4.0, 5.0, 6.0)));
199 }
200
201 // Test basic functionality of int vectors
TEST(VectorUtilsTest,IntVector)202 TEST(VectorUtilsTest, IntVector)
203 {
204 Vector2I vec(0);
205
206 int *data = vec.data();
207 data[1] = 1;
208
209 ASSERT_EQ(0, vec[0]);
210 ASSERT_EQ(1, vec[1]);
211 }
212
213 // Test basic functionality of int vectors
TEST(VectorUtilsTest,UIntVector)214 TEST(VectorUtilsTest, UIntVector)
215 {
216 Vector2U vec(0);
217
218 unsigned int *data = vec.data();
219 data[1] = 1;
220
221 ASSERT_EQ(0u, vec[0]);
222 ASSERT_EQ(1u, vec[1]);
223 }
224
225 } // anonymous namespace
226