diff --git a/libs/ui/Android.bp b/libs/ui/Android.bp
index ea18644..d1bfa18 100644
--- a/libs/ui/Android.bp
+++ b/libs/ui/Android.bp
@@ -78,9 +78,13 @@
 
     static_libs: [
         "libarect",
+        "libmath",
     ],
 
-    export_static_lib_headers: ["libarect"],
+    export_static_lib_headers: [
+        "libarect",
+        "libmath",
+    ],
 }
 
 subdirs = ["tests"]
diff --git a/libs/ui/tests/Android.bp b/libs/ui/tests/Android.bp
index c4f34d5..6733505 100644
--- a/libs/ui/tests/Android.bp
+++ b/libs/ui/tests/Android.bp
@@ -21,26 +21,6 @@
 }
 
 cc_test {
-    name: "vec_test",
-    srcs: ["vec_test.cpp"],
-}
-
-cc_test {
-    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"],
-}
-
-cc_test {
     name: "colorspace_test",
     shared_libs: ["libui"],
     srcs: ["colorspace_test.cpp"],
diff --git a/libs/ui/tests/half_test.cpp b/libs/ui/tests/half_test.cpp
deleted file mode 100644
index b2a5e5c..0000000
--- a/libs/ui/tests/half_test.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * 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(2UL, 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
deleted file mode 100644
index 0f8e631..0000000
--- a/libs/ui/tests/mat_test.cpp
+++ /dev/null
@@ -1,692 +0,0 @@
-/*
- * 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 "MatTest"
-
-#include <stdlib.h>
-
-#include <limits>
-#include <random>
-#include <functional>
-
-#include <gtest/gtest.h>
-
-#include <ui/mat2.h>
-#include <ui/mat4.h>
-
-namespace android {
-
-class MatTest : public testing::Test {
-protected:
-};
-
-TEST_F(MatTest, Basics) {
-    mat4 m0;
-    EXPECT_EQ(sizeof(mat4), sizeof(float)*16);
-}
-
-TEST_F(MatTest, ComparisonOps) {
-    mat4 m0;
-    mat4 m1(2);
-
-    EXPECT_TRUE(m0 == m0);
-    EXPECT_TRUE(m0 != m1);
-    EXPECT_FALSE(m0 != m0);
-    EXPECT_FALSE(m0 == m1);
-}
-
-TEST_F(MatTest, Constructors) {
-    mat4 m0;
-    ASSERT_EQ(m0[0].x, 1);
-    ASSERT_EQ(m0[0].y, 0);
-    ASSERT_EQ(m0[0].z, 0);
-    ASSERT_EQ(m0[0].w, 0);
-    ASSERT_EQ(m0[1].x, 0);
-    ASSERT_EQ(m0[1].y, 1);
-    ASSERT_EQ(m0[1].z, 0);
-    ASSERT_EQ(m0[1].w, 0);
-    ASSERT_EQ(m0[2].x, 0);
-    ASSERT_EQ(m0[2].y, 0);
-    ASSERT_EQ(m0[2].z, 1);
-    ASSERT_EQ(m0[2].w, 0);
-    ASSERT_EQ(m0[3].x, 0);
-    ASSERT_EQ(m0[3].y, 0);
-    ASSERT_EQ(m0[3].z, 0);
-    ASSERT_EQ(m0[3].w, 1);
-
-    mat4 m1(2);
-    mat4 m2(vec4(2));
-    mat4 m3(m2);
-
-    EXPECT_EQ(m1, m2);
-    EXPECT_EQ(m2, m3);
-    EXPECT_EQ(m3, m1);
-
-    mat4 m4(vec4(1), vec4(2), vec4(3), vec4(4));
-}
-
-TEST_F(MatTest, ArithmeticOps) {
-    mat4 m0;
-    mat4 m1(2);
-    mat4 m2(vec4(2));
-
-    m1 += m2;
-    EXPECT_EQ(mat4(4), m1);
-
-    m2 -= m1;
-    EXPECT_EQ(mat4(-2), m2);
-
-    m1 *= 2;
-    EXPECT_EQ(mat4(8), m1);
-
-    m1 /= 2;
-    EXPECT_EQ(mat4(4), m1);
-
-    m0 = -m0;
-    EXPECT_EQ(mat4(-1), m0);
-}
-
-TEST_F(MatTest, UnaryOps) {
-    const mat4 identity;
-    mat4 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;
-    EXPECT_EQ(identity, m0);
-}
-
-TEST_F(MatTest, MiscOps) {
-    const mat4 identity;
-    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));
-    EXPECT_EQ(m1, transpose(m2));
-    EXPECT_EQ(m2, transpose(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 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]);
-
-    mat4 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);
-
-
-    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
deleted file mode 100644
index f5cb659..0000000
--- a/libs/ui/tests/quat_test.cpp
+++ /dev/null
@@ -1,301 +0,0 @@
-/*
- * 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
deleted file mode 100644
index 7c749a7..0000000
--- a/libs/ui/tests/vec_test.cpp
+++ /dev/null
@@ -1,270 +0,0 @@
-/*
- * 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 "VecTest"
-
-#include <math.h>
-#include <stdlib.h>
-
-#include <ui/vec4.h>
-
-#include <gtest/gtest.h>
-
-namespace android {
-
-class VecTest : public testing::Test {
-};
-
-TEST_F(VecTest, Basics) {
-    vec4 v4;
-    vec3& v3(v4.xyz);
-
-    EXPECT_EQ(sizeof(vec4), sizeof(float)*4);
-    EXPECT_EQ(sizeof(vec3), sizeof(float)*3);
-    EXPECT_EQ(sizeof(vec2), sizeof(float)*2);
-    EXPECT_EQ(reinterpret_cast<void*>(&v3), reinterpret_cast<void*>(&v4));
-}
-
-TEST_F(VecTest, Constructors) {
-    vec4 v0;
-    EXPECT_EQ(v0.x, 0);
-    EXPECT_EQ(v0.y, 0);
-    EXPECT_EQ(v0.z, 0);
-    EXPECT_EQ(v0.w, 0);
-
-    vec4 v1(1);
-    EXPECT_EQ(v1.x, 1);
-    EXPECT_EQ(v1.y, 1);
-    EXPECT_EQ(v1.z, 1);
-    EXPECT_EQ(v1.w, 1);
-
-    vec4 v2(1, 2, 3, 4);
-    EXPECT_EQ(v2.x, 1);
-    EXPECT_EQ(v2.y, 2);
-    EXPECT_EQ(v2.z, 3);
-    EXPECT_EQ(v2.w, 4);
-
-    vec4 v3(v2);
-    EXPECT_EQ(v3.x, 1);
-    EXPECT_EQ(v3.y, 2);
-    EXPECT_EQ(v3.z, 3);
-    EXPECT_EQ(v3.w, 4);
-
-    vec4 v4(v3.xyz, 42);
-    EXPECT_EQ(v4.x, 1);
-    EXPECT_EQ(v4.y, 2);
-    EXPECT_EQ(v4.z, 3);
-    EXPECT_EQ(v4.w, 42);
-
-    vec4 v5(vec3(v2.xy, 42), 24);
-    EXPECT_EQ(v5.x, 1);
-    EXPECT_EQ(v5.y, 2);
-    EXPECT_EQ(v5.z, 42);
-    EXPECT_EQ(v5.w, 24);
-
-    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);
-
-    v0.x = 10;
-    v0.y = 20;
-    v0.z = 30;
-    v0.w = 40;
-    EXPECT_EQ(v0.x, 10);
-    EXPECT_EQ(v0.y, 20);
-    EXPECT_EQ(v0.z, 30);
-    EXPECT_EQ(v0.w, 40);
-
-    v0[0] = 100;
-    v0[1] = 200;
-    v0[2] = 300;
-    v0[3] = 400;
-    EXPECT_EQ(v0.x, 100);
-    EXPECT_EQ(v0.y, 200);
-    EXPECT_EQ(v0.z, 300);
-    EXPECT_EQ(v0.w, 400);
-
-    v0.xyz = vec3(1, 2, 3);
-    EXPECT_EQ(v0.x, 1);
-    EXPECT_EQ(v0.y, 2);
-    EXPECT_EQ(v0.z, 3);
-    EXPECT_EQ(v0.w, 400);
-}
-
-TEST_F(VecTest, UnaryOps) {
-    vec4 v0(1, 2, 3, 4);
-
-    v0 += 1;
-    EXPECT_EQ(v0.x, 2);
-    EXPECT_EQ(v0.y, 3);
-    EXPECT_EQ(v0.z, 4);
-    EXPECT_EQ(v0.w, 5);
-
-    v0 -= 1;
-    EXPECT_EQ(v0.x, 1);
-    EXPECT_EQ(v0.y, 2);
-    EXPECT_EQ(v0.z, 3);
-    EXPECT_EQ(v0.w, 4);
-
-    v0 *= 2;
-    EXPECT_EQ(v0.x, 2);
-    EXPECT_EQ(v0.y, 4);
-    EXPECT_EQ(v0.z, 6);
-    EXPECT_EQ(v0.w, 8);
-
-    v0 /= 2;
-    EXPECT_EQ(v0.x, 1);
-    EXPECT_EQ(v0.y, 2);
-    EXPECT_EQ(v0.z, 3);
-    EXPECT_EQ(v0.w, 4);
-
-    vec4 v1(10, 20, 30, 40);
-
-    v0 += v1;
-    EXPECT_EQ(v0.x, 11);
-    EXPECT_EQ(v0.y, 22);
-    EXPECT_EQ(v0.z, 33);
-    EXPECT_EQ(v0.w, 44);
-
-    v0 -= v1;
-    EXPECT_EQ(v0.x, 1);
-    EXPECT_EQ(v0.y, 2);
-    EXPECT_EQ(v0.z, 3);
-    EXPECT_EQ(v0.w, 4);
-
-    v0 *= v1;
-    EXPECT_EQ(v0.x, 10);
-    EXPECT_EQ(v0.y, 40);
-    EXPECT_EQ(v0.z, 90);
-    EXPECT_EQ(v0.w, 160);
-
-    v0 /= v1;
-    EXPECT_EQ(v0.x, 1);
-    EXPECT_EQ(v0.y, 2);
-    EXPECT_EQ(v0.z, 3);
-    EXPECT_EQ(v0.w, 4);
-
-    v1 = -v1;
-    EXPECT_EQ(v1.x, -10);
-    EXPECT_EQ(v1.y, -20);
-    EXPECT_EQ(v1.z, -30);
-    EXPECT_EQ(v1.w, -40);
-
-    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);
-
-    EXPECT_TRUE(v0 == v0);
-    EXPECT_TRUE(v0 != v1);
-    EXPECT_FALSE(v0 != v0);
-    EXPECT_FALSE(v0 == v1);
-}
-
-TEST_F(VecTest, ComparisonFunctions) {
-    vec4 v0(1, 2, 3, 4);
-    vec4 v1(10, 20, 30, 40);
-
-    EXPECT_TRUE(all(equal(v0, v0)));
-    EXPECT_TRUE(all(notEqual(v0, v1)));
-    EXPECT_FALSE(any(notEqual(v0, v0)));
-    EXPECT_FALSE(any(equal(v0, v1)));
-
-    EXPECT_FALSE(all(lessThan(v0, v0)));
-    EXPECT_TRUE(all(lessThanEqual(v0, v0)));
-    EXPECT_FALSE(all(greaterThan(v0, v0)));
-    EXPECT_TRUE(all(greaterThanEqual(v0, v0)));
-    EXPECT_TRUE(all(lessThan(v0, v1)));
-    EXPECT_TRUE(all(greaterThan(v1, v0)));
-}
-
-TEST_F(VecTest, ArithmeticOps) {
-    vec4 v0(1, 2, 3, 4);
-    vec4 v1(10, 20, 30, 40);
-
-    vec4 v2(v0 + v1);
-    EXPECT_EQ(v2.x, 11);
-    EXPECT_EQ(v2.y, 22);
-    EXPECT_EQ(v2.z, 33);
-    EXPECT_EQ(v2.w, 44);
-
-    v0 = v1 * 2;
-    EXPECT_EQ(v0.x, 20);
-    EXPECT_EQ(v0.y, 40);
-    EXPECT_EQ(v0.z, 60);
-    EXPECT_EQ(v0.w, 80);
-
-    v0 = 2 * v1;
-    EXPECT_EQ(v0.x, 20);
-    EXPECT_EQ(v0.y, 40);
-    EXPECT_EQ(v0.z, 60);
-    EXPECT_EQ(v0.w, 80);
-
-    float4 vf(2);
-    v0 = v1 * vf;
-    EXPECT_EQ(v0.x, 20);
-    EXPECT_EQ(v0.y, 40);
-    EXPECT_EQ(v0.z, 60);
-    EXPECT_EQ(v0.w, 80);
-}
-
-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));
-    EXPECT_EQ(dot(east, north), 0);
-    EXPECT_EQ(length(east), 1);
-    EXPECT_EQ(distance(east, north), sqrtf(2));
-
-    vec3 v0(1, 2, 3);
-    vec3 vn(normalize(v0));
-    EXPECT_FLOAT_EQ(1, length(vn));
-    EXPECT_FLOAT_EQ(length(v0), dot(v0, vn));
-
-    float3 vf(east);
-    EXPECT_EQ(length(vf), 1);
-
-    EXPECT_TRUE(any(vec3(0, 0, 1)));
-    EXPECT_FALSE(any(vec3(0, 0, 0)));
-
-    EXPECT_TRUE(all(vec3(1, 1, 1)));
-    EXPECT_FALSE(all(vec3(0, 0, 1)));
-
-    EXPECT_TRUE(any(bool3(false, false, true)));
-    EXPECT_FALSE(any(bool3(false)));
-
-    EXPECT_TRUE(all(bool3(true)));
-    EXPECT_FALSE(all(bool3(false, false, true)));
-
-    std::function<bool(float)> p = [](auto v) -> bool { return v > 0.0f; };
-    EXPECT_TRUE(all(map(vec3(1, 2, 3), p)));
-}
-
-}; // namespace android