//----------------------------------------------------------------------------//
//                                                                            //
// ozz-animation is hosted at http://github.com/guillaumeblanc/ozz-animation  //
// and distributed under the MIT License (MIT).                               //
//                                                                            //
// Copyright (c) Guillaume Blanc                                              //
//                                                                            //
// Permission is hereby granted, free of charge, to any person obtaining a    //
// copy of this software and associated documentation files (the "Software"), //
// to deal in the Software without restriction, including without limitation  //
// the rights to use, copy, modify, merge, publish, distribute, sublicense,   //
// and/or sell copies of the Software, and to permit persons to whom the      //
// Software is furnished to do so, subject to the following conditions:       //
//                                                                            //
// The above copyright notice and this permission notice shall be included in //
// all copies or substantial portions of the Software.                        //
//                                                                            //
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR //
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   //
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    //
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER //
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING    //
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER        //
// DEALINGS IN THE SOFTWARE.                                                  //
//                                                                            //
//----------------------------------------------------------------------------//

#include "ozz/base/maths/quaternion.h"

#include "gtest/gtest.h"

#include "ozz/base/gtest_helper.h"
#include "ozz/base/maths/gtest_math_helper.h"

using ozz::math::Float3;
using ozz::math::Float4;
using ozz::math::Quaternion;

TEST(QuaternionConstant, ozz_math) {
  EXPECT_QUATERNION_EQ(Quaternion::identity(), 0.f, 0.f, 0.f, 1.f);
}

TEST(QuaternionAxisAngle, ozz_math) {
  // Expect assertions from invalid inputs
  EXPECT_ASSERTION(Quaternion::FromAxisAngle(Float3::zero(), 0.f),
                   "axis is not normalized");
  EXPECT_ASSERTION(ToAxisAngle(Quaternion(0.f, 0.f, 0.f, 2.f)), "IsNormalized");

  // Identity
  EXPECT_QUATERNION_EQ(Quaternion::FromAxisAngle(Float3::y_axis(), 0.f), 0.f,
                       0.f, 0.f, 1.f);
  EXPECT_FLOAT4_EQ(ToAxisAngle(Quaternion::identity()), 1.f, 0.f, 0.f, 0.f);

  // Other axis angles
  EXPECT_QUATERNION_EQ(
      Quaternion::FromAxisAngle(Float3::y_axis(), ozz::math::kPi_2), 0.f,
      .70710677f, 0.f, .70710677f);
  EXPECT_FLOAT4_EQ(ToAxisAngle(Quaternion(0.f, .70710677f, 0.f, .70710677f)),
                   0.f, 1.f, 0.f, ozz::math::kPi_2);

  EXPECT_QUATERNION_EQ(
      Quaternion::FromAxisAngle(Float3::y_axis(), -ozz::math::kPi_2), 0.f,
      -.70710677f, 0.f, .70710677f);
  EXPECT_QUATERNION_EQ(
      Quaternion::FromAxisAngle(-Float3::y_axis(), ozz::math::kPi_2), 0.f,
      -.70710677f, 0.f, .70710677f);
  EXPECT_FLOAT4_EQ(ToAxisAngle(Quaternion(0.f, -.70710677f, 0.f, .70710677f)),
                   0.f, -1.f, 0.f, ozz::math::kPi_2);

  EXPECT_QUATERNION_EQ(
      Quaternion::FromAxisAngle(Float3::y_axis(), 3.f * ozz::math::kPi_4), 0.f,
      0.923879504f, 0.f, 0.382683426f);
  EXPECT_FLOAT4_EQ(
      ToAxisAngle(Quaternion(0.f, 0.923879504f, 0.f, 0.382683426f)), 0.f, 1.f,
      0.f, 3.f * ozz::math::kPi_4);

  EXPECT_QUATERNION_EQ(
      Quaternion::FromAxisAngle(Float3(.819865f, .033034f, -.571604f), 1.123f),
      .4365425f, .017589169f, -.30435428f, .84645736f);
  EXPECT_FLOAT4_EQ(
      ToAxisAngle(Quaternion(.4365425f, .017589169f, -.30435428f, .84645736f)),
      .819865f, .033034f, -.571604f, 1.123f);
}

TEST(QuaternionAxisCosAngle, ozz_math) {
  // Expect assertions from invalid inputs
  EXPECT_ASSERTION(Quaternion::FromAxisCosAngle(Float3::zero(), 0.f),
                   "axis is not normalized");
  EXPECT_ASSERTION(Quaternion::FromAxisCosAngle(Float3::y_axis(), -1.0000001f),
                   "cos is not in \\[-1,1\\] range.");
  EXPECT_ASSERTION(Quaternion::FromAxisCosAngle(Float3::y_axis(), 1.0000001f),
                   "cos is not in \\[-1,1\\] range.");

  // Identity
  EXPECT_QUATERNION_EQ(Quaternion::FromAxisCosAngle(Float3::y_axis(), 1.f), 0.f,
                       0.f, 0.f, 1.f);

  // Other axis angles
  EXPECT_QUATERNION_EQ(Quaternion::FromAxisCosAngle(Float3::y_axis(),
                                                    std::cos(ozz::math::kPi_2)),
                       0.f, .70710677f, 0.f, .70710677f);
  EXPECT_QUATERNION_EQ(Quaternion::FromAxisCosAngle(-Float3::y_axis(),
                                                    std::cos(ozz::math::kPi_2)),
                       0.f, -.70710677f, 0.f, .70710677f);

  EXPECT_QUATERNION_EQ(Quaternion::FromAxisCosAngle(
                           Float3::y_axis(), std::cos(3.f * ozz::math::kPi_4)),
                       0.f, 0.923879504f, 0.f, 0.382683426f);

  EXPECT_QUATERNION_EQ(
      Quaternion::FromAxisCosAngle(Float3(.819865f, .033034f, -.571604f),
                                   std::cos(1.123f)),
      .4365425f, .017589169f, -.30435428f, .84645736f);
}

TEST(QuaternionQuaternionEuler, ozz_math) {
  // Identity
  EXPECT_QUATERNION_EQ(Quaternion::FromEuler(0.f, 0.f, 0.f), 0.f, 0.f, 0.f,
                       1.f);
  EXPECT_FLOAT3_EQ(ToEuler(Quaternion::identity()), 0.f, 0.f, 0.f);

  // Heading
  EXPECT_QUATERNION_EQ(Quaternion::FromEuler(ozz::math::kPi_2, 0.f, 0.f), 0.f,
                       .70710677f, 0.f, .70710677f);
  EXPECT_FLOAT3_EQ(ToEuler(Quaternion(0.f, .70710677f, 0.f, .70710677f)),
                   ozz::math::kPi_2, 0.f, 0.f);

  // Elevation
  EXPECT_QUATERNION_EQ(Quaternion::FromEuler(0.f, ozz::math::kPi_2, 0.f), 0.f,
                       0.f, .70710677f, .70710677f);
  EXPECT_FLOAT3_EQ(ToEuler(Quaternion(0.f, 0.f, .70710677f, .70710677f)), 0.f,
                   ozz::math::kPi_2, 0.f);

  // Bank
  EXPECT_QUATERNION_EQ(Quaternion::FromEuler(0.f, 0.f, ozz::math::kPi_2),
                       .70710677f, 0.f, 0.f, .70710677f);
  EXPECT_FLOAT3_EQ(ToEuler(Quaternion(.70710677f, 0.f, 0.f, .70710677f)), 0.f,
                   0.f, ozz::math::kPi_2);

  // Any rotation
  EXPECT_QUATERNION_EQ(
      Quaternion::FromEuler(ozz::math::kPi / 4.f, -ozz::math::kPi / 6.f,
                            ozz::math::kPi_2),
      .56098551f, .092295974f, -0.43045932f, .70105737f);
  EXPECT_FLOAT3_EQ(
      ToEuler(Quaternion(.56098551f, .092295974f, -0.43045932f, .70105737f)),
      ozz::math::kPi / 4.f, -ozz::math::kPi / 6.f, ozz::math::kPi_2);
}

TEST(QuaternionFromVectors, ozz_math) {
  // Returns identity for a 0 length vector
  EXPECT_QUATERNION_EQ(
      Quaternion::FromVectors(Float3::zero(), Float3::x_axis()), 0.f, 0.f, 0.f,
      1.f);

  // pi/2 around y
  EXPECT_QUATERNION_EQ(
      Quaternion::FromVectors(Float3::z_axis(), Float3::x_axis()), 0.f,
      0.707106769f, 0.f, 0.707106769f);

  // Non unit pi/2 around y
  EXPECT_QUATERNION_EQ(
      Quaternion::FromVectors(Float3::z_axis() * 7.f, Float3::x_axis()), 0.f,
      0.707106769f, 0.f, 0.707106769f);

  // Minus pi/2 around y
  EXPECT_QUATERNION_EQ(
      Quaternion::FromVectors(Float3::x_axis(), Float3::z_axis()), 0.f,
      -0.707106769f, 0.f, 0.707106769f);

  // pi/2 around x
  EXPECT_QUATERNION_EQ(
      Quaternion::FromVectors(Float3::y_axis(), Float3::z_axis()), 0.707106769f,
      0.f, 0.f, 0.707106769f);

  // Non unit pi/2 around x
  EXPECT_QUATERNION_EQ(
      Quaternion::FromVectors(Float3::y_axis() * 9.f, Float3::z_axis() * 13.f),
      0.707106769f, 0.f, 0.f, 0.707106769f);

  // pi/2 around z
  EXPECT_QUATERNION_EQ(
      Quaternion::FromVectors(Float3::x_axis(), Float3::y_axis()), 0.f, 0.f,
      0.707106769f, 0.707106769f);

  // pi/2 around z also
  EXPECT_QUATERNION_EQ(
      Quaternion::FromVectors(Float3(0.707106769f, 0.707106769f, 0.f),
                              Float3(-0.707106769f, 0.707106769f, 0.f)),
      0.f, 0.f, 0.707106769f, 0.707106769f);

  // Aligned vectors
  EXPECT_QUATERNION_EQ(
      Quaternion::FromVectors(Float3::x_axis(), Float3::x_axis()), 0.f, 0.f,
      0.f, 1.f);

  // Non-unit aligned vectors
  EXPECT_QUATERNION_EQ(
      Quaternion::FromVectors(Float3::x_axis(), Float3::x_axis() * 2.f), 0.f,
      0.f, 0.f, 1.f);

  // Opposed vectors
  EXPECT_QUATERNION_EQ(
      Quaternion::FromVectors(Float3::x_axis(), -Float3::x_axis()), 0.f, 1.f,
      0.f, 0);
  EXPECT_QUATERNION_EQ(
      Quaternion::FromVectors(-Float3::x_axis(), Float3::x_axis()), 0.f, -1.f,
      0.f, 0);
  EXPECT_QUATERNION_EQ(
      Quaternion::FromVectors(Float3::y_axis(), -Float3::y_axis()), 0.f, 0.f,
      1.f, 0);
  EXPECT_QUATERNION_EQ(
      Quaternion::FromVectors(-Float3::y_axis(), Float3::y_axis()), 0.f, 0.f,
      -1.f, 0);
  EXPECT_QUATERNION_EQ(
      Quaternion::FromVectors(Float3::z_axis(), -Float3::z_axis()), 0.f, -1.f,
      0.f, 0);
  EXPECT_QUATERNION_EQ(
      Quaternion::FromVectors(-Float3::z_axis(), Float3::z_axis()), 0.f, 1.f,
      0.f, 0);
  EXPECT_QUATERNION_EQ(
      Quaternion::FromVectors(Float3(0.707106769f, 0.707106769f, 0.f),
                              -Float3(0.707106769f, 0.707106769f, 0.f)),
      -0.707106769f, 0.707106769f, 0.f, 0);
  EXPECT_QUATERNION_EQ(
      Quaternion::FromVectors(Float3(0.f, 0.707106769f, 0.707106769f),
                              -Float3(0.f, 0.707106769f, 0.707106769f)),
      0.f, -0.707106769f, 0.707106769f, 0);

  // Non-unit opposed vectors
  EXPECT_QUATERNION_EQ(
      Quaternion::FromVectors(Float3(2.f, 2.f, 2.f), -Float3(2.f, 2.f, 2.f)),
      0.f, -0.707106769f, 0.707106769f, 0);
}

TEST(QuaternionFromUnitVectors, ozz_math) {
  // assert 0 length vectors
  EXPECT_ASSERTION(
      Quaternion::FromUnitVectors(Float3::zero(), Float3::x_axis()),
      "Input vectors must be normalized.");
  EXPECT_ASSERTION(
      Quaternion::FromUnitVectors(Float3::x_axis(), Float3::zero()),
      "Input vectors must be normalized.");
  // assert non unit vectors
  EXPECT_ASSERTION(
      Quaternion::FromUnitVectors(Float3::x_axis() * 2.f, Float3::x_axis()),
      "Input vectors must be normalized.");
  EXPECT_ASSERTION(
      Quaternion::FromUnitVectors(Float3::x_axis(), Float3::x_axis() * .5f),
      "Input vectors must be normalized.");

  // pi/2 around y
  EXPECT_QUATERNION_EQ(
      Quaternion::FromUnitVectors(Float3::z_axis(), Float3::x_axis()), 0.f,
      0.707106769f, 0.f, 0.707106769f);

  // Minus pi/2 around y
  EXPECT_QUATERNION_EQ(
      Quaternion::FromUnitVectors(Float3::x_axis(), Float3::z_axis()), 0.f,
      -0.707106769f, 0.f, 0.707106769f);

  // pi/2 around x
  EXPECT_QUATERNION_EQ(
      Quaternion::FromUnitVectors(Float3::y_axis(), Float3::z_axis()),
      0.707106769f, 0.f, 0.f, 0.707106769f);

  // pi/2 around z
  EXPECT_QUATERNION_EQ(
      Quaternion::FromUnitVectors(Float3::x_axis(), Float3::y_axis()), 0.f, 0.f,
      0.707106769f, 0.707106769f);

  // pi/2 around z also
  EXPECT_QUATERNION_EQ(
      Quaternion::FromUnitVectors(Float3(0.707106769f, 0.707106769f, 0.f),
                                  Float3(-0.707106769f, 0.707106769f, 0.f)),
      0.f, 0.f, 0.707106769f, 0.707106769f);

  // Aligned vectors
  EXPECT_QUATERNION_EQ(
      Quaternion::FromUnitVectors(Float3::x_axis(), Float3::x_axis()), 0.f, 0.f,
      0.f, 1.f);

  // Opposed vectors
  EXPECT_QUATERNION_EQ(
      Quaternion::FromUnitVectors(Float3::x_axis(), -Float3::x_axis()), 0.f,
      1.f, 0.f, 0);
  EXPECT_QUATERNION_EQ(
      Quaternion::FromUnitVectors(-Float3::x_axis(), Float3::x_axis()), 0.f,
      -1.f, 0.f, 0);
  EXPECT_QUATERNION_EQ(
      Quaternion::FromUnitVectors(Float3::y_axis(), -Float3::y_axis()), 0.f,
      0.f, 1.f, 0);
  EXPECT_QUATERNION_EQ(
      Quaternion::FromUnitVectors(-Float3::y_axis(), Float3::y_axis()), 0.f,
      0.f, -1.f, 0);
  EXPECT_QUATERNION_EQ(
      Quaternion::FromUnitVectors(Float3::z_axis(), -Float3::z_axis()), 0.f,
      -1.f, 0.f, 0);
  EXPECT_QUATERNION_EQ(
      Quaternion::FromUnitVectors(-Float3::z_axis(), Float3::z_axis()), 0.f,
      1.f, 0.f, 0);
  EXPECT_QUATERNION_EQ(
      Quaternion::FromUnitVectors(Float3(0.707106769f, 0.707106769f, 0.f),
                                  -Float3(0.707106769f, 0.707106769f, 0.f)),
      -0.707106769f, 0.707106769f, 0.f, 0);
  EXPECT_QUATERNION_EQ(
      Quaternion::FromUnitVectors(Float3(0.f, 0.707106769f, 0.707106769f),
                                  -Float3(0.f, 0.707106769f, 0.707106769f)),
      0.f, -0.707106769f, 0.707106769f, 0);
}

TEST(QuaternionCompare, ozz_math) {
  EXPECT_TRUE(Quaternion::identity() == Quaternion(0.f, 0.f, 0.f, 1.f));
  EXPECT_TRUE(Quaternion::identity() != Quaternion(1.f, 0.f, 0.f, 0.f));
  EXPECT_TRUE(Compare(Quaternion::identity(), Quaternion::identity(), std::cos(.5f * 0.f)));
  EXPECT_TRUE(Compare(Quaternion::identity(),
                      Quaternion::FromEuler(0.f, 0.f, ozz::math::kPi / 100.f),
                      std::cos(.5f * ozz::math::kPi / 50.f)));
  EXPECT_TRUE(Compare(Quaternion::identity(),
                      -Quaternion::FromEuler(0.f, 0.f, ozz::math::kPi / 100.f),
                      std::cos(.5f * ozz::math::kPi / 50.f)));
  EXPECT_FALSE(Compare(Quaternion::identity(),
                       Quaternion::FromEuler(0.f, 0.f, ozz::math::kPi / 100.f),
                       std::cos(.5f * ozz::math::kPi / 200.f)));
}

TEST(QuaternionArithmetic, ozz_math) {
  const Quaternion a(.70710677f, 0.f, 0.f, .70710677f);
  const Quaternion b(0.f, .70710677f, 0.f, .70710677f);
  const Quaternion c(0.f, .70710677f, 0.f, -.70710677f);
  const Quaternion denorm(1.414212f, 0.f, 0.f, 1.414212f);

  EXPECT_TRUE(IsNormalized(a));
  EXPECT_TRUE(IsNormalized(b));
  EXPECT_TRUE(IsNormalized(c));
  EXPECT_FALSE(IsNormalized(denorm));

  const Quaternion conjugate = Conjugate(a);
  EXPECT_QUATERNION_EQ(conjugate, -a.x, -a.y, -a.z, a.w);
  EXPECT_TRUE(IsNormalized(conjugate));

  const Quaternion negate = -a;
  EXPECT_QUATERNION_EQ(negate, -a.x, -a.y, -a.z, -a.w);
  EXPECT_TRUE(IsNormalized(negate));

  const Quaternion add = a + b;
  EXPECT_QUATERNION_EQ(add, .70710677f, .70710677f, 0.f, 1.41421354f);

  const Quaternion mul0 = a * conjugate;
  EXPECT_QUATERNION_EQ(mul0, 0.f, 0.f, 0.f, 1.f);
  EXPECT_TRUE(IsNormalized(mul0));

  const Quaternion muls = a * 2.f;
  EXPECT_QUATERNION_EQ(muls, 1.41421354f, 0.f, 0.f, 1.41421354f);

  const Quaternion mul1 = conjugate * a;
  EXPECT_QUATERNION_EQ(mul1, 0.f, 0.f, 0.f, 1.f);
  EXPECT_TRUE(IsNormalized(mul1));

  const Quaternion q1234(1.f, 2.f, 3.f, 4.f);
  const Quaternion q5678(5.f, 6.f, 7.f, 8.f);
  const Quaternion mul12345678 = q1234 * q5678;
  EXPECT_QUATERNION_EQ(mul12345678, 24.f, 48.f, 48.f, -6.f);

  EXPECT_ASSERTION(Normalize(Quaternion(0.f, 0.f, 0.f, 0.f)),
                   "is not normalizable");
  const Quaternion normalize = Normalize(denorm);
  EXPECT_TRUE(IsNormalized(normalize));
  EXPECT_QUATERNION_EQ(normalize, .7071068f, 0.f, 0.f, .7071068f);

  EXPECT_ASSERTION(NormalizeSafe(denorm, Quaternion(0.f, 0.f, 0.f, 0.f)),
                   "_safer is not normalized");
  const Quaternion normalize_safe =
      NormalizeSafe(denorm, Quaternion::identity());
  EXPECT_TRUE(IsNormalized(normalize_safe));
  EXPECT_QUATERNION_EQ(normalize_safe, .7071068f, 0.f, 0.f, .7071068f);

  const Quaternion normalize_safer =
      NormalizeSafe(Quaternion(0.f, 0.f, 0.f, 0.f), Quaternion::identity());
  EXPECT_TRUE(IsNormalized(normalize_safer));
  EXPECT_QUATERNION_EQ(normalize_safer, 0.f, 0.f, 0.f, 1.f);

  const Quaternion lerp_0 = Lerp(a, b, 0.f);
  EXPECT_QUATERNION_EQ(lerp_0, a.x, a.y, a.z, a.w);

  const Quaternion lerp_1 = Lerp(a, b, 1.f);
  EXPECT_QUATERNION_EQ(lerp_1, b.x, b.y, b.z, b.w);

  const Quaternion lerp_0_2 = Lerp(a, b, .2f);
  EXPECT_QUATERNION_EQ(lerp_0_2, .5656853f, .1414213f, 0.f, .7071068f);

  const Quaternion nlerp_0 = NLerp(a, b, 0.f);
  EXPECT_TRUE(IsNormalized(nlerp_0));
  EXPECT_QUATERNION_EQ(nlerp_0, a.x, a.y, a.z, a.w);

  const Quaternion nlerp_1 = NLerp(a, b, 1.f);
  EXPECT_TRUE(IsNormalized(nlerp_1));
  EXPECT_QUATERNION_EQ(nlerp_1, b.x, b.y, b.z, b.w);

  const Quaternion nlerp_0_2 = NLerp(a, b, .2f);
  EXPECT_TRUE(IsNormalized(nlerp_0_2));
  EXPECT_QUATERNION_EQ(nlerp_0_2, .6172133f, .1543033f, 0.f, .7715167f);

  EXPECT_ASSERTION(SLerp(denorm, b, 0.f), "IsNormalized\\(_a\\)");
  EXPECT_ASSERTION(SLerp(a, denorm, 0.f), "IsNormalized\\(_b\\)");

  const Quaternion slerp_0 = SLerp(a, b, 0.f);
  EXPECT_TRUE(IsNormalized(slerp_0));
  EXPECT_QUATERNION_EQ(slerp_0, a.x, a.y, a.z, a.w);

  const Quaternion slerp_c_0 = SLerp(a, c, 0.f);
  EXPECT_TRUE(IsNormalized(slerp_c_0));
  EXPECT_QUATERNION_EQ(slerp_c_0, a.x, a.y, a.z, a.w);

  const Quaternion slerp_c_1 = SLerp(a, c, 1.f);
  EXPECT_TRUE(IsNormalized(slerp_c_1));
  EXPECT_QUATERNION_EQ(slerp_c_1, c.x, c.y, c.z, c.w);

  const Quaternion slerp_c_0_6 = SLerp(a, c, .6f);
  EXPECT_TRUE(IsNormalized(slerp_c_0_6));
  EXPECT_QUATERNION_EQ(slerp_c_0_6, .6067752f, .7765344f, 0.f, -.1697592f);

  const Quaternion slerp_1 = SLerp(a, b, 1.f);
  EXPECT_TRUE(IsNormalized(slerp_1));
  EXPECT_QUATERNION_EQ(slerp_1, b.x, b.y, b.z, b.w);

  const Quaternion slerp_0_2 = SLerp(a, b, .2f);
  EXPECT_TRUE(IsNormalized(slerp_0_2));
  EXPECT_QUATERNION_EQ(slerp_0_2, .6067752f, .1697592f, 0.f, .7765344f);

  const Quaternion slerp_0_7 = SLerp(a, b, .7f);
  EXPECT_TRUE(IsNormalized(slerp_0_7));
  EXPECT_QUATERNION_EQ(slerp_0_7, .2523113f, .5463429f, 0.f, .798654f);

  const float dot = Dot(a, b);
  EXPECT_FLOAT_EQ(dot, .5f);
}

TEST(QuaternionTransformVector, ozz_math) {
  // 0 length
  EXPECT_FLOAT3_EQ(
      TransformVector(Quaternion::FromAxisAngle(Float3::y_axis(), 0.f),
                      Float3::zero()),
      0, 0, 0);

  // Unit length
  EXPECT_FLOAT3_EQ(
      TransformVector(Quaternion::FromAxisAngle(Float3::y_axis(), 0.f),
                      Float3::z_axis()),
      0, 0, 1);
  EXPECT_FLOAT3_EQ(TransformVector(Quaternion::FromAxisAngle(Float3::y_axis(),
                                                             ozz::math::kPi_2),
                                   Float3::y_axis()),
                   0, 1, 0);
  EXPECT_FLOAT3_EQ(TransformVector(Quaternion::FromAxisAngle(Float3::y_axis(),
                                                             ozz::math::kPi_2),
                                   Float3::x_axis()),
                   0, 0, -1);
  EXPECT_FLOAT3_EQ(TransformVector(Quaternion::FromAxisAngle(Float3::y_axis(),
                                                             ozz::math::kPi_2),
                                   Float3::z_axis()),
                   1, 0, 0);

  // Non unit
  EXPECT_FLOAT3_EQ(TransformVector(Quaternion::FromAxisAngle(Float3::z_axis(),
                                                             ozz::math::kPi_2),
                                   Float3::x_axis() * 2),
                   0, 2, 0);
}