#if GTEST
#include <gtest/gtest.h>
#include <limits>
#include <math.h>

#include "Vector2.h"

#define FLOAT_INFINITY std::numeric_limits<float>::infinity()

TEST(Vector2, FromPolar) {
  Vector2 v;
  PolarSingle p;
  Vector2 r;

  v = Vector2(0, 1);
  p = PolarSingle::FromVector2(v);
  r = Vector2(p);

  EXPECT_FLOAT_EQ(r.x, 0.0F) << "FromPolar(0 1)";
  EXPECT_FLOAT_EQ(r.y, 1.0F) << "FromPolar(0 1)";

  v = Vector2(1, 0);
  p = PolarSingle::FromVector2(v);
  r = Vector2(p);

  EXPECT_FLOAT_EQ(r.x, 1.0F) << "FromPolar(1 0)";
  EXPECT_NEAR(r.y, 0.0F, 1.0e-07) << "FromPolar(1 0)";

  v = Vector2(0, 0);
  p = PolarSingle::FromVector2(v);
  r = Vector2(p);

  EXPECT_FLOAT_EQ(r.x, 0.0F) << "FromPolar(0 0)";
  EXPECT_FLOAT_EQ(r.y, 0.0F) << "FromPolar(0 0)";
}

TEST(Vector2, Magnitude) {
  Vector2 v = Vector2(1, 2);
  float m = 0;

  m = v.magnitude();
  EXPECT_FLOAT_EQ(m, 2.236068F) << "v.magnitude 1 2";

  m = Vector2::Magnitude(v);
  EXPECT_FLOAT_EQ(m, 2.236068F) << "Vector2::Magnitude 1 2";

  v = Vector2(-1, -2);
  m = v.magnitude();
  EXPECT_FLOAT_EQ(m, 2.236068F) << "v.magnitude -1 -2";

  v = Vector2(0, 0);
  m = v.magnitude();
  EXPECT_FLOAT_EQ(m, 0) << "v.magnitude 0 0 ";

  if (std::numeric_limits<float>::is_iec559) {
    v = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
    m = v.magnitude();
    EXPECT_FLOAT_EQ(m, FLOAT_INFINITY) << "v.magnitude INFINITY INFINITY ";

    v = Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY);
    m = v.magnitude();
    EXPECT_FLOAT_EQ(m, FLOAT_INFINITY) << "v.magnitude -INFINITY -INFINITY ";
  }
}

TEST(Vector2, SqrMagnitude) {
  Vector2 v = Vector2(1, 2);
  float m = 0;

  m = v.sqrMagnitude();
  EXPECT_FLOAT_EQ(m, 5) << "v.sqrMagnitude 1 2";

  m = Vector2::SqrMagnitude(v);
  EXPECT_FLOAT_EQ(m, 5) << "Vector2::SqrMagnitude 1 2";

  v = Vector2(-1, -2);
  m = v.sqrMagnitude();
  EXPECT_FLOAT_EQ(m, 5) << "v.sqrMagnitude -1 -2";

  v = Vector2(0, 0);
  m = v.sqrMagnitude();
  EXPECT_FLOAT_EQ(m, 0) << "v.sqrMagnitude 0 0 ";

  if (std::numeric_limits<float>::is_iec559) {
    v = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
    m = v.sqrMagnitude();
    EXPECT_FLOAT_EQ(m, FLOAT_INFINITY) << "v.sqrMagnitude INFINITY INFINITY ";

    v = Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY);
    m = v.sqrMagnitude();
    EXPECT_FLOAT_EQ(m, FLOAT_INFINITY) << "v.sqrMagnitude -INFINITY -INFINITY ";
  }
}

TEST(Vector2, Normalize) {
  bool r = false;

  Vector2 v1 = Vector2(0, 2);
  Vector2 v = Vector2::zero;

  v = v1.normalized();
  EXPECT_TRUE(v == Vector2(0, 1)) << "v.normalized 0 2";

  v = Vector2::Normalize(v1);
  EXPECT_TRUE(v == Vector2(0, 1)) << "Vector3::Normalize 0 2";

  v1 = Vector2(0, -2);
  v = v1.normalized();
  EXPECT_TRUE(v == Vector2(0, -1)) << "v.normalized 0 -2";

  v1 = Vector2(0, 0);
  v = v1.normalized();
  EXPECT_TRUE(v == Vector2(0, 0)) << "v.normalized 0 0";

  if (std::numeric_limits<float>::is_iec559) {
    v1 = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
    v = v1.normalized();
    r = isnan(v.x) && isnan(v.y);
    EXPECT_TRUE(r) << "v.normalized INFINITY INFINITY";

    v1 = Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY);
    v = v1.normalized();
    r = isnan(v.x) && isnan(v.y);
    EXPECT_TRUE(r) << "v.normalized -INFINITY -INFINITY";
  }
}

TEST(Vector2, Negate) {
  Vector2 v1 = Vector2(4, 5);
  Vector2 v = Vector2::zero;

  v = -v1;
  EXPECT_TRUE(v == Vector2(-4, -5)) << "- 4 5";

  v1 = Vector2(-4, -5);
  v = -v1;
  EXPECT_TRUE(v == Vector2(4, 5)) << "- -4 -5";

  v1 = Vector2(0, 0);
  v = -v1;
  EXPECT_TRUE(v == Vector2(0, 0)) << "- 0 0";

  if (std::numeric_limits<float>::is_iec559) {
    v1 = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
    v = -v1;
    EXPECT_TRUE(v == Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY))
        << "- INFINITY INFINITY";

    v1 = Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY);
    v = -v1;
    EXPECT_TRUE(v == Vector2(FLOAT_INFINITY, FLOAT_INFINITY))
        << "- -INFINITY -INFINITY";
  }
}

TEST(Vector2, Subtract) {
  Vector2 v1 = Vector2(4, 5);
  Vector2 v2 = Vector2(1, 2);
  Vector2 v = Vector2::zero;

  v = v1 - v2;
  EXPECT_TRUE(v == Vector2(3, 3)) << "4 5 - 1 2";

  v2 = Vector2(-1, -2);
  v = v1 - v2;
  EXPECT_TRUE(v == Vector2(5, 7)) << "4 5 - -1 -2";

  v2 = Vector2(4, 5);
  v = v1 - v2;
  EXPECT_TRUE(v == Vector2(0, 0)) << "4 5 - 4 5";
  v = v1;
  v -= v2;
  EXPECT_TRUE(v == Vector2(0, 0)) << "4 5 - 4 5";

  v2 = Vector2(0, 0);
  v = v1 - v2;
  EXPECT_TRUE(v == Vector2(4, 5)) << "4 5 - 0 0";

  v -= v2;
  EXPECT_TRUE(v == Vector2(4, 5)) << "4 5 - 0 0";

  if (std::numeric_limits<float>::is_iec559) {
    v2 = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
    v = v1 - v2;
    EXPECT_TRUE(v == Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY))
        << "4 5 - INFINITY INFINITY";

    v2 = Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY);
    v = v1 - v2;
    EXPECT_TRUE(v == Vector2(FLOAT_INFINITY, FLOAT_INFINITY))
        << "4 5 - -INFINITY -INFINITY";
  }
}

TEST(Vector2, Addition) {
  Vector2 v1 = Vector2(4, 5);
  Vector2 v2 = Vector2(1, 2);
  Vector2 v = Vector2::zero;

  v = v1 + v2;
  EXPECT_TRUE(v == Vector2(5, 7)) << "4 5 + 1 2";

  v2 = Vector2(-1, -2);
  v = v1 + v2;
  EXPECT_TRUE(v == Vector2(3, 3)) << "4 5 + -1 -2";
  v = v1;
  v += v2;
  EXPECT_TRUE(v == Vector2(3, 3)) << "4 5 + -1 -2";

  v2 = Vector2(0, 0);
  v = v1 + v2;
  EXPECT_TRUE(v == Vector2(4, 5)) << "4 5 + 0 0";
  v += v2;
  EXPECT_TRUE(v == Vector2(4, 5)) << "4 5 + 0 0";

  if (std::numeric_limits<float>::is_iec559) {
    v2 = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
    v = v1 + v2;
    EXPECT_TRUE(v == Vector2(FLOAT_INFINITY, FLOAT_INFINITY))
        << "4 5 + INFINITY INFINITY";

    v2 = Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY);
    v = v1 + v2;
    EXPECT_TRUE(v == Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY))
        << "4 5 + -INFINITY -INFINITY";
  }
}

TEST(Vector2, Scale) {
  Vector2 v1 = Vector2(4, 5);
  Vector2 v2 = Vector2(1, 2);
  Vector2 v = Vector2::zero;

  v = Vector2::Scale(v1, v2);
  EXPECT_TRUE(v == Vector2(4, 10)) << "Scale 4 5 , 1 2";

  v2 = Vector2(-1, -2);
  v = Vector2::Scale(v1, v2);
  EXPECT_TRUE(v == Vector2(-4, -10)) << "Scale 4 5 , -1 -2";

  v2 = Vector2(0, 0);
  v = Vector2::Scale(v1, v2);
  EXPECT_TRUE(v == Vector2(0, 0)) << "Scale 4 5 , 0 0";

  if (std::numeric_limits<float>::is_iec559) {
    v2 = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
    v = Vector2::Scale(v1, v2);
    EXPECT_TRUE(v == Vector2(FLOAT_INFINITY, FLOAT_INFINITY))
        << "4 5 + INFINITY INFINITY";

    v2 = Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY);
    v = Vector2::Scale(v1, v2);
    EXPECT_TRUE(v == Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY))
        << "4 5 + -INFINITY -INFINITY";
  }
}

TEST(Vector2, Multiply) {
  Vector2 v1 = Vector2(4, 5);
  float f = 3;
  Vector2 v = Vector2::zero;

  v = v1 * f;
  EXPECT_TRUE(v == Vector2(12, 15)) << "4 5 * 3";

  f = -3;
  v = v1 * f;
  EXPECT_TRUE(v == Vector2(-12, -15)) << "4 5 * -3";

  f = 0;
  v = v1 * f;
  EXPECT_TRUE(v == Vector2(0, 0)) << "4 5 * 0";

  if (std::numeric_limits<float>::is_iec559) {
    f = FLOAT_INFINITY;
    v = v1 * f;
    EXPECT_TRUE(v == Vector2(FLOAT_INFINITY, FLOAT_INFINITY))
        << "4 5 * INFINITY";

    f = -FLOAT_INFINITY;
    v = v1 * f;
    EXPECT_TRUE(v == Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY))
        << "4 5 * -INFINITY";
  }
}

TEST(Vector2, Divide) {
  Vector2 v1 = Vector2(4, 5);
  float f = 2;
  Vector2 v = Vector2::zero;

  v = v1 / f;
  EXPECT_TRUE(v == Vector2(2, 2.5F)) << "4 5 / 3";

  f = -2;
  v = v1 / f;
  EXPECT_TRUE(v == Vector2(-2, -2.5F)) << "4 5 / -3";

  if (std::numeric_limits<float>::is_iec559) {
    f = 0;
    v = v1 / f;
    EXPECT_TRUE(v == Vector2(FLOAT_INFINITY, FLOAT_INFINITY)) << "4 5 / 0";

    f = FLOAT_INFINITY;
    v = v1 / f;
    EXPECT_TRUE(v == Vector2(0, 0)) << "4 5 / INFINITY";

    f = -FLOAT_INFINITY;
    v = v1 / f;
    EXPECT_TRUE(v == Vector2(0, 0)) << "4 5 / -INFINITY";
  }
}

TEST(Vector2, Dot) {
  Vector2 v1 = Vector2(4, 5);
  Vector2 v2 = Vector2(1, 2);
  float f = 0;

  f = Vector2::Dot(v1, v2);
  EXPECT_FLOAT_EQ(f, 14) << "Dot(4 5, 1 2)";

  v2 = Vector2(-1, -2);
  f = Vector2::Dot(v1, v2);
  EXPECT_FLOAT_EQ(f, -14) << "Dot(4 5, -1 -2)";

  v2 = Vector2(0, 0);
  f = Vector2::Dot(v1, v2);
  EXPECT_FLOAT_EQ(f, 0) << "Dot(4 5, 0 0)";

  if (std::numeric_limits<float>::is_iec559) {
    v2 = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
    f = Vector2::Dot(v1, v2);
    EXPECT_FLOAT_EQ(f, FLOAT_INFINITY) << "Dot(4 5, INFINITY INFINITY)";

    v2 = Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY);
    f = Vector2::Dot(v1, v2);
    EXPECT_FLOAT_EQ(f, -FLOAT_INFINITY) << "Dot(4 5, -INFINITY -INFINITY)";
  }
}

TEST(Vector2, Equality) {
  Vector2 v1 = Vector2(4, 5);
  Vector2 v2 = Vector2(1, 2);
  bool r = false;

  r = v1 == v2;
  EXPECT_FALSE(r) << "4 5 == 1 2";

  v2 = Vector2(4, 5);
  r = v1 == v2;
  EXPECT_TRUE(r) << "4 5 == 1 2";

  if (std::numeric_limits<float>::is_iec559) {
    v2 = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
    r = v1 == v2;
    EXPECT_FALSE(r) << "4 5 == INFINITY INFINITY";

    v1 = Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY);
    r = v1 == v2;
    EXPECT_FALSE(r) << "-INFINITY -INFINITY == INFINITY INFINITY";
  }
}

TEST(Vector2, Distance) {
  Vector2 v1 = Vector2(4, 5);
  Vector2 v2 = Vector2(1, 2);
  float f = 0;

  f = Vector2::Distance(v1, v2);
  EXPECT_FLOAT_EQ(f, 4.24264F) << "Distance(4 5, 1 2)";

  v2 = Vector2(-1, -2);
  f = Vector2::Distance(v1, v2);
  EXPECT_FLOAT_EQ(f, 8.602325F) << "Distance(4 5, -1 -2)";

  v2 = Vector2(0, 0);
  f = Vector2::Distance(v1, v2);
  EXPECT_FLOAT_EQ(f, 6.403124F) << "Distance(4 5, 0 0)";

  if (std::numeric_limits<float>::is_iec559) {
    v2 = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
    f = Vector2::Distance(v1, v2);
    EXPECT_FLOAT_EQ(f, FLOAT_INFINITY) << "Distance(4 5, INFINITY INFINITY)";

    v2 = Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY);
    f = Vector2::Distance(v1, v2);
    EXPECT_FLOAT_EQ(f, FLOAT_INFINITY) << "Distance(4 5, -INFINITY -INFINITY)";
  }
}

TEST(Vector2, Angle) {
  Vector2 v1 = Vector2(4, 5);
  Vector2 v2 = Vector2(1, 2);
  float f = 0;
  bool r = false;

  f = Vector2::Angle(v1, v2);
  EXPECT_FLOAT_EQ(f, 12.09476F) << "Angle(4 5, 1 2)";

  v2 = Vector2(-1, -2);
  f = Vector2::Angle(v1, v2);
  EXPECT_FLOAT_EQ(f, 167.9052F) << "Angle(4 5, -1 -2)";

  v2 = Vector2(0, 0);
  f = Vector2::Angle(v1, v2);
  EXPECT_FLOAT_EQ(f, 0) << "Angle(4 5, 0 0)";

  if (std::numeric_limits<float>::is_iec559) {
    v2 = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
    f = Vector2::Angle(v1, v2);
    r = isnan(f);
    EXPECT_TRUE(r) << "Angle(4 5, INFINITY INFINITY)";

    v2 = Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY);
    f = Vector2::Angle(v1, v2);
    r = isnan(f);
    EXPECT_TRUE(r) << "Angle(4 5, -INFINITY -INFINITY)";
  }
}

TEST(Vector2, SignedAngle) {
  Vector2 v1 = Vector2(4, 5);
  Vector2 v2 = Vector2(1, 2);
  float f = 0;
  bool r = false;

  f = Vector2::SignedAngle(v1, v2);
  EXPECT_FLOAT_EQ(f, -12.09476F) << "SignedAngle(4 5, 1 2)";

  v2 = Vector2(-1, -2);
  f = Vector2::SignedAngle(v1, v2);
  EXPECT_FLOAT_EQ(f, 167.9052F) << "SignedAngle(4 5, -1 -2)";

  v2 = Vector2(0, 0);
  f = Vector2::SignedAngle(v1, v2);
  EXPECT_FLOAT_EQ(f, 0) << "SignedAngle(4 5, 0 0)";

  if (std::numeric_limits<float>::is_iec559) {
    v2 = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
    f = Vector2::SignedAngle(v1, v2);
    r = isnan(f);
    EXPECT_TRUE(r) << "SignedAngle(4 5, INFINITY INFINITY)";

    v2 = Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY);
    f = Vector2::SignedAngle(v1, v2);
    r = isnan(f);
    EXPECT_TRUE(r) << "SignedAngle(4 5, -INFINITY -INFINITY)";
  }

  v1 = Vector2(0, 1);
  v2 = Vector2(1, 0);
  f = Vector2::SignedAngle(v1, v2);
  EXPECT_FLOAT_EQ(f, 90.0F) << "SignedAngle(0 1, 1 0)";

  v1 = Vector2(0, 1);
  v2 = Vector2(0, -1);
  f = Vector2::SignedAngle(v1, v2);
  EXPECT_FLOAT_EQ(f, 180.0F) << "SignedAngle(0 1, 1 0)";
}

TEST(Vector2, Rotate) {
  Vector2 v1 = Vector2(1, 2);
  Vector2 r = Vector2(0, 0);

  r = Vector2::Rotate(v1, AngleSingle::Degrees(0));
  EXPECT_FLOAT_EQ(Vector2::Distance(r, v1), 0);

  r = Vector2::Rotate(v1, AngleSingle::Degrees(180));
  EXPECT_NEAR(Vector2::Distance(r, Vector2(-1, -2)), 0, 1.0e-06);

  r = Vector2::Rotate(v1, AngleSingle::Degrees(-90));
  EXPECT_NEAR(Vector2::Distance(r, Vector2(2, -1)), 0, 1.0e-06);

  r = Vector2::Rotate(v1, AngleSingle::Degrees(270));
  EXPECT_NEAR(Vector2::Distance(r, Vector2(2, -1)), 0, 1.0e-06);
}

TEST(Vector2, Lerp) {
  Vector2 v1 = Vector2(4, 5);
  Vector2 v2 = Vector2(1, 2);
  Vector2 r = Vector2(0, 0);

  r = Vector2::Lerp(v1, v2, 0);
  EXPECT_FLOAT_EQ(Vector2::Distance(r, v1), 0);

  r = Vector2::Lerp(v1, v2, 1);
  EXPECT_FLOAT_EQ(Vector2::Distance(r, v2), 0);

  r = Vector2::Lerp(v1, v2, 0.5f);
  EXPECT_FLOAT_EQ(Vector2::Distance(r, Vector2(2.5f, 3.5f)), 0);

  r = Vector2::Lerp(v1, v2, -1);
  EXPECT_FLOAT_EQ(Vector2::Distance(r, Vector2(7.0f, 8.0f)), 0);

  r = Vector2::Lerp(v1, v2, 2);
  EXPECT_FLOAT_EQ(Vector2::Distance(r, Vector2(-2.0, -1.0f)), 0);
}

#endif