Merge Filament's math library
This math library was derived from Android's and is API compatible.
It adds new useful types (quat and half) as well as many missing
functions and optimizations.
The half type (fp16) is going to be used for HDR/color management.
Test: mat_test, quat_test, half_test and vec_test
Change-Id: I4c61efb085d6aa2cf5b43cdd194719b3e855aa9b
diff --git a/libs/ui/tests/Android.bp b/libs/ui/tests/Android.bp
index 8cdab8c..9594466 100644
--- a/libs/ui/tests/Android.bp
+++ b/libs/ui/tests/Android.bp
@@ -29,3 +29,13 @@
name: "mat_test",
srcs: ["mat_test.cpp"],
}
+
+cc_test {
+ name: "half_test",
+ srcs: ["half_test.cpp"],
+}
+
+cc_test {
+ name: "quat_test",
+ srcs: ["quat_test.cpp"],
+}
diff --git a/libs/ui/tests/half_test.cpp b/libs/ui/tests/half_test.cpp
new file mode 100644
index 0000000..0ea9265
--- /dev/null
+++ b/libs/ui/tests/half_test.cpp
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "HalfTest"
+
+#include <math.h>
+#include <stdlib.h>
+
+#include <ui/half.h>
+#include <ui/vec4.h>
+
+#include <gtest/gtest.h>
+
+namespace android {
+
+class HalfTest : public testing::Test {
+protected:
+};
+
+TEST_F(HalfTest, Basics) {
+
+ EXPECT_EQ(2, sizeof(half));
+
+ // test +/- zero
+ EXPECT_EQ(0x0000, half( 0.0f).getBits());
+ EXPECT_EQ(0x8000, half(-0.0f).getBits());
+
+ // test nan
+ EXPECT_EQ(0x7e00, half(NAN).getBits());
+
+ // test +/- infinity
+ EXPECT_EQ(0x7C00, half( std::numeric_limits<float>::infinity()).getBits());
+ EXPECT_EQ(0xFC00, half(-std::numeric_limits<float>::infinity()).getBits());
+
+ // test a few known values
+ EXPECT_EQ(0x3C01, half(1.0009765625).getBits());
+ EXPECT_EQ(0xC000, half(-2).getBits());
+ EXPECT_EQ(0x0400, half(6.10352e-5).getBits());
+ EXPECT_EQ(0x7BFF, half(65504).getBits());
+ EXPECT_EQ(0x3555, half(1.0f/3).getBits());
+
+ // numeric limits
+ EXPECT_EQ(0x7C00, std::numeric_limits<half>::infinity().getBits());
+ EXPECT_EQ(0x0400, std::numeric_limits<half>::min().getBits());
+ EXPECT_EQ(0x7BFF, std::numeric_limits<half>::max().getBits());
+ EXPECT_EQ(0xFBFF, std::numeric_limits<half>::lowest().getBits());
+
+ // denormals (flushed to zero)
+ EXPECT_EQ(0x0000, half( 6.09756e-5).getBits()); // if handled, should be: 0x03FF
+ EXPECT_EQ(0x0000, half( 5.96046e-8).getBits()); // if handled, should be: 0x0001
+ EXPECT_EQ(0x8000, half(-6.09756e-5).getBits()); // if handled, should be: 0x83FF
+ EXPECT_EQ(0x8000, half(-5.96046e-8).getBits()); // if handled, should be: 0x8001
+
+ // test all exactly representable integers
+ for (int i=-2048 ; i<= 2048 ; ++i) {
+ half h = i;
+ EXPECT_EQ(i, float(h));
+ }
+}
+
+TEST_F(HalfTest, Literals) {
+ half one = 1.0_hf;
+ half pi = 3.1415926_hf;
+ half minusTwo = -2.0_hf;
+
+ EXPECT_EQ(half(1.0f), one);
+ EXPECT_EQ(half(3.1415926), pi);
+ EXPECT_EQ(half(-2.0f), minusTwo);
+}
+
+
+TEST_F(HalfTest, Vec) {
+ float4 f4(1,2,3,4);
+ half4 h4(f4);
+ half3 h3(f4.xyz);
+ half2 h2(f4.xy);
+
+ EXPECT_EQ(f4, h4);
+ EXPECT_EQ(f4.xyz, h3);
+ EXPECT_EQ(f4.xy, h2);
+}
+
+}; // namespace android
diff --git a/libs/ui/tests/mat_test.cpp b/libs/ui/tests/mat_test.cpp
index a2c63ac..0f8e631 100644
--- a/libs/ui/tests/mat_test.cpp
+++ b/libs/ui/tests/mat_test.cpp
@@ -14,13 +14,17 @@
* limitations under the License.
*/
-#define LOG_TAG "RegionTest"
+#define LOG_TAG "MatTest"
#include <stdlib.h>
-#include <ui/Region.h>
-#include <ui/Rect.h>
+
+#include <limits>
+#include <random>
+#include <functional>
+
#include <gtest/gtest.h>
+#include <ui/mat2.h>
#include <ui/mat4.h>
namespace android {
@@ -99,11 +103,13 @@
const mat4 identity;
mat4 m0;
- ++m0;
- EXPECT_EQ(mat4( vec4(2,1,1,1), vec4(1,2,1,1), vec4(1,1,2,1), vec4(1,1,1,2) ), m0);
- EXPECT_EQ(mat4( -vec4(2,1,1,1), -vec4(1,2,1,1), -vec4(1,1,2,1), -vec4(1,1,1,2) ), -m0);
+ m0 = -m0;
+ EXPECT_EQ(mat4(vec4(-1, 0, 0, 0),
+ vec4(0, -1, 0, 0),
+ vec4(0, 0, -1, 0),
+ vec4(0, 0, 0, -1)), m0);
- --m0;
+ m0 = -m0;
EXPECT_EQ(identity, m0);
}
@@ -112,19 +118,19 @@
mat4 m0;
EXPECT_EQ(4, trace(m0));
- mat4 m1(vec4(1,2,3,4), vec4(5,6,7,8), vec4(9,10,11,12), vec4(13,14,15,16));
- mat4 m2(vec4(1,5,9,13), vec4(2,6,10,14), vec4(3,7,11,15), vec4(4,8,12,16));
+ mat4 m1(vec4(1, 2, 3, 4), vec4(5, 6, 7, 8), vec4(9, 10, 11, 12), vec4(13, 14, 15, 16));
+ mat4 m2(vec4(1, 5, 9, 13), vec4(2, 6, 10, 14), vec4(3, 7, 11, 15), vec4(4, 8, 12, 16));
EXPECT_EQ(m1, transpose(m2));
EXPECT_EQ(m2, transpose(m1));
- EXPECT_EQ(vec4(1,6,11,16), diag(m1));
+ EXPECT_EQ(vec4(1, 6, 11, 16), diag(m1));
EXPECT_EQ(identity, inverse(identity));
- mat4 m3(vec4(4,3,0,0), vec4(3,2,0,0), vec4(0,0,1,0), vec4(0,0,0,1));
+ mat4 m3(vec4(4, 3, 0, 0), vec4(3, 2, 0, 0), vec4(0, 0, 1, 0), vec4(0, 0, 0, 1));
mat4 m3i(inverse(m3));
EXPECT_FLOAT_EQ(-2, m3i[0][0]);
- EXPECT_FLOAT_EQ( 3, m3i[0][1]);
- EXPECT_FLOAT_EQ( 3, m3i[1][0]);
+ EXPECT_FLOAT_EQ(3, m3i[0][1]);
+ EXPECT_FLOAT_EQ(3, m3i[1][0]);
EXPECT_FLOAT_EQ(-4, m3i[1][1]);
mat4 m3ii(inverse(m3i));
@@ -134,6 +140,553 @@
EXPECT_FLOAT_EQ(m3[1][1], m3ii[1][1]);
EXPECT_EQ(m1, m1*identity);
+
+
+ for (size_t c=0 ; c<4 ; c++) {
+ for (size_t r=0 ; r<4 ; r++) {
+ EXPECT_FLOAT_EQ(m1[c][r], m1(r, c));
+ }
+ }
}
+TEST_F(MatTest, ElementAccess) {
+ mat4 m(vec4(1, 2, 3, 4), vec4(5, 6, 7, 8), vec4(9, 10, 11, 12), vec4(13, 14, 15, 16));
+ for (size_t c=0 ; c<4 ; c++) {
+ for (size_t r=0 ; r<4 ; r++) {
+ EXPECT_FLOAT_EQ(m[c][r], m(r, c));
+ }
+ }
+
+ m(3,2) = 100;
+ EXPECT_FLOAT_EQ(m[2][3], 100);
+ EXPECT_FLOAT_EQ(m(3, 2), 100);
+}
+
+//------------------------------------------------------------------------------
+// MAT 3
+//------------------------------------------------------------------------------
+
+class Mat3Test : public testing::Test {
+protected:
+};
+
+TEST_F(Mat3Test, Basics) {
+ mat3 m0;
+ EXPECT_EQ(sizeof(mat3), sizeof(float)*9);
+}
+
+TEST_F(Mat3Test, ComparisonOps) {
+ mat3 m0;
+ mat3 m1(2);
+
+ EXPECT_TRUE(m0 == m0);
+ EXPECT_TRUE(m0 != m1);
+ EXPECT_FALSE(m0 != m0);
+ EXPECT_FALSE(m0 == m1);
+}
+
+TEST_F(Mat3Test, Constructors) {
+ mat3 m0;
+ ASSERT_EQ(m0[0].x, 1);
+ ASSERT_EQ(m0[0].y, 0);
+ ASSERT_EQ(m0[0].z, 0);
+ ASSERT_EQ(m0[1].x, 0);
+ ASSERT_EQ(m0[1].y, 1);
+ ASSERT_EQ(m0[1].z, 0);
+ ASSERT_EQ(m0[2].x, 0);
+ ASSERT_EQ(m0[2].y, 0);
+ ASSERT_EQ(m0[2].z, 1);
+
+ mat3 m1(2);
+ mat3 m2(vec3(2));
+ mat3 m3(m2);
+
+ EXPECT_EQ(m1, m2);
+ EXPECT_EQ(m2, m3);
+ EXPECT_EQ(m3, m1);
+}
+
+TEST_F(Mat3Test, ArithmeticOps) {
+ mat3 m0;
+ mat3 m1(2);
+ mat3 m2(vec3(2));
+
+ m1 += m2;
+ EXPECT_EQ(mat3(4), m1);
+
+ m2 -= m1;
+ EXPECT_EQ(mat3(-2), m2);
+
+ m1 *= 2;
+ EXPECT_EQ(mat3(8), m1);
+
+ m1 /= 2;
+ EXPECT_EQ(mat3(4), m1);
+
+ m0 = -m0;
+ EXPECT_EQ(mat3(-1), m0);
+}
+
+TEST_F(Mat3Test, UnaryOps) {
+ const mat3 identity;
+ mat3 m0;
+
+ m0 = -m0;
+ EXPECT_EQ(mat3(vec3(-1, 0, 0),
+ vec3(0, -1, 0),
+ vec3(0, 0, -1)), m0);
+
+ m0 = -m0;
+ EXPECT_EQ(identity, m0);
+}
+
+TEST_F(Mat3Test, MiscOps) {
+ const mat3 identity;
+ mat3 m0;
+ EXPECT_EQ(3, trace(m0));
+
+ mat3 m1(vec3(1, 2, 3), vec3(4, 5, 6), vec3(7, 8, 9));
+ mat3 m2(vec3(1, 4, 7), vec3(2, 5, 8), vec3(3, 6, 9));
+ EXPECT_EQ(m1, transpose(m2));
+ EXPECT_EQ(m2, transpose(m1));
+ EXPECT_EQ(vec3(1, 5, 9), diag(m1));
+
+ EXPECT_EQ(identity, inverse(identity));
+
+ mat3 m3(vec3(4, 3, 0), vec3(3, 2, 0), vec3(0, 0, 1));
+ mat3 m3i(inverse(m3));
+ EXPECT_FLOAT_EQ(-2, m3i[0][0]);
+ EXPECT_FLOAT_EQ(3, m3i[0][1]);
+ EXPECT_FLOAT_EQ(3, m3i[1][0]);
+ EXPECT_FLOAT_EQ(-4, m3i[1][1]);
+
+ mat3 m3ii(inverse(m3i));
+ EXPECT_FLOAT_EQ(m3[0][0], m3ii[0][0]);
+ EXPECT_FLOAT_EQ(m3[0][1], m3ii[0][1]);
+ EXPECT_FLOAT_EQ(m3[1][0], m3ii[1][0]);
+ EXPECT_FLOAT_EQ(m3[1][1], m3ii[1][1]);
+
+ EXPECT_EQ(m1, m1*identity);
+}
+
+//------------------------------------------------------------------------------
+// MAT 2
+//------------------------------------------------------------------------------
+
+class Mat2Test : public testing::Test {
+protected:
+};
+
+TEST_F(Mat2Test, Basics) {
+ mat2 m0;
+ EXPECT_EQ(sizeof(mat2), sizeof(float)*4);
+}
+
+TEST_F(Mat2Test, ComparisonOps) {
+ mat2 m0;
+ mat2 m1(2);
+
+ EXPECT_TRUE(m0 == m0);
+ EXPECT_TRUE(m0 != m1);
+ EXPECT_FALSE(m0 != m0);
+ EXPECT_FALSE(m0 == m1);
+}
+
+TEST_F(Mat2Test, Constructors) {
+ mat2 m0;
+ ASSERT_EQ(m0[0].x, 1);
+ ASSERT_EQ(m0[0].y, 0);
+ ASSERT_EQ(m0[1].x, 0);
+ ASSERT_EQ(m0[1].y, 1);
+
+ mat2 m1(2);
+ mat2 m2(vec2(2));
+ mat2 m3(m2);
+
+ EXPECT_EQ(m1, m2);
+ EXPECT_EQ(m2, m3);
+ EXPECT_EQ(m3, m1);
+}
+
+TEST_F(Mat2Test, ArithmeticOps) {
+ mat2 m0;
+ mat2 m1(2);
+ mat2 m2(vec2(2));
+
+ m1 += m2;
+ EXPECT_EQ(mat2(4), m1);
+
+ m2 -= m1;
+ EXPECT_EQ(mat2(-2), m2);
+
+ m1 *= 2;
+ EXPECT_EQ(mat2(8), m1);
+
+ m1 /= 2;
+ EXPECT_EQ(mat2(4), m1);
+
+ m0 = -m0;
+ EXPECT_EQ(mat2(-1), m0);
+}
+
+TEST_F(Mat2Test, UnaryOps) {
+ const mat2 identity;
+ mat2 m0;
+
+ m0 = -m0;
+ EXPECT_EQ(mat2(vec2(-1, 0),
+ vec2(0, -1)), m0);
+
+ m0 = -m0;
+ EXPECT_EQ(identity, m0);
+}
+
+TEST_F(Mat2Test, MiscOps) {
+ const mat2 identity;
+ mat2 m0;
+ EXPECT_EQ(2, trace(m0));
+
+ mat2 m1(vec2(1, 2), vec2(3, 4));
+ mat2 m2(vec2(1, 3), vec2(2, 4));
+ EXPECT_EQ(m1, transpose(m2));
+ EXPECT_EQ(m2, transpose(m1));
+ EXPECT_EQ(vec2(1, 4), diag(m1));
+
+ EXPECT_EQ(identity, inverse(identity));
+
+ EXPECT_EQ(m1, m1*identity);
+}
+
+//------------------------------------------------------------------------------
+// MORE MATRIX TESTS
+//------------------------------------------------------------------------------
+
+template <typename T>
+class MatTestT : public ::testing::Test {
+public:
+};
+
+typedef ::testing::Types<float,float> TestMatrixValueTypes;
+
+TYPED_TEST_CASE(MatTestT, TestMatrixValueTypes);
+
+#define TEST_MATRIX_INVERSE(MATRIX, EPSILON) \
+{ \
+ typedef decltype(MATRIX) MatrixType; \
+ MatrixType inv1 = inverse(MATRIX); \
+ MatrixType ident1 = MATRIX * inv1; \
+ static const MatrixType IDENTITY; \
+ for (size_t row = 0; row < MatrixType::ROW_SIZE; ++row) { \
+ for (size_t col = 0; col < MatrixType::COL_SIZE; ++col) { \
+ EXPECT_NEAR(ident1[row][col], IDENTITY[row][col], EPSILON); \
+ } \
+ } \
+}
+
+TYPED_TEST(MatTestT, Inverse4) {
+ typedef ::android::details::TMat44<TypeParam> M44T;
+
+ M44T m1(1, 0, 0, 0,
+ 0, 1, 0, 0,
+ 0, 0, 1, 0,
+ 0, 0, 0, 1);
+
+ M44T m2(0, -1, 0, 0,
+ 1, 0, 0, 0,
+ 0, 0, 1, 0,
+ 0, 0, 0, 1);
+
+ M44T m3(1, 0, 0, 0,
+ 0, 2, 0, 0,
+ 0, 0, 0, 1,
+ 0, 0, -1, 0);
+
+ M44T m4(
+ 4.683281e-01, 1.251189e-02, -8.834660e-01, -4.726541e+00,
+ -8.749647e-01, 1.456563e-01, -4.617587e-01, 3.044795e+00,
+ 1.229049e-01, 9.892561e-01, 7.916244e-02, -6.737138e+00,
+ 0.000000e+00, 0.000000e+00, 0.000000e+00, 1.000000e+00);
+
+ M44T m5(
+ 4.683281e-01, 1.251189e-02, -8.834660e-01, -4.726541e+00,
+ -8.749647e-01, 1.456563e-01, -4.617587e-01, 3.044795e+00,
+ 1.229049e-01, 9.892561e-01, 7.916244e-02, -6.737138e+00,
+ 1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00);
+
+ TEST_MATRIX_INVERSE(m1, 0);
+ TEST_MATRIX_INVERSE(m2, 0);
+ TEST_MATRIX_INVERSE(m3, 0);
+ TEST_MATRIX_INVERSE(m4, 20.0 * std::numeric_limits<TypeParam>::epsilon());
+ TEST_MATRIX_INVERSE(m5, 20.0 * std::numeric_limits<TypeParam>::epsilon());
+}
+
+//------------------------------------------------------------------------------
+TYPED_TEST(MatTestT, Inverse3) {
+ typedef ::android::details::TMat33<TypeParam> M33T;
+
+ M33T m1(1, 0, 0,
+ 0, 1, 0,
+ 0, 0, 1);
+
+ M33T m2(0, -1, 0,
+ 1, 0, 0,
+ 0, 0, 1);
+
+ M33T m3(2, 0, 0,
+ 0, 0, 1,
+ 0, -1, 0);
+
+ M33T m4(
+ 4.683281e-01, 1.251189e-02, 0.000000e+00,
+ -8.749647e-01, 1.456563e-01, 0.000000e+00,
+ 0.000000e+00, 0.000000e+00, 1.000000e+00);
+
+ M33T m5(
+ 4.683281e-01, 1.251189e-02, -8.834660e-01,
+ -8.749647e-01, 1.456563e-01, -4.617587e-01,
+ 1.229049e-01, 9.892561e-01, 7.916244e-02);
+
+ TEST_MATRIX_INVERSE(m1, 0);
+ TEST_MATRIX_INVERSE(m2, 0);
+ TEST_MATRIX_INVERSE(m3, 0);
+ TEST_MATRIX_INVERSE(m4, 20.0 * std::numeric_limits<TypeParam>::epsilon());
+ TEST_MATRIX_INVERSE(m5, 20.0 * std::numeric_limits<TypeParam>::epsilon());
+}
+
+//------------------------------------------------------------------------------
+TYPED_TEST(MatTestT, Inverse2) {
+ typedef ::android::details::TMat22<TypeParam> M22T;
+
+ M22T m1(1, 0,
+ 0, 1);
+
+ M22T m2(0, -1,
+ 1, 0);
+
+ M22T m3(
+ 4.683281e-01, 1.251189e-02,
+ -8.749647e-01, 1.456563e-01);
+
+ M22T m4(
+ 4.683281e-01, 1.251189e-02,
+ -8.749647e-01, 1.456563e-01);
+
+ TEST_MATRIX_INVERSE(m1, 0);
+ TEST_MATRIX_INVERSE(m2, 0);
+ TEST_MATRIX_INVERSE(m3, 20.0 * std::numeric_limits<TypeParam>::epsilon());
+ TEST_MATRIX_INVERSE(m4, 20.0 * std::numeric_limits<TypeParam>::epsilon());
+}
+
+//------------------------------------------------------------------------------
+// A macro to help with vector comparisons within floating point range.
+#define EXPECT_VEC_EQ(VEC1, VEC2) \
+do { \
+ const decltype(VEC1) v1 = VEC1; \
+ const decltype(VEC2) v2 = VEC2; \
+ if (std::is_same<TypeParam,float>::value) { \
+ for (size_t i = 0; i < v1.size(); ++i) { \
+ EXPECT_FLOAT_EQ(v1[i], v2[i]); \
+ } \
+ } else if (std::is_same<TypeParam,float>::value) { \
+ for (size_t i = 0; i < v1.size(); ++i) { \
+ EXPECT_DOUBLE_EQ(v1[i], v2[i]); \
+ } \
+ } else { \
+ for (size_t i = 0; i < v1.size(); ++i) { \
+ EXPECT_EQ(v1[i], v2[i]); \
+ } \
+ } \
+} while(0)
+
+//------------------------------------------------------------------------------
+// A macro to help with type comparisons within floating point range.
+#define ASSERT_TYPE_EQ(T1, T2) \
+do { \
+ const decltype(T1) t1 = T1; \
+ const decltype(T2) t2 = T2; \
+ if (std::is_same<TypeParam,float>::value) { \
+ ASSERT_FLOAT_EQ(t1, t2); \
+ } else if (std::is_same<TypeParam,float>::value) { \
+ ASSERT_DOUBLE_EQ(t1, t2); \
+ } else { \
+ ASSERT_EQ(t1, t2); \
+ } \
+} while(0)
+
+//------------------------------------------------------------------------------
+// Test some translation stuff.
+TYPED_TEST(MatTestT, Translation4) {
+ typedef ::android::details::TMat44<TypeParam> M44T;
+ typedef ::android::details::TVec4<TypeParam> V4T;
+
+ V4T translateBy(-7.3, 1.1, 14.4, 0.0);
+ V4T translation(translateBy[0], translateBy[1], translateBy[2], 1.0);
+ M44T translation_matrix = M44T::translate(translation);
+
+ V4T p1(9.9, 3.1, 41.1, 1.0);
+ V4T p2(-18.0, 0.0, 1.77, 1.0);
+ V4T p3(0, 0, 0, 1);
+ V4T p4(-1000, -1000, 1000, 1.0);
+
+ EXPECT_VEC_EQ(translation_matrix * p1, translateBy + p1);
+ EXPECT_VEC_EQ(translation_matrix * p2, translateBy + p2);
+ EXPECT_VEC_EQ(translation_matrix * p3, translateBy + p3);
+ EXPECT_VEC_EQ(translation_matrix * p4, translateBy + p4);
+}
+
+//------------------------------------------------------------------------------
+template <typename MATRIX>
+static void verifyOrthonormal(const MATRIX& A) {
+ typedef typename MATRIX::value_type T;
+
+ static constexpr T value_eps = T(100) * std::numeric_limits<T>::epsilon();
+
+ const MATRIX prod = A * transpose(A);
+ for (size_t i = 0; i < MATRIX::NUM_COLS; ++i) {
+ for (size_t j = 0; j < MATRIX::NUM_ROWS; ++j) {
+ if (i == j) {
+ ASSERT_NEAR(prod[i][j], T(1), value_eps);
+ } else {
+ ASSERT_NEAR(prod[i][j], T(0), value_eps);
+ }
+ }
+ }
+}
+
+//------------------------------------------------------------------------------
+// Test euler code.
+TYPED_TEST(MatTestT, EulerZYX_44) {
+ typedef ::android::details::TMat44<TypeParam> M44T;
+
+ std::default_random_engine generator(82828);
+ std::uniform_real_distribution<float> distribution(-6.0 * 2.0*M_PI, 6.0 * 2.0*M_PI);
+ auto rand_gen = std::bind(distribution, generator);
+
+ for (size_t i = 0; i < 100; ++i) {
+ M44T m = M44T::eulerZYX(rand_gen(), rand_gen(), rand_gen());
+ verifyOrthonormal(m);
+ }
+
+ M44T m = M44T::eulerZYX(1, 2, 3);
+ verifyOrthonormal(m);
+}
+
+//------------------------------------------------------------------------------
+// Test euler code.
+TYPED_TEST(MatTestT, EulerZYX_33) {
+
+ typedef ::android::details::TMat33<TypeParam> M33T;
+
+ std::default_random_engine generator(112233);
+ std::uniform_real_distribution<float> distribution(-6.0 * 2.0*M_PI, 6.0 * 2.0*M_PI);
+ auto rand_gen = std::bind(distribution, generator);
+
+ for (size_t i = 0; i < 100; ++i) {
+ M33T m = M33T::eulerZYX(rand_gen(), rand_gen(), rand_gen());
+ verifyOrthonormal(m);
+ }
+
+ M33T m = M33T::eulerZYX(1, 2, 3);
+ verifyOrthonormal(m);
+}
+
+//------------------------------------------------------------------------------
+// Test to quaternion with post translation.
+TYPED_TEST(MatTestT, ToQuaternionPostTranslation) {
+
+ typedef ::android::details::TMat44<TypeParam> M44T;
+ typedef ::android::details::TVec4<TypeParam> V4T;
+ typedef ::android::details::TQuaternion<TypeParam> QuatT;
+
+ std::default_random_engine generator(112233);
+ std::uniform_real_distribution<float> distribution(-6.0 * 2.0*M_PI, 6.0 * 2.0*M_PI);
+ auto rand_gen = std::bind(distribution, generator);
+
+ for (size_t i = 0; i < 100; ++i) {
+ M44T r = M44T::eulerZYX(rand_gen(), rand_gen(), rand_gen());
+ M44T t = M44T::translate(V4T(rand_gen(), rand_gen(), rand_gen(), 1));
+ QuatT qr = r.toQuaternion();
+ M44T tr = t * r;
+ QuatT qtr = tr.toQuaternion();
+
+ ASSERT_TYPE_EQ(qr.x, qtr.x);
+ ASSERT_TYPE_EQ(qr.y, qtr.y);
+ ASSERT_TYPE_EQ(qr.z, qtr.z);
+ ASSERT_TYPE_EQ(qr.w, qtr.w);
+ }
+
+ M44T r = M44T::eulerZYX(1, 2, 3);
+ M44T t = M44T::translate(V4T(20, -15, 2, 1));
+ QuatT qr = r.toQuaternion();
+ M44T tr = t * r;
+ QuatT qtr = tr.toQuaternion();
+
+ ASSERT_TYPE_EQ(qr.x, qtr.x);
+ ASSERT_TYPE_EQ(qr.y, qtr.y);
+ ASSERT_TYPE_EQ(qr.z, qtr.z);
+ ASSERT_TYPE_EQ(qr.w, qtr.w);
+}
+
+//------------------------------------------------------------------------------
+// Test to quaternion with post translation.
+TYPED_TEST(MatTestT, ToQuaternionPointTransformation33) {
+ static constexpr TypeParam value_eps =
+ TypeParam(1000) * std::numeric_limits<TypeParam>::epsilon();
+
+ typedef ::android::details::TMat33<TypeParam> M33T;
+ typedef ::android::details::TVec3<TypeParam> V3T;
+ typedef ::android::details::TQuaternion<TypeParam> QuatT;
+
+ std::default_random_engine generator(112233);
+ std::uniform_real_distribution<float> distribution(-100.0, 100.0);
+ auto rand_gen = std::bind(distribution, generator);
+
+ for (size_t i = 0; i < 100; ++i) {
+ M33T r = M33T::eulerZYX(rand_gen(), rand_gen(), rand_gen());
+ QuatT qr = r.toQuaternion();
+ V3T p(rand_gen(), rand_gen(), rand_gen());
+
+ V3T pr = r * p;
+ V3T pq = qr * p;
+
+ ASSERT_NEAR(pr.x, pq.x, value_eps);
+ ASSERT_NEAR(pr.y, pq.y, value_eps);
+ ASSERT_NEAR(pr.z, pq.z, value_eps);
+ }
+}
+
+//------------------------------------------------------------------------------
+// Test to quaternion with post translation.
+TYPED_TEST(MatTestT, ToQuaternionPointTransformation44) {
+ static constexpr TypeParam value_eps =
+ TypeParam(1000) * std::numeric_limits<TypeParam>::epsilon();
+
+ typedef ::android::details::TMat44<TypeParam> M44T;
+ typedef ::android::details::TVec4<TypeParam> V4T;
+ typedef ::android::details::TVec3<TypeParam> V3T;
+ typedef ::android::details::TQuaternion<TypeParam> QuatT;
+
+ std::default_random_engine generator(992626);
+ std::uniform_real_distribution<float> distribution(-100.0, 100.0);
+ auto rand_gen = std::bind(distribution, generator);
+
+ for (size_t i = 0; i < 100; ++i) {
+ M44T r = M44T::eulerZYX(rand_gen(), rand_gen(), rand_gen());
+ QuatT qr = r.toQuaternion();
+ V3T p(rand_gen(), rand_gen(), rand_gen());
+
+ V4T pr = r * V4T(p.x, p.y, p.z, 1);
+ pr.x /= pr.w;
+ pr.y /= pr.w;
+ pr.z /= pr.w;
+ V3T pq = qr * p;
+
+ ASSERT_NEAR(pr.x, pq.x, value_eps);
+ ASSERT_NEAR(pr.y, pq.y, value_eps);
+ ASSERT_NEAR(pr.z, pq.z, value_eps);
+ }
+}
+
+#undef TEST_MATRIX_INVERSE
+
}; // namespace android
diff --git a/libs/ui/tests/quat_test.cpp b/libs/ui/tests/quat_test.cpp
new file mode 100644
index 0000000..f5cb659
--- /dev/null
+++ b/libs/ui/tests/quat_test.cpp
@@ -0,0 +1,301 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "QuatTest"
+
+#include <math.h>
+#include <stdlib.h>
+
+#include <random>
+#include <functional>
+
+#include <ui/quat.h>
+#include <ui/mat4.h>
+#include <ui/vec3.h>
+#include <ui/vec4.h>
+
+#include <gtest/gtest.h>
+
+namespace android {
+
+class QuatTest : public testing::Test {
+protected:
+};
+
+TEST_F(QuatTest, Basics) {
+ quatd q;
+ double4& v(q.xyzw);
+
+ EXPECT_EQ(sizeof(quatd), sizeof(double)*4);
+ EXPECT_EQ(reinterpret_cast<void*>(&q), reinterpret_cast<void*>(&v));
+}
+
+TEST_F(QuatTest, Constructors) {
+ quatd q0;
+ EXPECT_EQ(q0.x, 0);
+ EXPECT_EQ(q0.y, 0);
+ EXPECT_EQ(q0.z, 0);
+ EXPECT_EQ(q0.w, 0);
+
+ quatd q1(1);
+ EXPECT_EQ(q1.x, 0);
+ EXPECT_EQ(q1.y, 0);
+ EXPECT_EQ(q1.z, 0);
+ EXPECT_EQ(q1.w, 1);
+
+ quatd q2(1, 2, 3, 4);
+ EXPECT_EQ(q2.x, 2);
+ EXPECT_EQ(q2.y, 3);
+ EXPECT_EQ(q2.z, 4);
+ EXPECT_EQ(q2.w, 1);
+
+ quatd q3(q2);
+ EXPECT_EQ(q3.x, 2);
+ EXPECT_EQ(q3.y, 3);
+ EXPECT_EQ(q3.z, 4);
+ EXPECT_EQ(q3.w, 1);
+
+ quatd q4(q3.xyz, 42);
+ EXPECT_EQ(q4.x, 2);
+ EXPECT_EQ(q4.y, 3);
+ EXPECT_EQ(q4.z, 4);
+ EXPECT_EQ(q4.w, 42);
+
+ quatd q5(double3(q2.xy, 42), 24);
+ EXPECT_EQ(q5.x, 2);
+ EXPECT_EQ(q5.y, 3);
+ EXPECT_EQ(q5.z, 42);
+ EXPECT_EQ(q5.w, 24);
+
+ quatd q6;
+ q6 = 12;
+ EXPECT_EQ(q6.x, 0);
+ EXPECT_EQ(q6.y, 0);
+ EXPECT_EQ(q6.z, 0);
+ EXPECT_EQ(q6.w, 12);
+
+ quatd q7 = 1 + 2_id + 3_jd + 4_kd;
+ EXPECT_EQ(q7.x, 2);
+ EXPECT_EQ(q7.y, 3);
+ EXPECT_EQ(q7.z, 4);
+ EXPECT_EQ(q7.w, 1);
+
+ quatf qf(2);
+ EXPECT_EQ(qf.x, 0);
+ EXPECT_EQ(qf.y, 0);
+ EXPECT_EQ(qf.z, 0);
+ EXPECT_EQ(qf.w, 2);
+}
+
+TEST_F(QuatTest, Access) {
+ quatd q0(1, 2, 3, 4);
+ q0.x = 10;
+ q0.y = 20;
+ q0.z = 30;
+ q0.w = 40;
+ EXPECT_EQ(q0.x, 10);
+ EXPECT_EQ(q0.y, 20);
+ EXPECT_EQ(q0.z, 30);
+ EXPECT_EQ(q0.w, 40);
+
+ q0[0] = 100;
+ q0[1] = 200;
+ q0[2] = 300;
+ q0[3] = 400;
+ EXPECT_EQ(q0.x, 100);
+ EXPECT_EQ(q0.y, 200);
+ EXPECT_EQ(q0.z, 300);
+ EXPECT_EQ(q0.w, 400);
+
+ q0.xyz = double3(1, 2, 3);
+ EXPECT_EQ(q0.x, 1);
+ EXPECT_EQ(q0.y, 2);
+ EXPECT_EQ(q0.z, 3);
+ EXPECT_EQ(q0.w, 400);
+}
+
+TEST_F(QuatTest, UnaryOps) {
+ quatd q0(1, 2, 3, 4);
+
+ q0 += 1;
+ EXPECT_EQ(q0.x, 2);
+ EXPECT_EQ(q0.y, 3);
+ EXPECT_EQ(q0.z, 4);
+ EXPECT_EQ(q0.w, 2);
+
+ q0 -= 1;
+ EXPECT_EQ(q0.x, 2);
+ EXPECT_EQ(q0.y, 3);
+ EXPECT_EQ(q0.z, 4);
+ EXPECT_EQ(q0.w, 1);
+
+ q0 *= 2;
+ EXPECT_EQ(q0.x, 4);
+ EXPECT_EQ(q0.y, 6);
+ EXPECT_EQ(q0.z, 8);
+ EXPECT_EQ(q0.w, 2);
+
+ q0 /= 2;
+ EXPECT_EQ(q0.x, 2);
+ EXPECT_EQ(q0.y, 3);
+ EXPECT_EQ(q0.z, 4);
+ EXPECT_EQ(q0.w, 1);
+
+ quatd q1(10, 20, 30, 40);
+
+ q0 += q1;
+ EXPECT_EQ(q0.x, 22);
+ EXPECT_EQ(q0.y, 33);
+ EXPECT_EQ(q0.z, 44);
+ EXPECT_EQ(q0.w, 11);
+
+ q0 -= q1;
+ EXPECT_EQ(q0.x, 2);
+ EXPECT_EQ(q0.y, 3);
+ EXPECT_EQ(q0.z, 4);
+ EXPECT_EQ(q0.w, 1);
+
+ q1 = -q1;
+ EXPECT_EQ(q1.x, -20);
+ EXPECT_EQ(q1.y, -30);
+ EXPECT_EQ(q1.z, -40);
+ EXPECT_EQ(q1.w, -10);
+
+ // TODO(mathias): multiplies
+}
+
+TEST_F(QuatTest, ComparisonOps) {
+ quatd q0(1, 2, 3, 4);
+ quatd q1(10, 20, 30, 40);
+
+ EXPECT_TRUE(q0 == q0);
+ EXPECT_TRUE(q0 != q1);
+ EXPECT_FALSE(q0 != q0);
+ EXPECT_FALSE(q0 == q1);
+}
+
+TEST_F(QuatTest, ArithmeticOps) {
+ quatd q0(1, 2, 3, 4);
+ quatd q1(10, 20, 30, 40);
+
+ quatd q2(q0 + q1);
+ EXPECT_EQ(q2.x, 22);
+ EXPECT_EQ(q2.y, 33);
+ EXPECT_EQ(q2.z, 44);
+ EXPECT_EQ(q2.w, 11);
+
+ q0 = q1 * 2;
+ EXPECT_EQ(q0.x, 40);
+ EXPECT_EQ(q0.y, 60);
+ EXPECT_EQ(q0.z, 80);
+ EXPECT_EQ(q0.w, 20);
+
+ q0 = 2 * q1;
+ EXPECT_EQ(q0.x, 40);
+ EXPECT_EQ(q0.y, 60);
+ EXPECT_EQ(q0.z, 80);
+ EXPECT_EQ(q0.w, 20);
+
+ quatf qf(2);
+ q0 = q1 * qf;
+ EXPECT_EQ(q0.x, 40);
+ EXPECT_EQ(q0.y, 60);
+ EXPECT_EQ(q0.z, 80);
+ EXPECT_EQ(q0.w, 20);
+
+ EXPECT_EQ(1_id * 1_id, quat(-1));
+ EXPECT_EQ(1_jd * 1_jd, quat(-1));
+ EXPECT_EQ(1_kd * 1_kd, quat(-1));
+ EXPECT_EQ(1_id * 1_jd * 1_kd, quat(-1));
+}
+
+TEST_F(QuatTest, ArithmeticFunc) {
+ quatd q(1, 2, 3, 4);
+ quatd qc(conj(q));
+ __attribute__((unused)) quatd qi(inverse(q));
+ quatd qn(normalize(q));
+
+ EXPECT_EQ(qc.x, -2);
+ EXPECT_EQ(qc.y, -3);
+ EXPECT_EQ(qc.z, -4);
+ EXPECT_EQ(qc.w, 1);
+
+ EXPECT_EQ(~q, qc);
+ EXPECT_EQ(length(q), length(qc));
+ EXPECT_EQ(sqrt(30), length(q));
+ EXPECT_FLOAT_EQ(1, length(qn));
+ EXPECT_FLOAT_EQ(1, dot(qn, qn));
+
+ quatd qr = quatd::fromAxisAngle(double3(0, 0, 1), M_PI / 2);
+ EXPECT_EQ(mat4d(qr).toQuaternion(), qr);
+ EXPECT_EQ(1_id, mat4d(1_id).toQuaternion());
+ EXPECT_EQ(1_jd, mat4d(1_jd).toQuaternion());
+ EXPECT_EQ(1_kd, mat4d(1_kd).toQuaternion());
+
+
+ EXPECT_EQ(qr, log(exp(qr)));
+
+ quatd qq = qr * qr;
+ quatd q2 = pow(qr, 2);
+ EXPECT_NEAR(qq.x, q2.x, 1e-15);
+ EXPECT_NEAR(qq.y, q2.y, 1e-15);
+ EXPECT_NEAR(qq.z, q2.z, 1e-15);
+ EXPECT_NEAR(qq.w, q2.w, 1e-15);
+
+ quatd qa = quatd::fromAxisAngle(double3(0, 0, 1), 0);
+ quatd qb = quatd::fromAxisAngle(double3(0, 0, 1), M_PI / 2);
+ quatd qs = slerp(qa, qb, 0.5);
+ qr = quatd::fromAxisAngle(double3(0, 0, 1), M_PI / 4);
+ EXPECT_FLOAT_EQ(qr.x, qs.x);
+ EXPECT_FLOAT_EQ(qr.y, qs.y);
+ EXPECT_FLOAT_EQ(qr.z, qs.z);
+ EXPECT_FLOAT_EQ(qr.w, qs.w);
+
+ qs = nlerp(qa, qb, 0.5);
+ EXPECT_FLOAT_EQ(qr.x, qs.x);
+ EXPECT_FLOAT_EQ(qr.y, qs.y);
+ EXPECT_FLOAT_EQ(qr.z, qs.z);
+ EXPECT_FLOAT_EQ(qr.w, qs.w);
+}
+
+TEST_F(QuatTest, MultiplicationExhaustive) {
+ static constexpr double value_eps = double(1000) * std::numeric_limits<double>::epsilon();
+
+ std::default_random_engine generator(171717);
+ std::uniform_real_distribution<double> distribution(-10.0, 10.0);
+ auto rand_gen = std::bind(distribution, generator);
+
+ for (size_t i = 0; i < (1024 * 1024); ++i) {
+ double3 axis_a = normalize(double3(rand_gen(), rand_gen(), rand_gen()));
+ double angle_a = rand_gen();
+ quatd a = quatd::fromAxisAngle(axis_a, angle_a);
+
+ double3 axis_b = normalize(double3(rand_gen(), rand_gen(), rand_gen()));
+ double angle_b = rand_gen();
+ quatd b = quatd::fromAxisAngle(axis_b, angle_b);
+
+ quatd ab = a * b;
+ quatd ab_other(a.w * b.xyz + b.w * a.xyz + cross(a.xyz, b.xyz),
+ (a.w * b.w) - dot(a.xyz, b.xyz));
+
+ ASSERT_NEAR(ab.x, ab_other.x, value_eps);
+ ASSERT_NEAR(ab.y, ab_other.y, value_eps);
+ ASSERT_NEAR(ab.z, ab_other.z, value_eps);
+ ASSERT_NEAR(ab.w, ab_other.w, value_eps);
+ }
+}
+
+}; // namespace android
diff --git a/libs/ui/tests/vec_test.cpp b/libs/ui/tests/vec_test.cpp
index 454c999..586d1a8 100644
--- a/libs/ui/tests/vec_test.cpp
+++ b/libs/ui/tests/vec_test.cpp
@@ -14,13 +14,11 @@
* limitations under the License.
*/
-#define LOG_TAG "RegionTest"
+#define LOG_TAG "VecTest"
#include <math.h>
#include <stdlib.h>
-#include <ui/Region.h>
-#include <ui/Rect.h>
#include <ui/vec4.h>
#include <gtest/gtest.h>
@@ -37,7 +35,7 @@
EXPECT_EQ(sizeof(vec4), sizeof(float)*4);
EXPECT_EQ(sizeof(vec3), sizeof(float)*3);
EXPECT_EQ(sizeof(vec2), sizeof(float)*2);
- EXPECT_EQ((void*)&v3, (void*)&v4);
+ EXPECT_EQ(reinterpret_cast<void*>(&v3), reinterpret_cast<void*>(&v4));
}
TEST_F(VecTest, Constructors) {
@@ -53,7 +51,7 @@
EXPECT_EQ(v1.z, 1);
EXPECT_EQ(v1.w, 1);
- vec4 v2(1,2,3,4);
+ vec4 v2(1, 2, 3, 4);
EXPECT_EQ(v2.x, 1);
EXPECT_EQ(v2.y, 2);
EXPECT_EQ(v2.z, 3);
@@ -77,15 +75,16 @@
EXPECT_EQ(v5.z, 42);
EXPECT_EQ(v5.w, 24);
- tvec4<double> vd(2);
- EXPECT_EQ(vd.x, 2);
- EXPECT_EQ(vd.y, 2);
- EXPECT_EQ(vd.z, 2);
- EXPECT_EQ(vd.w, 2);
+ float4 vf(2);
+ EXPECT_EQ(vf.x, 2);
+ EXPECT_EQ(vf.y, 2);
+ EXPECT_EQ(vf.z, 2);
+ EXPECT_EQ(vf.w, 2);
}
TEST_F(VecTest, Access) {
- vec4 v0(1,2,3,4);
+ vec4 v0(1, 2, 3, 4);
+
v0.x = 10;
v0.y = 20;
v0.z = 30;
@@ -104,7 +103,7 @@
EXPECT_EQ(v0.z, 300);
EXPECT_EQ(v0.w, 400);
- v0.xyz = vec3(1,2,3);
+ v0.xyz = vec3(1, 2, 3);
EXPECT_EQ(v0.x, 1);
EXPECT_EQ(v0.y, 2);
EXPECT_EQ(v0.z, 3);
@@ -112,7 +111,7 @@
}
TEST_F(VecTest, UnaryOps) {
- vec4 v0(1,2,3,4);
+ vec4 v0(1, 2, 3, 4);
v0 += 1;
EXPECT_EQ(v0.x, 2);
@@ -164,41 +163,23 @@
EXPECT_EQ(v0.z, 3);
EXPECT_EQ(v0.w, 4);
- ++v0;
- EXPECT_EQ(v0.x, 2);
- EXPECT_EQ(v0.y, 3);
- EXPECT_EQ(v0.z, 4);
- EXPECT_EQ(v0.w, 5);
-
- ++++v0;
- EXPECT_EQ(v0.x, 4);
- EXPECT_EQ(v0.y, 5);
- EXPECT_EQ(v0.z, 6);
- EXPECT_EQ(v0.w, 7);
-
- --v1;
- EXPECT_EQ(v1.x, 9);
- EXPECT_EQ(v1.y, 19);
- EXPECT_EQ(v1.z, 29);
- EXPECT_EQ(v1.w, 39);
-
v1 = -v1;
- EXPECT_EQ(v1.x, -9);
- EXPECT_EQ(v1.y, -19);
- EXPECT_EQ(v1.z, -29);
- EXPECT_EQ(v1.w, -39);
+ EXPECT_EQ(v1.x, -10);
+ EXPECT_EQ(v1.y, -20);
+ EXPECT_EQ(v1.z, -30);
+ EXPECT_EQ(v1.w, -40);
- tvec4<double> dv(1,2,3,4);
- v1 += dv;
- EXPECT_EQ(v1.x, -8);
- EXPECT_EQ(v1.y, -17);
- EXPECT_EQ(v1.z, -26);
- EXPECT_EQ(v1.w, -35);
+ float4 fv(1, 2, 3, 4);
+ v1 += fv;
+ EXPECT_EQ(v1.x, -9);
+ EXPECT_EQ(v1.y, -18);
+ EXPECT_EQ(v1.z, -27);
+ EXPECT_EQ(v1.w, -36);
}
TEST_F(VecTest, ComparisonOps) {
- vec4 v0(1,2,3,4);
- vec4 v1(10,20,30,40);
+ vec4 v0(1, 2, 3, 4);
+ vec4 v1(10, 20, 30, 40);
EXPECT_TRUE(v0 == v0);
EXPECT_TRUE(v0 != v1);
@@ -207,8 +188,8 @@
}
TEST_F(VecTest, ArithmeticOps) {
- vec4 v0(1,2,3,4);
- vec4 v1(10,20,30,40);
+ vec4 v0(1, 2, 3, 4);
+ vec4 v1(10, 20, 30, 40);
vec4 v2(v0 + v1);
EXPECT_EQ(v2.x, 11);
@@ -228,8 +209,8 @@
EXPECT_EQ(v0.z, 60);
EXPECT_EQ(v0.w, 80);
- tvec4<double> vd(2);
- v0 = v1 * vd;
+ float4 vf(2);
+ v0 = v1 * vf;
EXPECT_EQ(v0.x, 20);
EXPECT_EQ(v0.y, 40);
EXPECT_EQ(v0.z, 60);
@@ -239,19 +220,19 @@
TEST_F(VecTest, ArithmeticFunc) {
vec3 east(1, 0, 0);
vec3 north(0, 1, 0);
- vec3 up( cross(east, north) );
- EXPECT_EQ(up, vec3(0,0,1));
+ vec3 up(cross(east, north));
+ EXPECT_EQ(up, vec3(0, 0, 1));
EXPECT_EQ(dot(east, north), 0);
EXPECT_EQ(length(east), 1);
EXPECT_EQ(distance(east, north), sqrtf(2));
- vec3 v0(1,2,3);
+ vec3 v0(1, 2, 3);
vec3 vn(normalize(v0));
EXPECT_FLOAT_EQ(1, length(vn));
EXPECT_FLOAT_EQ(length(v0), dot(v0, vn));
- tvec3<double> vd(east);
- EXPECT_EQ(length(vd), 1);
+ float3 vf(east);
+ EXPECT_EQ(length(vf), 1);
}
}; // namespace android