rect_f_unittest.cc 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528
  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/rect_f.h"
  5. #include <cmath>
  6. #include "ui/gfx/geometry/insets_f.h"
  7. #include "ui/gfx/geometry/rect_f.h"
  8. #include "ui/gfx/geometry/test/geometry_util.h"
  9. namespace gfx {
  10. TEST(RectFTest, FromRect) {
  11. // Check that explicit conversion from integer to float compiles.
  12. Rect a(10, 20, 30, 40);
  13. RectF b(10, 20, 30, 40);
  14. RectF c = RectF(a);
  15. EXPECT_EQ(b, c);
  16. }
  17. TEST(RectFTest, ContainsPointF) {
  18. EXPECT_FALSE(RectF().Contains(PointF()));
  19. RectF r(10, 20, 30, 40);
  20. EXPECT_FALSE(r.Contains(PointF(0, 0)));
  21. EXPECT_FALSE(r.Contains(PointF(9.9999f, 20)));
  22. EXPECT_FALSE(r.Contains(PointF(10, 19.9999f)));
  23. EXPECT_TRUE(r.Contains(PointF(10, 20)));
  24. EXPECT_TRUE(r.Contains(PointF(39.9999f, 20)));
  25. EXPECT_FALSE(r.Contains(PointF(40, 20)));
  26. EXPECT_TRUE(r.Contains(PointF(10, 59.9999f)));
  27. EXPECT_FALSE(r.Contains(PointF(10, 60)));
  28. EXPECT_TRUE(r.Contains(PointF(39.9999f, 59.9999f)));
  29. EXPECT_FALSE(r.Contains(PointF(40, 60)));
  30. EXPECT_FALSE(r.Contains(PointF(100, 100)));
  31. }
  32. TEST(RectFTest, ContainsXY) {
  33. EXPECT_FALSE(RectF().Contains(0, 0));
  34. RectF r(10, 20, 30, 40);
  35. EXPECT_FALSE(r.Contains(0, 0));
  36. EXPECT_FALSE(r.Contains(9.9999f, 20));
  37. EXPECT_FALSE(r.Contains(10, 19.9999f));
  38. EXPECT_TRUE(r.Contains(10, 20));
  39. EXPECT_TRUE(r.Contains(39.9999f, 20));
  40. EXPECT_FALSE(r.Contains(40, 20));
  41. EXPECT_TRUE(r.Contains(10, 59.9999f));
  42. EXPECT_FALSE(r.Contains(10, 60));
  43. EXPECT_TRUE(r.Contains(39.9999f, 59.9999f));
  44. EXPECT_FALSE(r.Contains(40, 60));
  45. EXPECT_FALSE(r.Contains(100, 100));
  46. }
  47. TEST(RectFTest, InclusiveContainsPointF) {
  48. EXPECT_TRUE(RectF().InclusiveContains(PointF()));
  49. EXPECT_FALSE(RectF().InclusiveContains(PointF(0.0001f, 0)));
  50. RectF r(10, 20, 30, 40);
  51. EXPECT_FALSE(r.InclusiveContains(PointF(0, 0)));
  52. EXPECT_FALSE(r.InclusiveContains(PointF(9.9999f, 20)));
  53. EXPECT_FALSE(r.InclusiveContains(PointF(10, 19.9999f)));
  54. EXPECT_TRUE(r.InclusiveContains(PointF(10, 20)));
  55. EXPECT_TRUE(r.InclusiveContains(PointF(40, 20)));
  56. EXPECT_FALSE(r.InclusiveContains(PointF(40.0001f, 20)));
  57. EXPECT_TRUE(r.InclusiveContains(PointF(10, 60)));
  58. EXPECT_FALSE(r.InclusiveContains(PointF(10, 60.0001f)));
  59. EXPECT_TRUE(r.InclusiveContains(PointF(40, 60)));
  60. EXPECT_FALSE(r.InclusiveContains(PointF(100, 100)));
  61. }
  62. TEST(RectFTest, InclusiveContainsXY) {
  63. EXPECT_TRUE(RectF().InclusiveContains(0, 0));
  64. EXPECT_FALSE(RectF().InclusiveContains(0.0001f, 0));
  65. RectF r(10, 20, 30, 40);
  66. EXPECT_FALSE(r.InclusiveContains(0, 0));
  67. EXPECT_FALSE(r.InclusiveContains(9.9999f, 20));
  68. EXPECT_FALSE(r.InclusiveContains(10, 19.9999f));
  69. EXPECT_TRUE(r.InclusiveContains(10, 20));
  70. EXPECT_TRUE(r.InclusiveContains(40, 20));
  71. EXPECT_FALSE(r.InclusiveContains(40.0001f, 20));
  72. EXPECT_TRUE(r.InclusiveContains(10, 60));
  73. EXPECT_FALSE(r.InclusiveContains(10, 60.0001f));
  74. EXPECT_TRUE(r.InclusiveContains(40, 60));
  75. EXPECT_FALSE(r.InclusiveContains(100, 100));
  76. }
  77. TEST(RectFTest, BoundingRect) {
  78. // If point B dominates A, then A should be the origin.
  79. EXPECT_RECTF_EQ(RectF(4.2f, 6.8f, 0, 0),
  80. BoundingRect(PointF(4.2f, 6.8f), PointF(4.2f, 6.8f)));
  81. EXPECT_RECTF_EQ(RectF(4.2f, 6.8f, 4.3f, 0),
  82. BoundingRect(PointF(4.2f, 6.8f), PointF(8.5f, 6.8f)));
  83. EXPECT_RECTF_EQ(RectF(4.2f, 6.8f, 0, 2.5f),
  84. BoundingRect(PointF(4.2f, 6.8f), PointF(4.2f, 9.3f)));
  85. EXPECT_RECTF_EQ(RectF(4.2f, 6.8f, 4.3f, 2.5f),
  86. BoundingRect(PointF(4.2f, 6.8f), PointF(8.5f, 9.3f)));
  87. // If point A dominates B, then B should be the origin.
  88. EXPECT_RECTF_EQ(RectF(4.2f, 6.8f, 0, 0),
  89. BoundingRect(PointF(4.2f, 6.8f), PointF(4.2f, 6.8f)));
  90. EXPECT_RECTF_EQ(RectF(4.2f, 6.8f, 4.3f, 0),
  91. BoundingRect(PointF(8.5f, 6.8f), PointF(4.2f, 6.8f)));
  92. EXPECT_RECTF_EQ(RectF(4.2f, 6.8f, 0, 2.5f),
  93. BoundingRect(PointF(4.2f, 9.3f), PointF(4.2f, 6.8f)));
  94. EXPECT_RECTF_EQ(RectF(4.2f, 6.8f, 4.3f, 2.5f),
  95. BoundingRect(PointF(8.5f, 9.3f), PointF(4.2f, 6.8f)));
  96. // If neither point dominates, then the origin is a combination of the two.
  97. EXPECT_RECTF_EQ(RectF(4.2f, 4.2f, 2.6f, 2.6f),
  98. BoundingRect(PointF(4.2f, 6.8f), PointF(6.8f, 4.2f)));
  99. EXPECT_RECTF_EQ(RectF(-6.8f, -6.8f, 2.6f, 2.6f),
  100. BoundingRect(PointF(-4.2f, -6.8f), PointF(-6.8f, -4.2f)));
  101. EXPECT_RECTF_EQ(RectF(-4.2f, -4.2f, 11.0f, 11.0f),
  102. BoundingRect(PointF(-4.2f, 6.8f), PointF(6.8f, -4.2f)));
  103. }
  104. TEST(RectFTest, Union) {
  105. EXPECT_RECTF_EQ(RectF(), UnionRects(RectF(), RectF()));
  106. EXPECT_RECTF_EQ(
  107. RectF(1.1f, 2.2f, 3.3f, 4.4f),
  108. UnionRects(RectF(1.1f, 2.2f, 3.3f, 4.4f), RectF(1.1f, 2.2f, 3.3f, 4.4f)));
  109. EXPECT_RECTF_EQ(
  110. RectF(0, 0, 8.8f, 11.0f),
  111. UnionRects(RectF(0, 0, 3.3f, 4.4f), RectF(3.3f, 4.4f, 5.5f, 6.6f)));
  112. EXPECT_RECTF_EQ(
  113. RectF(0, 0, 8.8f, 11.0f),
  114. UnionRects(RectF(3.3f, 4.4f, 5.5f, 6.6f), RectF(0, 0, 3.3f, 4.4f)));
  115. EXPECT_RECTF_EQ(
  116. RectF(0, 1.1f, 3.3f, 8.8f),
  117. UnionRects(RectF(0, 1.1f, 3.3f, 4.4f), RectF(0, 5.5f, 3.3f, 4.4f)));
  118. EXPECT_RECTF_EQ(
  119. RectF(0, 1.1f, 11.0f, 12.1f),
  120. UnionRects(RectF(0, 1.1f, 3.3f, 4.4f), RectF(4.4f, 5.5f, 6.6f, 7.7f)));
  121. EXPECT_RECTF_EQ(
  122. RectF(0, 1.1f, 11.0f, 12.1f),
  123. UnionRects(RectF(4.4f, 5.5f, 6.6f, 7.7f), RectF(0, 1.1f, 3.3f, 4.4f)));
  124. EXPECT_RECTF_EQ(
  125. RectF(2.2f, 3.3f, 4.4f, 5.5f),
  126. UnionRects(RectF(8.8f, 9.9f, 0, 2.2f), RectF(2.2f, 3.3f, 4.4f, 5.5f)));
  127. EXPECT_RECTF_EQ(
  128. RectF(2.2f, 3.3f, 4.4f, 5.5f),
  129. UnionRects(RectF(2.2f, 3.3f, 4.4f, 5.5f), RectF(8.8f, 9.9f, 2.2f, 0)));
  130. }
  131. TEST(RectFTest, UnionEvenIfEmpty) {
  132. EXPECT_RECTF_EQ(RectF(), UnionRectsEvenIfEmpty(RectF(), RectF()));
  133. EXPECT_RECTF_EQ(RectF(0, 0, 3.3f, 4.4f),
  134. UnionRectsEvenIfEmpty(RectF(), RectF(3.3f, 4.4f, 0, 0)));
  135. EXPECT_RECTF_EQ(RectF(0, 0, 8.8f, 11.0f),
  136. UnionRectsEvenIfEmpty(RectF(0, 0, 3.3f, 4.4f),
  137. RectF(3.3f, 4.4f, 5.5f, 6.6f)));
  138. EXPECT_RECTF_EQ(RectF(0, 0, 8.8f, 11.0f),
  139. UnionRectsEvenIfEmpty(RectF(3.3f, 4.4f, 5.5f, 6.6f),
  140. RectF(0, 0, 3.3f, 4.4f)));
  141. EXPECT_RECTF_EQ(RectF(2.2f, 3.3f, 6.6f, 8.8f),
  142. UnionRectsEvenIfEmpty(RectF(8.8f, 9.9f, 0, 2.2f),
  143. RectF(2.2f, 3.3f, 4.4f, 5.5f)));
  144. EXPECT_RECTF_EQ(RectF(2.2f, 3.3f, 8.8f, 6.6f),
  145. UnionRectsEvenIfEmpty(RectF(2.2f, 3.3f, 4.4f, 5.5f),
  146. RectF(8.8f, 9.9f, 2.2f, 0)));
  147. }
  148. TEST(RectFTest, UnionEnsuresContainWithFloatingError) {
  149. for (float f = 0.1f; f < 5; f += 0.1f) {
  150. RectF r1(1, 2, 3, 4);
  151. r1.Scale(f, f + 0.05f);
  152. RectF r2 = r1 + Vector2dF(10.f + f, f - 10.f);
  153. RectF r3 = UnionRects(r1, r2);
  154. EXPECT_TRUE(r3.Contains(r1));
  155. EXPECT_TRUE(r3.Contains(r2));
  156. }
  157. }
  158. TEST(RectFTest, UnionIfEmptyResultTinySize) {
  159. RectF r1(1e-15f, 0, 0, 0);
  160. RectF r2(0, 1e-15f, 0, 0);
  161. RectF r3 = UnionRectsEvenIfEmpty(r1, r2);
  162. EXPECT_FALSE(r3.IsEmpty());
  163. EXPECT_TRUE(r3.Contains(r1));
  164. EXPECT_TRUE(r3.Contains(r2));
  165. }
  166. TEST(RectFTest, UnionMaxRects) {
  167. constexpr float kMaxFloat = std::numeric_limits<float>::max();
  168. constexpr float kMinFloat = std::numeric_limits<float>::min();
  169. gfx::RectF r1(kMinFloat, 0, kMaxFloat, kMaxFloat);
  170. gfx::RectF r2(0, kMinFloat, kMaxFloat, kMaxFloat);
  171. // This should not trigger DCHECK failure.
  172. r1.Union(r2);
  173. }
  174. TEST(RectFTest, CenterPoint) {
  175. PointF center;
  176. // When origin is (0, 0).
  177. center = RectF(0, 0, 20, 20).CenterPoint();
  178. EXPECT_TRUE(center == PointF(10, 10));
  179. // When origin is even.
  180. center = RectF(10, 10, 20, 20).CenterPoint();
  181. EXPECT_TRUE(center == PointF(20, 20));
  182. // When origin is odd.
  183. center = RectF(11, 11, 20, 20).CenterPoint();
  184. EXPECT_TRUE(center == PointF(21, 21));
  185. // When 0 width or height.
  186. center = RectF(10, 10, 0, 20).CenterPoint();
  187. EXPECT_TRUE(center == PointF(10, 20));
  188. center = RectF(10, 10, 20, 0).CenterPoint();
  189. EXPECT_TRUE(center == PointF(20, 10));
  190. // When an odd size.
  191. center = RectF(10, 10, 21, 21).CenterPoint();
  192. EXPECT_TRUE(center == PointF(20.5f, 20.5f));
  193. // When an odd size and position.
  194. center = RectF(11, 11, 21, 21).CenterPoint();
  195. EXPECT_TRUE(center == PointF(21.5f, 21.5f));
  196. }
  197. TEST(RectFTest, ScaleRect) {
  198. constexpr RectF input(3, 3, 3, 3);
  199. EXPECT_RECTF_EQ(RectF(4.5f, 4.5f, 4.5f, 4.5f), ScaleRect(input, 1.5f));
  200. EXPECT_RECTF_EQ(RectF(0, 0, 0, 0), ScaleRect(input, 0));
  201. constexpr float kMaxFloat = std::numeric_limits<float>::max();
  202. EXPECT_RECTF_EQ(RectF(kMaxFloat, kMaxFloat, kMaxFloat, kMaxFloat),
  203. ScaleRect(input, kMaxFloat));
  204. RectF nan_rect = ScaleRect(input, std::numeric_limits<float>::quiet_NaN());
  205. EXPECT_TRUE(std::isnan(nan_rect.x()));
  206. EXPECT_TRUE(std::isnan(nan_rect.y()));
  207. // NaN is clamped to 0 in SizeF constructor.
  208. EXPECT_EQ(0, nan_rect.width());
  209. EXPECT_EQ(0, nan_rect.height());
  210. }
  211. TEST(RectFTest, IsExpressibleAsRect) {
  212. EXPECT_TRUE(RectF().IsExpressibleAsRect());
  213. constexpr float kMinIntF =
  214. static_cast<float>(std::numeric_limits<int>::min());
  215. constexpr float kMaxIntF =
  216. static_cast<float>(std::numeric_limits<int>::max());
  217. constexpr float kInfinity = std::numeric_limits<float>::infinity();
  218. EXPECT_TRUE(
  219. RectF(kMinIntF + 200, kMinIntF + 200, kMaxIntF - 200, kMaxIntF - 200)
  220. .IsExpressibleAsRect());
  221. EXPECT_FALSE(
  222. RectF(kMinIntF - 200, kMinIntF + 200, kMaxIntF + 200, kMaxIntF + 200)
  223. .IsExpressibleAsRect());
  224. EXPECT_FALSE(
  225. RectF(kMinIntF + 200, kMinIntF - 200, kMaxIntF + 200, kMaxIntF + 200)
  226. .IsExpressibleAsRect());
  227. EXPECT_FALSE(
  228. RectF(kMinIntF + 200, kMinIntF + 200, kMaxIntF + 200, kMaxIntF - 200)
  229. .IsExpressibleAsRect());
  230. EXPECT_FALSE(
  231. RectF(kMinIntF + 200, kMinIntF + 200, kMaxIntF - 200, kMaxIntF + 200)
  232. .IsExpressibleAsRect());
  233. EXPECT_TRUE(
  234. RectF(0, 0, kMaxIntF - 200, kMaxIntF - 200).IsExpressibleAsRect());
  235. EXPECT_FALSE(
  236. RectF(200, 0, kMaxIntF + 200, kMaxIntF - 200).IsExpressibleAsRect());
  237. EXPECT_FALSE(
  238. RectF(0, 200, kMaxIntF - 200, kMaxIntF + 200).IsExpressibleAsRect());
  239. EXPECT_FALSE(
  240. RectF(0, 0, kMaxIntF + 200, kMaxIntF - 200).IsExpressibleAsRect());
  241. EXPECT_FALSE(
  242. RectF(0, 0, kMaxIntF - 200, kMaxIntF + 200).IsExpressibleAsRect());
  243. EXPECT_FALSE(RectF(kInfinity, 0, 1, 1).IsExpressibleAsRect());
  244. EXPECT_FALSE(RectF(0, kInfinity, 1, 1).IsExpressibleAsRect());
  245. EXPECT_FALSE(RectF(0, 0, kInfinity, 1).IsExpressibleAsRect());
  246. EXPECT_FALSE(RectF(0, 0, 1, kInfinity).IsExpressibleAsRect());
  247. }
  248. TEST(RectFTest, Offset) {
  249. RectF f(1.1f, 2.2f, 3.3f, 4.4f);
  250. EXPECT_EQ(RectF(2.2f, 1.1f, 3.3f, 4.4f), (f + Vector2dF(1.1f, -1.1f)));
  251. EXPECT_EQ(RectF(2.2f, 1.1f, 3.3f, 4.4f), (Vector2dF(1.1f, -1.1f) + f));
  252. f += Vector2dF(1.1f, -1.1f);
  253. EXPECT_EQ(RectF(2.2f, 1.1f, 3.3f, 4.4f), f);
  254. EXPECT_EQ(RectF(1.1f, 2.2f, 3.3f, 4.4f), (f - Vector2dF(1.1f, -1.1f)));
  255. f -= Vector2dF(1.1f, -1.1f);
  256. EXPECT_EQ(RectF(1.1f, 2.2f, 3.3f, 4.4f), f);
  257. }
  258. TEST(RectFTest, Corners) {
  259. RectF f(1.1f, 2.1f, 3.1f, 4.1f);
  260. EXPECT_EQ(PointF(1.1f, 2.1f), f.origin());
  261. EXPECT_EQ(PointF(4.2f, 2.1f), f.top_right());
  262. EXPECT_EQ(PointF(1.1f, 6.2f), f.bottom_left());
  263. EXPECT_EQ(PointF(4.2f, 6.2f), f.bottom_right());
  264. }
  265. TEST(RectFTest, Centers) {
  266. RectF f(10.1f, 20.2f, 30.3f, 40.4f);
  267. EXPECT_EQ(PointF(10.1f, 40.4f), f.left_center());
  268. EXPECT_EQ(PointF(25.25f, 20.2f), f.top_center());
  269. EXPECT_EQ(PointF(40.4f, 40.4f), f.right_center());
  270. EXPECT_EQ(25.25f, f.bottom_center().x());
  271. EXPECT_NEAR(60.6f, f.bottom_center().y(), 0.001f);
  272. }
  273. TEST(RectFTest, Transpose) {
  274. RectF f(10.1f, 20.2f, 30.3f, 40.4f);
  275. f.Transpose();
  276. EXPECT_EQ(RectF(20.2f, 10.1f, 40.4f, 30.3f), f);
  277. }
  278. TEST(RectFTest, ManhattanDistanceToPoint) {
  279. RectF f(1.1f, 2.1f, 3.1f, 4.1f);
  280. EXPECT_FLOAT_EQ(0.f, f.ManhattanDistanceToPoint(PointF(1.1f, 2.1f)));
  281. EXPECT_FLOAT_EQ(0.f, f.ManhattanDistanceToPoint(PointF(4.2f, 6.f)));
  282. EXPECT_FLOAT_EQ(0.f, f.ManhattanDistanceToPoint(PointF(2.f, 4.f)));
  283. EXPECT_FLOAT_EQ(3.2f, f.ManhattanDistanceToPoint(PointF(0.f, 0.f)));
  284. EXPECT_FLOAT_EQ(2.1f, f.ManhattanDistanceToPoint(PointF(2.f, 0.f)));
  285. EXPECT_FLOAT_EQ(2.9f, f.ManhattanDistanceToPoint(PointF(5.f, 0.f)));
  286. EXPECT_FLOAT_EQ(.8f, f.ManhattanDistanceToPoint(PointF(5.f, 4.f)));
  287. EXPECT_FLOAT_EQ(2.6f, f.ManhattanDistanceToPoint(PointF(5.f, 8.f)));
  288. EXPECT_FLOAT_EQ(1.8f, f.ManhattanDistanceToPoint(PointF(3.f, 8.f)));
  289. EXPECT_FLOAT_EQ(1.9f, f.ManhattanDistanceToPoint(PointF(0.f, 7.f)));
  290. EXPECT_FLOAT_EQ(1.1f, f.ManhattanDistanceToPoint(PointF(0.f, 3.f)));
  291. }
  292. TEST(RectFTest, ManhattanInternalDistance) {
  293. RectF f(0.0f, 0.0f, 400.0f, 400.0f);
  294. static const float kEpsilon = std::numeric_limits<float>::epsilon();
  295. EXPECT_FLOAT_EQ(0.0f,
  296. f.ManhattanInternalDistance(RectF(-1.0f, 0.0f, 2.0f, 1.0f)));
  297. EXPECT_FLOAT_EQ(
  298. kEpsilon, f.ManhattanInternalDistance(RectF(400.0f, 0.0f, 1.0f, 400.0f)));
  299. EXPECT_FLOAT_EQ(2.0f * kEpsilon, f.ManhattanInternalDistance(RectF(
  300. -100.0f, -100.0f, 100.0f, 100.0f)));
  301. EXPECT_FLOAT_EQ(1.0f + kEpsilon, f.ManhattanInternalDistance(
  302. RectF(-101.0f, 100.0f, 100.0f, 100.0f)));
  303. EXPECT_FLOAT_EQ(
  304. 2.0f + 2.0f * kEpsilon,
  305. f.ManhattanInternalDistance(RectF(-101.0f, -101.0f, 100.0f, 100.0f)));
  306. EXPECT_FLOAT_EQ(
  307. 433.0f + 2.0f * kEpsilon,
  308. f.ManhattanInternalDistance(RectF(630.0f, 603.0f, 100.0f, 100.0f)));
  309. EXPECT_FLOAT_EQ(0.0f,
  310. f.ManhattanInternalDistance(RectF(-1.0f, 0.0f, 1.1f, 1.0f)));
  311. EXPECT_FLOAT_EQ(0.1f + kEpsilon,
  312. f.ManhattanInternalDistance(RectF(-1.5f, 0.0f, 1.4f, 1.0f)));
  313. EXPECT_FLOAT_EQ(kEpsilon,
  314. f.ManhattanInternalDistance(RectF(-1.5f, 0.0f, 1.5f, 1.0f)));
  315. }
  316. TEST(RectFTest, Inset) {
  317. RectF r(10, 20, 30, 40);
  318. r.Inset(0);
  319. EXPECT_RECTF_EQ(RectF(10, 20, 30, 40), r);
  320. r.Inset(1.5);
  321. EXPECT_RECTF_EQ(RectF(11.5, 21.5, 27, 37), r);
  322. r.Inset(-1.5);
  323. EXPECT_RECTF_EQ(RectF(10, 20, 30, 40), r);
  324. r.Inset(InsetsF::VH(2.25, 1.5));
  325. EXPECT_RECTF_EQ(RectF(11.5, 22.25, 27, 35.5), r);
  326. r.Inset(InsetsF::VH(-2.25, -1.5));
  327. EXPECT_RECTF_EQ(RectF(10, 20, 30, 40), r);
  328. // The parameters are left, top, right, bottom.
  329. r.Inset(InsetsF::TLBR(2.25, 1.5, 4, 3.75));
  330. EXPECT_RECTF_EQ(RectF(11.5, 22.25, 24.75, 33.75), r);
  331. r.Inset(InsetsF::TLBR(-2.25, -1.5, -4, -3.75));
  332. EXPECT_RECTF_EQ(RectF(10, 20, 30, 40), r);
  333. // InsetsF parameters are top, right, bottom, left.
  334. r.Inset(InsetsF::TLBR(1.5, 2.25, 3.75, 4));
  335. EXPECT_RECTF_EQ(RectF(12.25, 21.5, 23.75, 34.75), r);
  336. r.Inset(InsetsF::TLBR(-1.5, -2.25, -3.75, -4));
  337. EXPECT_RECTF_EQ(RectF(10, 20, 30, 40), r);
  338. }
  339. TEST(RectFTest, Outset) {
  340. RectF r(10, 20, 30, 40);
  341. r.Outset(0);
  342. EXPECT_RECTF_EQ(RectF(10, 20, 30, 40), r);
  343. r.Outset(1.5);
  344. EXPECT_RECTF_EQ(RectF(8.5, 18.5, 33, 43), r);
  345. r.Outset(-1.5);
  346. EXPECT_RECTF_EQ(RectF(10, 20, 30, 40), r);
  347. r.Outset(OutsetsF::VH(2.25, 1.5));
  348. EXPECT_RECTF_EQ(RectF(8.5, 17.75, 33, 44.5), r);
  349. r.Outset(OutsetsF::VH(-2.25, -1.5));
  350. EXPECT_RECTF_EQ(RectF(10, 20, 30, 40), r);
  351. r.Outset(OutsetsF::TLBR(2.25, 1.5, 4, 3.75));
  352. EXPECT_RECTF_EQ(RectF(8.5, 17.75, 35.25, 46.25), r);
  353. r.Outset(OutsetsF::TLBR(-2.25, -1.5, -4, -3.75));
  354. EXPECT_RECTF_EQ(RectF(10, 20, 30, 40), r);
  355. }
  356. TEST(RectFTest, InsetClamped) {
  357. RectF r(10, 20, 30, 40);
  358. r.Inset(18);
  359. EXPECT_RECTF_EQ(RectF(28, 38, 0, 4), r);
  360. r.Inset(-18);
  361. EXPECT_RECTF_EQ(RectF(10, 20, 36, 40), r);
  362. r.Inset(InsetsF::VH(30, 15));
  363. EXPECT_RECTF_EQ(RectF(25, 50, 6, 0), r);
  364. r.Inset(InsetsF::VH(-30, -15));
  365. EXPECT_RECTF_EQ(RectF(10, 20, 36, 60), r);
  366. r.Inset(InsetsF::TLBR(30, 20, 50, 40));
  367. EXPECT_RECTF_EQ(RectF(30, 50, 0, 0), r);
  368. r.Inset(InsetsF::TLBR(-30, -20, -50, -40));
  369. EXPECT_RECTF_EQ(RectF(10, 20, 60, 80), r);
  370. }
  371. TEST(RectFTest, InclusiveIntersect) {
  372. RectF rect(11, 12, 0, 0);
  373. EXPECT_TRUE(rect.InclusiveIntersect(RectF(11, 12, 13, 14)));
  374. EXPECT_RECTF_EQ(RectF(11, 12, 0, 0), rect);
  375. rect = RectF(11, 12, 13, 14);
  376. EXPECT_TRUE(rect.InclusiveIntersect(RectF(24, 8, 0, 7)));
  377. EXPECT_RECTF_EQ(RectF(24, 12, 0, 3), rect);
  378. rect = RectF(11, 12, 13, 14);
  379. EXPECT_TRUE(rect.InclusiveIntersect(RectF(9, 15, 4, 0)));
  380. EXPECT_RECTF_EQ(RectF(11, 15, 2, 0), rect);
  381. rect = RectF(11, 12, 0, 14);
  382. EXPECT_FALSE(rect.InclusiveIntersect(RectF(12, 13, 15, 16)));
  383. EXPECT_RECTF_EQ(RectF(), rect);
  384. }
  385. TEST(RectFTest, MaximumCoveredRect) {
  386. // X aligned and intersect: unite.
  387. EXPECT_EQ(RectF(10, 20, 30, 60),
  388. MaximumCoveredRect(RectF(10, 20, 30, 40), RectF(10, 30, 30, 50)));
  389. // X aligned and adjacent: unite.
  390. EXPECT_EQ(RectF(10, 20, 30, 90),
  391. MaximumCoveredRect(RectF(10, 20, 30, 40), RectF(10, 60, 30, 50)));
  392. // X aligned and separate: choose the bigger one.
  393. EXPECT_EQ(RectF(10, 61, 30, 50),
  394. MaximumCoveredRect(RectF(10, 20, 30, 40), RectF(10, 61, 30, 50)));
  395. // Y aligned and intersect: unite.
  396. EXPECT_EQ(RectF(10, 20, 60, 40),
  397. MaximumCoveredRect(RectF(10, 20, 30, 40), RectF(30, 20, 40, 40)));
  398. // Y aligned and adjacent: unite.
  399. EXPECT_EQ(RectF(10, 20, 70, 40),
  400. MaximumCoveredRect(RectF(10, 20, 30, 40), RectF(40, 20, 40, 40)));
  401. // Y aligned and separate: choose the bigger one.
  402. EXPECT_EQ(RectF(41, 20, 40, 40),
  403. MaximumCoveredRect(RectF(10, 20, 30, 40), RectF(41, 20, 40, 40)));
  404. // Get the biggest expanded intersection.
  405. EXPECT_EQ(RectF(0, 0, 9, 19),
  406. MaximumCoveredRect(RectF(0, 0, 10, 10), RectF(0, 9, 9, 10)));
  407. EXPECT_EQ(RectF(0, 0, 19, 9),
  408. MaximumCoveredRect(RectF(0, 0, 10, 10), RectF(9, 0, 10, 9)));
  409. // Otherwise choose the bigger one.
  410. EXPECT_EQ(RectF(20, 30, 40, 50),
  411. MaximumCoveredRect(RectF(10, 20, 30, 40), RectF(20, 30, 40, 50)));
  412. EXPECT_EQ(RectF(10, 20, 40, 50),
  413. MaximumCoveredRect(RectF(10, 20, 40, 50), RectF(20, 30, 30, 40)));
  414. EXPECT_EQ(RectF(10, 20, 40, 50),
  415. MaximumCoveredRect(RectF(10, 20, 40, 50), RectF(20, 30, 40, 50)));
  416. }
  417. TEST(RectFTest, ClosestPoint) {
  418. // r.x()=50 r.right()=350
  419. // | |
  420. // 1 | 2 | 3
  421. // ------+----------+--------r.y()=100
  422. // 4 | 5(in) | 6
  423. // ------+----------+--------r.bottom()=250
  424. // 7 | 8 | 9
  425. RectF r(50, 100, 300, 150);
  426. // 1
  427. EXPECT_EQ(PointF(50, 100), r.ClosestPoint(PointF(10, 20)));
  428. // 2
  429. EXPECT_EQ(PointF(110, 100), r.ClosestPoint(PointF(110, 80)));
  430. // 3
  431. EXPECT_EQ(PointF(350, 100), r.ClosestPoint(PointF(400, 80)));
  432. // 4
  433. EXPECT_EQ(PointF(50, 110), r.ClosestPoint(PointF(10, 110)));
  434. // 5
  435. EXPECT_EQ(PointF(50, 100), r.ClosestPoint(PointF(50, 100)));
  436. EXPECT_EQ(PointF(150, 100), r.ClosestPoint(PointF(150, 100)));
  437. EXPECT_EQ(PointF(350, 100), r.ClosestPoint(PointF(350, 100)));
  438. EXPECT_EQ(PointF(350, 150), r.ClosestPoint(PointF(350, 150)));
  439. EXPECT_EQ(PointF(350, 250), r.ClosestPoint(PointF(350, 250)));
  440. EXPECT_EQ(PointF(150, 250), r.ClosestPoint(PointF(150, 250)));
  441. EXPECT_EQ(PointF(50, 250), r.ClosestPoint(PointF(50, 250)));
  442. EXPECT_EQ(PointF(50, 150), r.ClosestPoint(PointF(50, 150)));
  443. EXPECT_EQ(PointF(150, 150), r.ClosestPoint(PointF(150, 150)));
  444. // 6
  445. EXPECT_EQ(PointF(350, 150), r.ClosestPoint(PointF(380, 150)));
  446. // 7
  447. EXPECT_EQ(PointF(50, 250), r.ClosestPoint(PointF(10, 280)));
  448. // 8
  449. EXPECT_EQ(PointF(180, 250), r.ClosestPoint(PointF(180, 300)));
  450. // 9
  451. EXPECT_EQ(PointF(350, 250), r.ClosestPoint(PointF(450, 450)));
  452. }
  453. TEST(RectFTest, MapRect) {
  454. EXPECT_RECTF_EQ(RectF(), MapRect(RectF(), RectF(), RectF()));
  455. EXPECT_RECTF_EQ(RectF(),
  456. MapRect(RectF(1, 2, 3, 4), RectF(), RectF(5, 6, 7, 8)));
  457. EXPECT_RECTF_EQ(
  458. RectF(1, 2, 3, 4),
  459. MapRect(RectF(1, 2, 3, 4), RectF(5, 6, 7, 8), RectF(5, 6, 7, 8)));
  460. EXPECT_RECTF_EQ(
  461. RectF(5, 6, 7, 8),
  462. MapRect(RectF(1, 2, 3, 4), RectF(1, 2, 3, 4), RectF(5, 6, 7, 8)));
  463. EXPECT_RECTF_EQ(
  464. RectF(200, 300, 300, 400),
  465. MapRect(RectF(1, 2, 3, 4), RectF(0, 1, 6, 8), RectF(100, 200, 600, 800)));
  466. EXPECT_RECTF_EQ(RectF(1, 2, 3, 4),
  467. MapRect(RectF(200, 300, 300, 400), RectF(100, 200, 600, 800),
  468. RectF(0, 1, 6, 8)));
  469. }
  470. } // namespace gfx