vector2d_f_unittest.cc 5.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154
  1. // Copyright 2021 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "ui/gfx/geometry/vector2d_f.h"
  5. #include "testing/gtest/include/gtest/gtest.h"
  6. #include "ui/gfx/geometry/test/geometry_util.h"
  7. #include "ui/gfx/geometry/vector2d.h"
  8. namespace gfx {
  9. TEST(Vector2dTest, Vector2dToVector2dF) {
  10. Vector2d i(3, 4);
  11. Vector2dF f = i;
  12. EXPECT_EQ(i, f);
  13. }
  14. TEST(Vector2dFTest, IsZero) {
  15. EXPECT_TRUE(Vector2dF().IsZero());
  16. EXPECT_TRUE(Vector2dF(0, 0).IsZero());
  17. EXPECT_FALSE(Vector2dF(0.1f, 0).IsZero());
  18. EXPECT_FALSE(Vector2dF(0, -0.1f).IsZero());
  19. EXPECT_FALSE(Vector2dF(0.1f, -0.1f).IsZero());
  20. }
  21. TEST(Vector2dFTest, Add) {
  22. Vector2dF f1(3.1f, 5.1f);
  23. Vector2dF f2(4.3f, -1.3f);
  24. EXPECT_VECTOR2DF_EQ(Vector2dF(3.1f, 5.1f), f1 + Vector2dF());
  25. EXPECT_VECTOR2DF_EQ(Vector2dF(3.1f + 4.3f, 5.1f - 1.3f), f1 + f2);
  26. EXPECT_VECTOR2DF_EQ(Vector2dF(3.1f - 4.3f, 5.1f + 1.3f), f1 - f2);
  27. }
  28. TEST(Vector2dFTest, Negative) {
  29. EXPECT_VECTOR2DF_EQ(Vector2dF(), -Vector2dF());
  30. EXPECT_VECTOR2DF_EQ(Vector2dF(-0.3f, -0.3f), -Vector2dF(0.3f, 0.3f));
  31. EXPECT_VECTOR2DF_EQ(Vector2dF(0.3f, 0.3f), -Vector2dF(-0.3f, -0.3f));
  32. EXPECT_VECTOR2DF_EQ(Vector2dF(-0.3f, 0.3f), -Vector2dF(0.3f, -0.3f));
  33. EXPECT_VECTOR2DF_EQ(Vector2dF(0.3f, -0.3f), -Vector2dF(-0.3f, 0.3f));
  34. }
  35. TEST(Vector2dFTest, Scale) {
  36. float double_values[][4] = {
  37. {4.5f, 1.2f, 3.3f, 5.6f}, {4.5f, -1.2f, 3.3f, 5.6f},
  38. {4.5f, 1.2f, 3.3f, -5.6f}, {4.5f, 1.2f, -3.3f, -5.6f},
  39. {-4.5f, 1.2f, 3.3f, 5.6f}, {-4.5f, 1.2f, 0, 5.6f},
  40. {-4.5f, 1.2f, 3.3f, 0}, {4.5f, 0, 3.3f, 5.6f},
  41. {0, 1.2f, 3.3f, 5.6f}};
  42. for (auto& values : double_values) {
  43. Vector2dF v(values[0], values[1]);
  44. v.Scale(values[2], values[3]);
  45. EXPECT_EQ(v.x(), values[0] * values[2]);
  46. EXPECT_EQ(v.y(), values[1] * values[3]);
  47. Vector2dF v2 = ScaleVector2d(gfx::Vector2dF(values[0], values[1]),
  48. values[2], values[3]);
  49. EXPECT_EQ(values[0] * values[2], v2.x());
  50. EXPECT_EQ(values[1] * values[3], v2.y());
  51. }
  52. float single_values[][3] = {
  53. {4.5f, 1.2f, 3.3f}, {4.5f, -1.2f, 3.3f}, {4.5f, 1.2f, 3.3f},
  54. {4.5f, 1.2f, -3.3f}, {-4.5f, 1.2f, 3.3f}, {-4.5f, 1.2f, 0},
  55. {-4.5f, 1.2f, 3.3f}, {4.5f, 0, 3.3f}, {0, 1.2f, 3.3f}};
  56. for (auto& values : single_values) {
  57. Vector2dF v(values[0], values[1]);
  58. v.Scale(values[2]);
  59. EXPECT_EQ(v.x(), values[0] * values[2]);
  60. EXPECT_EQ(v.y(), values[1] * values[2]);
  61. Vector2dF v2 =
  62. ScaleVector2d(gfx::Vector2dF(values[0], values[1]), values[2]);
  63. EXPECT_EQ(values[0] * values[2], v2.x());
  64. EXPECT_EQ(values[1] * values[2], v2.y());
  65. }
  66. }
  67. TEST(Vector2dFTest, SetToMinMax) {
  68. Vector2dF a;
  69. a = Vector2dF(3.5f, 5.5f);
  70. EXPECT_EQ(Vector2dF(3.5f, 5.5f), a);
  71. a.SetToMax(Vector2dF(2.5f, 4.5f));
  72. EXPECT_EQ(Vector2dF(3.5f, 5.5f), a);
  73. a.SetToMax(Vector2dF(3.5f, 5.5f));
  74. EXPECT_EQ(Vector2dF(3.5f, 5.5f), a);
  75. a.SetToMax(Vector2dF(4.5f, 2.5f));
  76. EXPECT_EQ(Vector2dF(4.5f, 5.5f), a);
  77. a.SetToMax(Vector2dF(8.5f, 10.5f));
  78. EXPECT_EQ(Vector2dF(8.5f, 10.5f), a);
  79. a.SetToMin(Vector2dF(9.5f, 11.5f));
  80. EXPECT_EQ(Vector2dF(8.5f, 10.5f), a);
  81. a.SetToMin(Vector2dF(8.5f, 10.5f));
  82. EXPECT_EQ(Vector2dF(8.5f, 10.5f), a);
  83. a.SetToMin(Vector2dF(11.5f, 9.5f));
  84. EXPECT_EQ(Vector2dF(8.5f, 9.5f), a);
  85. a.SetToMin(Vector2dF(7.5f, 11.5f));
  86. EXPECT_EQ(Vector2dF(7.5f, 9.5f), a);
  87. a.SetToMin(Vector2dF(3.5f, 5.5f));
  88. EXPECT_EQ(Vector2dF(3.5f, 5.5f), a);
  89. }
  90. TEST(Vector2dFTest, Length) {
  91. constexpr float kFloatMax = std::numeric_limits<float>::max();
  92. EXPECT_FLOAT_EQ(0.f, Vector2dF(0, 0).Length());
  93. EXPECT_FLOAT_EQ(1.f, Vector2dF(1, 0).Length());
  94. EXPECT_FLOAT_EQ(1.414214f, Vector2dF(1, 1).Length());
  95. EXPECT_FLOAT_EQ(2.236068f, Vector2dF(-1, -2).Length());
  96. // The Pythagorean triples 3-4-5 and 5-12-13.
  97. EXPECT_FLOAT_EQ(5.f, Vector2dF(3.f, 4.f).Length());
  98. EXPECT_FLOAT_EQ(13.f, Vector2dF(5.f, 12.f).Length());
  99. // Very small numbers.
  100. EXPECT_FLOAT_EQ(.7071068e-20f, Vector2dF(.5e-20f, .5e-20f).Length());
  101. // Very large numbers.
  102. EXPECT_FLOAT_EQ(.7071068e20f, Vector2dF(.5e20f, .5e20f).Length());
  103. EXPECT_FLOAT_EQ(kFloatMax, Vector2dF(kFloatMax, 0).Length());
  104. EXPECT_FLOAT_EQ(kFloatMax, Vector2dF(kFloatMax, kFloatMax).Length());
  105. }
  106. TEST(Vector2dFTest, SlopeAngleRadians) {
  107. // The function is required to be very accurate, so we use a smaller
  108. // tolerance than EXPECT_FLOAT_EQ().
  109. constexpr float kTolerance = 1e-7f;
  110. constexpr float kPi = 3.1415927f;
  111. EXPECT_NEAR(0, Vector2dF(0, 0).SlopeAngleRadians(), kTolerance);
  112. EXPECT_NEAR(0, Vector2dF(1, 0).SlopeAngleRadians(), kTolerance);
  113. EXPECT_NEAR(kPi / 4, Vector2dF(1, 1).SlopeAngleRadians(), kTolerance);
  114. EXPECT_NEAR(kPi / 2, Vector2dF(0, 1).SlopeAngleRadians(), kTolerance);
  115. EXPECT_NEAR(kPi, Vector2dF(-50, 0).SlopeAngleRadians(), kTolerance);
  116. EXPECT_NEAR(-kPi * 3 / 4, Vector2dF(-50, -50).SlopeAngleRadians(),
  117. kTolerance);
  118. EXPECT_NEAR(-kPi / 4, Vector2dF(1, -1).SlopeAngleRadians(), kTolerance);
  119. }
  120. TEST(Vector2dFTest, Transpose) {
  121. gfx::Vector2dF v(-1.5f, 2.5f);
  122. EXPECT_EQ(gfx::Vector2dF(2.5f, -1.5f), TransposeVector2d(v));
  123. v.Transpose();
  124. EXPECT_EQ(gfx::Vector2dF(2.5f, -1.5f), v);
  125. }
  126. TEST(Vector2dFTest, ToString) {
  127. EXPECT_EQ("[1 2]", Vector2dF(1, 2).ToString());
  128. EXPECT_EQ("[1.03125 2.5]", Vector2dF(1.03125, 2.5).ToString());
  129. }
  130. } // namespace gfx