RavEngine
Loading...
Searching...
No Matches
gtest_math_helper.h
1//----------------------------------------------------------------------------//
2// //
3// ozz-animation is hosted at http://github.com/guillaumeblanc/ozz-animation //
4// and distributed under the MIT License (MIT). //
5// //
6// Copyright (c) Guillaume Blanc //
7// //
8// Permission is hereby granted, free of charge, to any person obtaining a //
9// copy of this software and associated documentation files (the "Software"), //
10// to deal in the Software without restriction, including without limitation //
11// the rights to use, copy, modify, merge, publish, distribute, sublicense, //
12// and/or sell copies of the Software, and to permit persons to whom the //
13// Software is furnished to do so, subject to the following conditions: //
14// //
15// The above copyright notice and this permission notice shall be included in //
16// all copies or substantial portions of the Software. //
17// //
18// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR //
19// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, //
20// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL //
21// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER //
22// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING //
23// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER //
24// DEALINGS IN THE SOFTWARE. //
25// //
26//----------------------------------------------------------------------------//
27
28#ifndef OZZ_OZZ_BASE_MATHS_GTEST_MATH_HELPER_H_
29#define OZZ_OZZ_BASE_MATHS_GTEST_MATH_HELPER_H_
30
31static const float kFloatNearTolerance = 1e-5f;
32static const float kFloatNearEstTolerance = 1e-3f;
33
34// Implements "float near" test as a function. Avoids overloading compiler
35// optimizer when too much EXPECT_NEAR are used in a single compilation unit.
36inline void ExpectFloatNear(float _a, float _b,
37 float _tol = kFloatNearTolerance) {
38 EXPECT_NEAR(_a, _b, _tol);
39}
40
41// Implements "int equality" test as a function. Avoids overloading compiler
42// optimizer when too much EXPECT_TRUE are used in a single compilation unit.
43inline void ExpectIntEq(int _a, int _b) { EXPECT_EQ(_a, _b); }
44
45// Implements "bool equality" test as a function. Avoids overloading compiler
46// optimizer when too much EXPECT_TRUE are used in a single compilation unit.
47inline void ExpectTrue(bool _b) { EXPECT_TRUE(_b); }
48
49// Macro for testing floats, dedicated to estimated functions with a lower
50// precision.
51#define EXPECT_FLOAT_EQ_EST(_expected, _x) \
52 EXPECT_NEAR(_expected, _x, kFloatNearEstTolerance)
53
54// Macro for testing ozz::math::Float4 members with x, y, z, w float values,
55// using EXPECT_FLOAT_EQ internally.
56#define EXPECT_FLOAT4_EQ(_expected, _x, _y, _z, _w) \
57 \
58 do { \
59 SCOPED_TRACE(""); \
60 const ozz::math::Float4 expected(_expected); \
61 ExpectFloatNear(expected.x, _x); \
62 ExpectFloatNear(expected.y, _y); \
63 ExpectFloatNear(expected.z, _z); \
64 ExpectFloatNear(expected.w, _w); \
65 \
66 } while (void(0), 0)
67
68// Macro for testing ozz::math::Float3 members with x, y, z float values,
69// using EXPECT_FLOAT_EQ internally.
70#define EXPECT_FLOAT3_EQ(_expected, _x, _y, _z) \
71 \
72 do { \
73 SCOPED_TRACE(""); \
74 const ozz::math::Float3 expected(_expected); \
75 ExpectFloatNear(expected.x, _x); \
76 ExpectFloatNear(expected.y, _y); \
77 ExpectFloatNear(expected.z, _z); \
78 \
79 } while (void(0), 0)
80
81// Macro for testing ozz::math::Float2 members with x, y float values,
82// using EXPECT_NEAR internally.
83#define EXPECT_FLOAT2_EQ(_expected, _x, _y) \
84 \
85 do { \
86 SCOPED_TRACE(""); \
87 const ozz::math::Float2 expected(_expected); \
88 ExpectFloatNear(expected.x, _x); \
89 ExpectFloatNear(expected.y, _y); \
90 \
91 } while (void(0), 0)
92
93// Macro for testing ozz::math::Quaternion members with x, y, z, w float value.
94#define EXPECT_QUATERNION_EQ(_expected, _x, _y, _z, _w) \
95 \
96 do { \
97 SCOPED_TRACE(""); \
98 const ozz::math::Quaternion expected(_expected); \
99 ExpectFloatNear(expected.x, _x); \
100 ExpectFloatNear(expected.y, _y); \
101 ExpectFloatNear(expected.z, _z); \
102 ExpectFloatNear(expected.w, _w); \
103 \
104 } while (void(0), 0)
105
106#define _IMPL_EXPECT_SIMDFLOAT_EQ_TOL(_expected, _x, _y, _z, _w, _tol) \
107 \
108 do { \
109 union { \
110 ozz::math::SimdFloat4 ret; \
111 float af[4]; \
112 } u = {_expected}; \
113 ExpectFloatNear(u.af[0], _x, _tol); \
114 ExpectFloatNear(u.af[1], _y, _tol); \
115 ExpectFloatNear(u.af[2], _z, _tol); \
116 ExpectFloatNear(u.af[3], _w, _tol); \
117 \
118 } while (void(0), 0)
119
120#define _IMPL_EXPECT_SIMDFLOAT_EQ(_expected, _x, _y, _z, _w) \
121 _IMPL_EXPECT_SIMDFLOAT_EQ_TOL(_expected, _x, _y, _z, _w, kFloatNearTolerance)
122
123#define _IMPL_EXPECT_SIMDFLOAT_EQ_EST(_expected, _x, _y, _z, _w) \
124 _IMPL_EXPECT_SIMDFLOAT_EQ_TOL(_expected, _x, _y, _z, _w, \
125 kFloatNearEstTolerance)
126
127// Macro for testing ozz::math::simd::SimdFloat members with x, y, z, w values.
128#define EXPECT_SIMDFLOAT_EQ(_expected, _x, _y, _z, _w) \
129 \
130 do { \
131 SCOPED_TRACE(""); \
132 _IMPL_EXPECT_SIMDFLOAT_EQ(_expected, _x, _y, _z, _w); \
133 \
134 } while (void(0), 0)
135
136// Macro for testing ozz::math::simd::SimdFloat members with x, y, z, w values.
137// Dedicated to estimated functions with a lower precision.
138#define EXPECT_SIMDFLOAT_EQ_EST(_expected, _x, _y, _z, _w) \
139 \
140 do { \
141 SCOPED_TRACE(""); \
142 _IMPL_EXPECT_SIMDFLOAT_EQ_EST(_expected, _x, _y, _z, _w); \
143 \
144 } while (void(0), 0)
145
146// Macro for testing ozz::math::simd::SimdFloat members with x, y values with
147// a user defined precision.
148#define _IMPL_EXPECT_SIMDFLOAT2_EQ_TOL(_expected, _x, _y, _tol) \
149 \
150 do { \
151 union { \
152 ozz::math::SimdFloat4 ret; \
153 float af[4]; \
154 } u = {_expected}; \
155 ExpectFloatNear(u.af[0], _x, _tol); \
156 ExpectFloatNear(u.af[1], _y, _tol); \
157 \
158 } while (void(0), 0)
159
160// Macro for testing ozz::math::simd::SimdFloat members with x, y values.
161#define EXPECT_SIMDFLOAT2_EQ(_expected, _x, _y) \
162 \
163 do { \
164 SCOPED_TRACE(""); \
165 _IMPL_EXPECT_SIMDFLOAT2_EQ_TOL(_expected, _x, _y, kFloatNearTolerance); \
166 \
167 } while (void(0), 0)
168
169// Macro for testing ozz::math::simd::SimdFloat members with x, y values.
170// Dedicated to estimated functions with a lower precision.
171#define EXPECT_SIMDFLOAT2_EQ_EST(_expected, _x, _y) \
172 \
173 do { \
174 SCOPED_TRACE(""); \
175 _IMPL_EXPECT_SIMDFLOAT2_EQ_TOL(_expected, _x, _y, kFloatNearEstTolerance); \
176 \
177 } while (void(0), 0)
178
179// Macro for testing ozz::math::simd::SimdFloat members with x, y, z values.
180// Dedicated to estimated functions with a user defined precision.
181#define EXPECT_SIMDFLOAT3_EQ_TOL(_expected, _x, _y, _z, _tol) \
182 \
183 do { \
184 SCOPED_TRACE(""); \
185 _IMPL_EXPECT_SIMDFLOAT3_EQ_TOL(_expected, _x, _y, _z, _tol); \
186 \
187 } while (void(0), 0)
188
189// Macro for testing ozz::math::simd::SimdFloat members with x, y, z values with
190// a user defined precision.
191#define _IMPL_EXPECT_SIMDFLOAT3_EQ_TOL(_expected, _x, _y, _z, _tol) \
192 \
193 do { \
194 union { \
195 ozz::math::SimdFloat4 ret; \
196 float af[4]; \
197 } u = {_expected}; \
198 ExpectFloatNear(u.af[0], _x, _tol); \
199 ExpectFloatNear(u.af[1], _y, _tol); \
200 ExpectFloatNear(u.af[2], _z, _tol); \
201 \
202 } while (void(0), 0)
203
204// Macro for testing ozz::math::simd::SimdFloat members with x, y, z values.
205#define EXPECT_SIMDFLOAT3_EQ(_expected, _x, _y, _z) \
206 \
207 do { \
208 SCOPED_TRACE(""); \
209 _IMPL_EXPECT_SIMDFLOAT3_EQ_TOL(_expected, _x, _y, _z, \
210 kFloatNearTolerance); \
211 \
212 } while (void(0), 0)
213
214// Macro for testing ozz::math::simd::SimdFloat members with x, y, z values.
215// Dedicated to estimated functions with a lower precision.
216#define EXPECT_SIMDFLOAT3_EQ_EST(_expected, _x, _y, _z) \
217 \
218 do { \
219 SCOPED_TRACE(""); \
220 _IMPL_EXPECT_SIMDFLOAT3_EQ_TOL(_expected, _x, _y, _z, \
221 kFloatNearEstTolerance); \
222 \
223 } while (void(0), 0)
224
225// Macro for testing ozz::math::simd::SimdFloat members with x, y, z values.
226// Dedicated to estimated functions with a user defined precision.
227#define EXPECT_SIMDFLOAT3_EQ_TOL(_expected, _x, _y, _z, _tol) \
228 \
229 do { \
230 SCOPED_TRACE(""); \
231 _IMPL_EXPECT_SIMDFLOAT3_EQ_TOL(_expected, _x, _y, _z, _tol); \
232 \
233 } while (void(0), 0)
234
235// Macro for testing ozz::math::simd::SimdInt members with x, y, z, w values.
236#define EXPECT_SIMDINT_EQ(_expected, _x, _y, _z, _w) \
237 \
238 do { \
239 SCOPED_TRACE(""); \
240 union { \
241 ozz::math::SimdInt4 ret; \
242 int ai[4]; \
243 } u = {_expected}; \
244 ExpectIntEq(u.ai[0], static_cast<int>(_x)); \
245 ExpectIntEq(u.ai[1], static_cast<int>(_y)); \
246 ExpectIntEq(u.ai[2], static_cast<int>(_z)); \
247 ExpectIntEq(u.ai[3], static_cast<int>(_w)); \
248 \
249 } while (void(0), 0)
250
251// Macro for testing ozz::math::SoaFloat4 members with x, y, z, w float values.
252#define EXPECT_FLOAT4x4_EQ(_expected, _x0, _x1, _x2, _x3, _y0, _y1, _y2, _y3, \
253 _z0, _z1, _z2, _z3, _w0, _w1, _w2, _w3) \
254 \
255 do { \
256 SCOPED_TRACE(""); \
257 const ozz::math::Float4x4 expected(_expected); \
258 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.cols[0], _x0, _x1, _x2, _x3); \
259 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.cols[1], _y0, _y1, _y2, _y3); \
260 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.cols[2], _z0, _z1, _z2, _z3); \
261 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.cols[3], _w0, _w1, _w2, _w3); \
262 \
263 } while (void(0), 0)
264
265// Macro for testing ozz::math::simd::SimdQuaternion members with x, y, z, w
266// values.
267#define EXPECT_SIMDQUATERNION_EQ(_expected, _x, _y, _z, _w) \
268 \
269 do { \
270 SCOPED_TRACE(""); \
271 _IMPL_EXPECT_SIMDFLOAT_EQ(_expected.xyzw, _x, _y, _z, _w); \
272 \
273 } while (void(0), 0)
274
275// Macro for testing ozz::math::simd::SimdQuaternion members with x, y, z, w
276// values.
277#define EXPECT_SIMDQUATERNION_EQ_EST(_expected, _x, _y, _z, _w) \
278 \
279 do { \
280 SCOPED_TRACE(""); \
281 _IMPL_EXPECT_SIMDFLOAT_EQ_EST(_expected.xyzw, _x, _y, _z, _w); \
282 \
283 } while (void(0), 0)
284
285// Macro for testing ozz::math::simd::SimdQuaternion members with x, y, z, w
286// values.
287#define EXPECT_SIMDQUATERNION_EQ_TOL(_expected, _x, _y, _z, _w, _tol) \
288 \
289 do { \
290 SCOPED_TRACE(""); \
291 _IMPL_EXPECT_SIMDFLOAT_EQ_TOL(_expected.xyzw, _x, _y, _z, _w, _tol); \
292 \
293 } while (void(0), 0)
294
295// Macro for testing ozz::math::SoaFloat4 members with x, y, z, w float values.
296#define EXPECT_SOAFLOAT4_EQ(_expected, _x0, _x1, _x2, _x3, _y0, _y1, _y2, _y3, \
297 _z0, _z1, _z2, _z3, _w0, _w1, _w2, _w3) \
298 \
299 do { \
300 SCOPED_TRACE(""); \
301 const ozz::math::SoaFloat4 expected(_expected); \
302 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.x, _x0, _x1, _x2, _x3); \
303 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.y, _y0, _y1, _y2, _y3); \
304 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.z, _z0, _z1, _z2, _z3); \
305 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.w, _w0, _w1, _w2, _w3); \
306 \
307 } while (void(0), 0)
308
309// Macro for testing ozz::math::SoaFloat4 members with x, y, z, w float values.
310// Dedicated to estimated functions with a lower precision.
311#define EXPECT_SOAFLOAT4_EQ_EST(_expected, _x0, _x1, _x2, _x3, _y0, _y1, _y2, \
312 _y3, _z0, _z1, _z2, _z3, _w0, _w1, _w2, _w3) \
313 \
314 do { \
315 SCOPED_TRACE(""); \
316 const ozz::math::SoaFloat4 expected(_expected); \
317 _IMPL_EXPECT_SIMDFLOAT_EQ_EST(expected.x, _x0, _x1, _x2, _x3); \
318 _IMPL_EXPECT_SIMDFLOAT_EQ_EST(expected.y, _y0, _y1, _y2, _y3); \
319 _IMPL_EXPECT_SIMDFLOAT_EQ_EST(expected.z, _z0, _z1, _z2, _z3); \
320 _IMPL_EXPECT_SIMDFLOAT_EQ_EST(expected.w, _w0, _w1, _w2, _w3); \
321 \
322 } while (void(0), 0)
323
324// Macro for testing ozz::math::SoaFloat3 members with x, y, z float values.
325#define EXPECT_SOAFLOAT3_EQ(_expected, _x0, _x1, _x2, _x3, _y0, _y1, _y2, _y3, \
326 _z0, _z1, _z2, _z3) \
327 \
328 do { \
329 SCOPED_TRACE(""); \
330 const ozz::math::SoaFloat3 expected(_expected); \
331 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.x, _x0, _x1, _x2, _x3); \
332 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.y, _y0, _y1, _y2, _y3); \
333 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.z, _z0, _z1, _z2, _z3); \
334 \
335 } while (void(0), 0)
336
337// Macro for testing ozz::math::SoaFloat3 members with x, y, z float values.
338// Dedicated to estimated functions with a lower precision.
339#define EXPECT_SOAFLOAT3_EQ_EST(_expected, _x0, _x1, _x2, _x3, _y0, _y1, _y2, \
340 _y3, _z0, _z1, _z2, _z3) \
341 \
342 do { \
343 SCOPED_TRACE(""); \
344 const ozz::math::SoaFloat3 expected(_expected); \
345 _IMPL_EXPECT_SIMDFLOAT_EQ_EST(expected.x, _x0, _x1, _x2, _x3); \
346 _IMPL_EXPECT_SIMDFLOAT_EQ_EST(expected.y, _y0, _y1, _y2, _y3); \
347 _IMPL_EXPECT_SIMDFLOAT_EQ_EST(expected.z, _z0, _z1, _z2, _z3); \
348 \
349 } while (void(0), 0)
350
351// Macro for testing ozz::math::SoaFloat2 members with x, y float values.
352#define EXPECT_SOAFLOAT2_EQ(_expected, _x0, _x1, _x2, _x3, _y0, _y1, _y2, _y3) \
353 \
354 do { \
355 SCOPED_TRACE(""); \
356 const ozz::math::SoaFloat2 expected(_expected); \
357 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.x, _x0, _x1, _x2, _x3); \
358 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.y, _y0, _y1, _y2, _y3); \
359 \
360 } while (void(0), 0)
361
362// Macro for testing ozz::math::SoaFloat2 members with x, y float values.
363// Dedicated to estimated functions with a lower precision.
364#define EXPECT_SOAFLOAT2_EQ_EST(_expected, _x0, _x1, _x2, _x3, _y0, _y1, _y2, \
365 _y3) \
366 \
367 do { \
368 SCOPED_TRACE(""); \
369 const ozz::math::SoaFloat2 expected(_expected); \
370 _IMPL_EXPECT_SIMDFLOAT_EQ_EST(expected.x, _x0, _x1, _x2, _x3); \
371 _IMPL_EXPECT_SIMDFLOAT_EQ_EST(expected.y, _y0, _y1, _y2, _y3); \
372 \
373 } while (void(0), 0)
374
375// Macro for testing ozz::math::SoaFloat2 members with x, y float values.
376#define EXPECT_SOAFLOAT1_EQ(_expected, _x0, _x1, _x2, _x3) \
377 _IMPL_EXPECT_SIMDFLOAT_EQ(_expected, _x0, _x1, _x2, _x3);
378
379// Macro for testing ozz::math::SoaFloat2 members with x, y float values.
380// Dedicated to estimated functions with a lower precision.
381#define EXPECT_SOAFLOAT1_EQ_EST(_expected, _x0, _x1, _x2, _x3) \
382 _IMPL_EXPECT_SIMDFLOAT_EQ_EST(_expected, _x0, _x1, _x2, _x3);
383
384// Macro for testing ozz::math::SoaQuaternion members with x, y, z, w float
385// values.
386#define EXPECT_SOAQUATERNION_EQ(_expected, _x0, _x1, _x2, _x3, _y0, _y1, _y2, \
387 _y3, _z0, _z1, _z2, _z3, _w0, _w1, _w2, _w3) \
388 \
389 do { \
390 SCOPED_TRACE(""); \
391 const ozz::math::SoaQuaternion expected(_expected); \
392 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.x, _x0, _x1, _x2, _x3); \
393 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.y, _y0, _y1, _y2, _y3); \
394 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.z, _z0, _z1, _z2, _z3); \
395 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.w, _w0, _w1, _w2, _w3); \
396 \
397 } while (void(0), 0)
398
399// Macro for testing ozz::math::SoaQuaternion members with x, y, z, w float
400// values.
401// Dedicated to estimated functions with a lower precision.
402#define EXPECT_SOAQUATERNION_EQ_EST(_expected, _x0, _x1, _x2, _x3, _y0, _y1, \
403 _y2, _y3, _z0, _z1, _z2, _z3, _w0, _w1, \
404 _w2, _w3) \
405 \
406 do { \
407 SCOPED_TRACE(""); \
408 const ozz::math::SoaQuaternion expected(_expected); \
409 _IMPL_EXPECT_SIMDFLOAT_EQ_EST(expected.x, _x0, _x1, _x2, _x3); \
410 _IMPL_EXPECT_SIMDFLOAT_EQ_EST(expected.y, _y0, _y1, _y2, _y3); \
411 _IMPL_EXPECT_SIMDFLOAT_EQ_EST(expected.z, _z0, _z1, _z2, _z3); \
412 _IMPL_EXPECT_SIMDFLOAT_EQ_EST(expected.w, _w0, _w1, _w2, _w3); \
413 \
414 } while (void(0), 0)
415
416#define EXPECT_SOAFLOAT4x4_EQ( \
417 _expected, col0xx, col0xy, col0xz, col0xw, col0yx, col0yy, col0yz, col0yw, \
418 col0zx, col0zy, col0zz, col0zw, col0wx, col0wy, col0wz, col0ww, col1xx, \
419 col1xy, col1xz, col1xw, col1yx, col1yy, col1yz, col1yw, col1zx, col1zy, \
420 col1zz, col1zw, col1wx, col1wy, col1wz, col1ww, col2xx, col2xy, col2xz, \
421 col2xw, col2yx, col2yy, col2yz, col2yw, col2zx, col2zy, col2zz, col2zw, \
422 col2wx, col2wy, col2wz, col2ww, col3xx, col3xy, col3xz, col3xw, col3yx, \
423 col3yy, col3yz, col3yw, col3zx, col3zy, col3zz, col3zw, col3wx, col3wy, \
424 col3wz, col3ww) \
425 \
426 do { \
427 SCOPED_TRACE(""); \
428 const ozz::math::SoaFloat4x4 expected(_expected); \
429 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.cols[0].x, col0xx, col0xy, col0xz, \
430 col0xw); \
431 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.cols[0].y, col0yx, col0yy, col0yz, \
432 col0yw); \
433 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.cols[0].z, col0zx, col0zy, col0zz, \
434 col0zw); \
435 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.cols[0].w, col0wx, col0wy, col0wz, \
436 col0ww); \
437 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.cols[1].x, col1xx, col1xy, col1xz, \
438 col1xw); \
439 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.cols[1].y, col1yx, col1yy, col1yz, \
440 col1yw); \
441 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.cols[1].z, col1zx, col1zy, col1zz, \
442 col1zw); \
443 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.cols[1].w, col1wx, col1wy, col1wz, \
444 col1ww); \
445 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.cols[2].x, col2xx, col2xy, col2xz, \
446 col2xw); \
447 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.cols[2].y, col2yx, col2yy, col2yz, \
448 col2yw); \
449 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.cols[2].z, col2zx, col2zy, col2zz, \
450 col2zw); \
451 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.cols[2].w, col2wx, col2wy, col2wz, \
452 col2ww); \
453 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.cols[3].x, col3xx, col3xy, col3xz, \
454 col3xw); \
455 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.cols[3].y, col3yx, col3yy, col3yz, \
456 col3yw); \
457 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.cols[3].z, col3zx, col3zy, col3zz, \
458 col3zw); \
459 _IMPL_EXPECT_SIMDFLOAT_EQ(expected.cols[3].w, col3wx, col3wy, col3wz, \
460 col3ww); \
461 \
462 } while (void(0), 0)
463#endif // OZZ_OZZ_BASE_MATHS_GTEST_MATH_HELPER_H_