You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
294 lines
8.7 KiB
294 lines
8.7 KiB
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#include <stddef.h>
|
|
|
|
#include <cmath>
|
|
#include <limits>
|
|
|
|
#include "base/macros.h"
|
|
#include "testing/gtest/include/gtest/gtest.h"
|
|
#include "ui/gfx/geometry/vector2d.h"
|
|
#include "ui/gfx/geometry/vector2d_f.h"
|
|
|
|
namespace gfx {
|
|
|
|
TEST(Vector2dTest, ConversionToFloat) {
|
|
Vector2d i(3, 4);
|
|
Vector2dF f = i;
|
|
EXPECT_EQ(i, f);
|
|
}
|
|
|
|
TEST(Vector2dTest, IsZero) {
|
|
Vector2d int_zero(0, 0);
|
|
Vector2d int_nonzero(2, -2);
|
|
Vector2dF float_zero(0, 0);
|
|
Vector2dF float_nonzero(0.1f, -0.1f);
|
|
|
|
EXPECT_TRUE(int_zero.IsZero());
|
|
EXPECT_FALSE(int_nonzero.IsZero());
|
|
EXPECT_TRUE(float_zero.IsZero());
|
|
EXPECT_FALSE(float_nonzero.IsZero());
|
|
}
|
|
|
|
TEST(Vector2dTest, Add) {
|
|
Vector2d i1(3, 5);
|
|
Vector2d i2(4, -1);
|
|
|
|
const struct {
|
|
Vector2d expected;
|
|
Vector2d actual;
|
|
} int_tests[] = {
|
|
{ Vector2d(3, 5), i1 + Vector2d() },
|
|
{ Vector2d(3 + 4, 5 - 1), i1 + i2 },
|
|
{ Vector2d(3 - 4, 5 + 1), i1 - i2 }
|
|
};
|
|
|
|
for (size_t i = 0; i < arraysize(int_tests); ++i)
|
|
EXPECT_EQ(int_tests[i].expected.ToString(),
|
|
int_tests[i].actual.ToString());
|
|
|
|
Vector2dF f1(3.1f, 5.1f);
|
|
Vector2dF f2(4.3f, -1.3f);
|
|
|
|
const struct {
|
|
Vector2dF expected;
|
|
Vector2dF actual;
|
|
} float_tests[] = {
|
|
{ Vector2dF(3.1F, 5.1F), f1 + Vector2d() },
|
|
{ Vector2dF(3.1F, 5.1F), f1 + Vector2dF() },
|
|
{ Vector2dF(3.1f + 4.3f, 5.1f - 1.3f), f1 + f2 },
|
|
{ Vector2dF(3.1f - 4.3f, 5.1f + 1.3f), f1 - f2 }
|
|
};
|
|
|
|
for (size_t i = 0; i < arraysize(float_tests); ++i)
|
|
EXPECT_EQ(float_tests[i].expected.ToString(),
|
|
float_tests[i].actual.ToString());
|
|
}
|
|
|
|
TEST(Vector2dTest, Negative) {
|
|
const struct {
|
|
Vector2d expected;
|
|
Vector2d actual;
|
|
} int_tests[] = {
|
|
{ Vector2d(0, 0), -Vector2d(0, 0) },
|
|
{ Vector2d(-3, -3), -Vector2d(3, 3) },
|
|
{ Vector2d(3, 3), -Vector2d(-3, -3) },
|
|
{ Vector2d(-3, 3), -Vector2d(3, -3) },
|
|
{ Vector2d(3, -3), -Vector2d(-3, 3) }
|
|
};
|
|
|
|
for (size_t i = 0; i < arraysize(int_tests); ++i)
|
|
EXPECT_EQ(int_tests[i].expected.ToString(),
|
|
int_tests[i].actual.ToString());
|
|
|
|
const struct {
|
|
Vector2dF expected;
|
|
Vector2dF actual;
|
|
} float_tests[] = {
|
|
{ Vector2dF(0, 0), -Vector2d(0, 0) },
|
|
{ Vector2dF(-0.3f, -0.3f), -Vector2dF(0.3f, 0.3f) },
|
|
{ Vector2dF(0.3f, 0.3f), -Vector2dF(-0.3f, -0.3f) },
|
|
{ Vector2dF(-0.3f, 0.3f), -Vector2dF(0.3f, -0.3f) },
|
|
{ Vector2dF(0.3f, -0.3f), -Vector2dF(-0.3f, 0.3f) }
|
|
};
|
|
|
|
for (size_t i = 0; i < arraysize(float_tests); ++i)
|
|
EXPECT_EQ(float_tests[i].expected.ToString(),
|
|
float_tests[i].actual.ToString());
|
|
}
|
|
|
|
TEST(Vector2dTest, Scale) {
|
|
float double_values[][4] = {
|
|
{ 4.5f, 1.2f, 3.3f, 5.6f },
|
|
{ 4.5f, -1.2f, 3.3f, 5.6f },
|
|
{ 4.5f, 1.2f, 3.3f, -5.6f },
|
|
{ 4.5f, 1.2f, -3.3f, -5.6f },
|
|
{ -4.5f, 1.2f, 3.3f, 5.6f },
|
|
{ -4.5f, 1.2f, 0, 5.6f },
|
|
{ -4.5f, 1.2f, 3.3f, 0 },
|
|
{ 4.5f, 0, 3.3f, 5.6f },
|
|
{ 0, 1.2f, 3.3f, 5.6f }
|
|
};
|
|
|
|
for (size_t i = 0; i < arraysize(double_values); ++i) {
|
|
Vector2dF v(double_values[i][0], double_values[i][1]);
|
|
v.Scale(double_values[i][2], double_values[i][3]);
|
|
EXPECT_EQ(v.x(), double_values[i][0] * double_values[i][2]);
|
|
EXPECT_EQ(v.y(), double_values[i][1] * double_values[i][3]);
|
|
|
|
Vector2dF v2 = ScaleVector2d(
|
|
gfx::Vector2dF(double_values[i][0], double_values[i][1]),
|
|
double_values[i][2], double_values[i][3]);
|
|
EXPECT_EQ(double_values[i][0] * double_values[i][2], v2.x());
|
|
EXPECT_EQ(double_values[i][1] * double_values[i][3], v2.y());
|
|
}
|
|
|
|
float single_values[][3] = {
|
|
{ 4.5f, 1.2f, 3.3f },
|
|
{ 4.5f, -1.2f, 3.3f },
|
|
{ 4.5f, 1.2f, 3.3f },
|
|
{ 4.5f, 1.2f, -3.3f },
|
|
{ -4.5f, 1.2f, 3.3f },
|
|
{ -4.5f, 1.2f, 0 },
|
|
{ -4.5f, 1.2f, 3.3f },
|
|
{ 4.5f, 0, 3.3f },
|
|
{ 0, 1.2f, 3.3f }
|
|
};
|
|
|
|
for (size_t i = 0; i < arraysize(single_values); ++i) {
|
|
Vector2dF v(single_values[i][0], single_values[i][1]);
|
|
v.Scale(single_values[i][2]);
|
|
EXPECT_EQ(v.x(), single_values[i][0] * single_values[i][2]);
|
|
EXPECT_EQ(v.y(), single_values[i][1] * single_values[i][2]);
|
|
|
|
Vector2dF v2 = ScaleVector2d(
|
|
gfx::Vector2dF(double_values[i][0], double_values[i][1]),
|
|
double_values[i][2]);
|
|
EXPECT_EQ(single_values[i][0] * single_values[i][2], v2.x());
|
|
EXPECT_EQ(single_values[i][1] * single_values[i][2], v2.y());
|
|
}
|
|
}
|
|
|
|
TEST(Vector2dTest, Length) {
|
|
int int_values[][2] = {
|
|
{ 0, 0 },
|
|
{ 10, 20 },
|
|
{ 20, 10 },
|
|
{ -10, -20 },
|
|
{ -20, 10 },
|
|
{ 10, -20 },
|
|
};
|
|
|
|
for (size_t i = 0; i < arraysize(int_values); ++i) {
|
|
int v0 = int_values[i][0];
|
|
int v1 = int_values[i][1];
|
|
double length_squared =
|
|
static_cast<double>(v0) * v0 + static_cast<double>(v1) * v1;
|
|
double length = std::sqrt(length_squared);
|
|
Vector2d vector(v0, v1);
|
|
EXPECT_EQ(static_cast<float>(length_squared), vector.LengthSquared());
|
|
EXPECT_EQ(static_cast<float>(length), vector.Length());
|
|
}
|
|
|
|
float float_values[][2] = {
|
|
{ 0, 0 },
|
|
{ 10.5f, 20.5f },
|
|
{ 20.5f, 10.5f },
|
|
{ -10.5f, -20.5f },
|
|
{ -20.5f, 10.5f },
|
|
{ 10.5f, -20.5f },
|
|
// A large vector that fails if the Length function doesn't use
|
|
// double precision internally.
|
|
{ 1236278317862780234892374893213178027.12122348904204230f,
|
|
335890352589839028212313231225425134332.38123f },
|
|
};
|
|
|
|
for (size_t i = 0; i < arraysize(float_values); ++i) {
|
|
double v0 = float_values[i][0];
|
|
double v1 = float_values[i][1];
|
|
double length_squared =
|
|
static_cast<double>(v0) * v0 + static_cast<double>(v1) * v1;
|
|
double length = std::sqrt(length_squared);
|
|
Vector2dF vector(v0, v1);
|
|
EXPECT_DOUBLE_EQ(length_squared, vector.LengthSquared());
|
|
EXPECT_FLOAT_EQ(static_cast<float>(length), vector.Length());
|
|
}
|
|
}
|
|
|
|
TEST(Vector2dTest, ClampVector2d) {
|
|
Vector2d a;
|
|
|
|
a = Vector2d(3, 5);
|
|
EXPECT_EQ(Vector2d(3, 5).ToString(), a.ToString());
|
|
a.SetToMax(Vector2d(2, 4));
|
|
EXPECT_EQ(Vector2d(3, 5).ToString(), a.ToString());
|
|
a.SetToMax(Vector2d(3, 5));
|
|
EXPECT_EQ(Vector2d(3, 5).ToString(), a.ToString());
|
|
a.SetToMax(Vector2d(4, 2));
|
|
EXPECT_EQ(Vector2d(4, 5).ToString(), a.ToString());
|
|
a.SetToMax(Vector2d(8, 10));
|
|
EXPECT_EQ(Vector2d(8, 10).ToString(), a.ToString());
|
|
|
|
a.SetToMin(Vector2d(9, 11));
|
|
EXPECT_EQ(Vector2d(8, 10).ToString(), a.ToString());
|
|
a.SetToMin(Vector2d(8, 10));
|
|
EXPECT_EQ(Vector2d(8, 10).ToString(), a.ToString());
|
|
a.SetToMin(Vector2d(11, 9));
|
|
EXPECT_EQ(Vector2d(8, 9).ToString(), a.ToString());
|
|
a.SetToMin(Vector2d(7, 11));
|
|
EXPECT_EQ(Vector2d(7, 9).ToString(), a.ToString());
|
|
a.SetToMin(Vector2d(3, 5));
|
|
EXPECT_EQ(Vector2d(3, 5).ToString(), a.ToString());
|
|
}
|
|
|
|
TEST(Vector2dTest, ClampVector2dF) {
|
|
Vector2dF a;
|
|
|
|
a = Vector2dF(3.5f, 5.5f);
|
|
EXPECT_EQ(Vector2dF(3.5f, 5.5f).ToString(), a.ToString());
|
|
a.SetToMax(Vector2dF(2.5f, 4.5f));
|
|
EXPECT_EQ(Vector2dF(3.5f, 5.5f).ToString(), a.ToString());
|
|
a.SetToMax(Vector2dF(3.5f, 5.5f));
|
|
EXPECT_EQ(Vector2dF(3.5f, 5.5f).ToString(), a.ToString());
|
|
a.SetToMax(Vector2dF(4.5f, 2.5f));
|
|
EXPECT_EQ(Vector2dF(4.5f, 5.5f).ToString(), a.ToString());
|
|
a.SetToMax(Vector2dF(8.5f, 10.5f));
|
|
EXPECT_EQ(Vector2dF(8.5f, 10.5f).ToString(), a.ToString());
|
|
|
|
a.SetToMin(Vector2dF(9.5f, 11.5f));
|
|
EXPECT_EQ(Vector2dF(8.5f, 10.5f).ToString(), a.ToString());
|
|
a.SetToMin(Vector2dF(8.5f, 10.5f));
|
|
EXPECT_EQ(Vector2dF(8.5f, 10.5f).ToString(), a.ToString());
|
|
a.SetToMin(Vector2dF(11.5f, 9.5f));
|
|
EXPECT_EQ(Vector2dF(8.5f, 9.5f).ToString(), a.ToString());
|
|
a.SetToMin(Vector2dF(7.5f, 11.5f));
|
|
EXPECT_EQ(Vector2dF(7.5f, 9.5f).ToString(), a.ToString());
|
|
a.SetToMin(Vector2dF(3.5f, 5.5f));
|
|
EXPECT_EQ(Vector2dF(3.5f, 5.5f).ToString(), a.ToString());
|
|
}
|
|
|
|
TEST(Vector2dTest, IntegerOverflow) {
|
|
int int_max = std::numeric_limits<int>::max();
|
|
int int_min = std::numeric_limits<int>::min();
|
|
|
|
Vector2d max_vector(int_max, int_max);
|
|
Vector2d min_vector(int_min, int_min);
|
|
Vector2d test;
|
|
|
|
test = Vector2d();
|
|
test += Vector2d(int_max, int_max);
|
|
EXPECT_EQ(test, max_vector);
|
|
|
|
test = Vector2d();
|
|
test += Vector2d(int_min, int_min);
|
|
EXPECT_EQ(test, min_vector);
|
|
|
|
test = Vector2d(10, 20);
|
|
test += Vector2d(int_max, int_max);
|
|
EXPECT_EQ(test, max_vector);
|
|
|
|
test = Vector2d(-10, -20);
|
|
test += Vector2d(int_min, int_min);
|
|
EXPECT_EQ(test, min_vector);
|
|
|
|
test = Vector2d();
|
|
test -= Vector2d(int_max, int_max);
|
|
EXPECT_EQ(test, Vector2d(-int_max, -int_max));
|
|
|
|
test = Vector2d();
|
|
test -= Vector2d(int_min, int_min);
|
|
EXPECT_EQ(test, max_vector);
|
|
|
|
test = Vector2d(10, 20);
|
|
test -= Vector2d(int_min, int_min);
|
|
EXPECT_EQ(test, max_vector);
|
|
|
|
test = Vector2d(-10, -20);
|
|
test -= Vector2d(int_max, int_max);
|
|
EXPECT_EQ(test, min_vector);
|
|
}
|
|
|
|
} // namespace gfx
|