Rename GeometryTest namepsace to geometry_test

https://google.github.io/styleguide/cppguide.html#Namespace_Names
> Namespace names are all lower-case.

This CL has no behavior changes.

Bug: 889726
Change-Id: If8167502426867a143dc15200809b21b08dfb520
Reviewed-on: https://chromium-review.googlesource.com/c/1293293Reviewed-by: Kent Tamura <tkent@chromium.org>
Commit-Queue: Zhuoyu Qian <zhuoyu.qian@samsung.com>
Cr-Commit-Position: refs/heads/master@{#601494}

third_party/blink/renderer/platform/geometry/float_box_test_helpers.cc

@@ -33,7 +33,7 @@ namespace blink {
 namespace FloatBoxTest {
 
 bool ApproximatelyEqual(const float& a, const float& b) {
-  return GeometryTest::ApproximatelyEqual(a, b, kTestEpsilon);
+  return geometry_test::ApproximatelyEqual(a, b, kTestEpsilon);
 }
 
 bool ApproximatelyEqual(const FloatBox& a, const FloatBox& b) {

third_party/blink/renderer/platform/geometry/float_point_test.cc

@@ -12,19 +12,19 @@ namespace blink {
 TEST(FloatPointTest, LengthTest) {
   // Sanity check the Pythagorean triples 3-4-5 and 5-12-13
   FloatPoint p1 = FloatPoint(3.f, 4.f);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual, p1.length(), 5.f);
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual, p1.length(), 5.f);
   FloatPoint p2 = FloatPoint(5.f, 12.f);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual, p2.length(), 13.f);
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual, p2.length(), 13.f);
 
   // Test very small numbers. This fails under the old implementation of
   // FloatPoint::length(): `return sqrtf(lengthSquared());'
   FloatPoint p3 = FloatPoint(.5e-20f, .5e-20f);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual, p3.length(),
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual, p3.length(),
                       .707106781186548e-20f);
 
   // Test very large numbers.
   FloatPoint p4 = FloatPoint(.5e20f, .5e20f);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual, p4.length(),
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual, p4.length(),
                       .707106781186548e20f);
 }
 

third_party/blink/renderer/platform/geometry/float_rect_test.cc

@@ -31,107 +31,107 @@ TEST(FloatRectTest, SquaredDistanceToTest) {
 
   // `1` case
   FloatPoint p1(80, 80);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual, r1.SquaredDistanceTo(p1),
-                      800.f);
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual,
+                      r1.SquaredDistanceTo(p1), 800.f);
 
   FloatPoint p2(-10, -10);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual, r1.SquaredDistanceTo(p2),
-                      24200.f);
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual,
+                      r1.SquaredDistanceTo(p2), 24200.f);
 
   FloatPoint p3(80, -10);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual, r1.SquaredDistanceTo(p3),
-                      12500.f);
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual,
+                      r1.SquaredDistanceTo(p3), 12500.f);
 
   // `2` case
   FloatPoint p4(110, 80);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual, r1.SquaredDistanceTo(p4),
-                      400.f);
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual,
+                      r1.SquaredDistanceTo(p4), 400.f);
 
   FloatPoint p5(150, 0);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual, r1.SquaredDistanceTo(p5),
-                      10000.f);
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual,
+                      r1.SquaredDistanceTo(p5), 10000.f);
 
   FloatPoint p6(180, -10);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual, r1.SquaredDistanceTo(p6),
-                      12100.f);
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual,
+                      r1.SquaredDistanceTo(p6), 12100.f);
 
   // `3` case
   FloatPoint p7(400, 80);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual, r1.SquaredDistanceTo(p7),
-                      2900.f);
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual,
+                      r1.SquaredDistanceTo(p7), 2900.f);
 
   FloatPoint p8(360, -10);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual, r1.SquaredDistanceTo(p8),
-                      12200.f);
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual,
+                      r1.SquaredDistanceTo(p8), 12200.f);
 
   // `4` case
   FloatPoint p9(80, 110);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual, r1.SquaredDistanceTo(p9),
-                      400.f);
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual,
+                      r1.SquaredDistanceTo(p9), 400.f);
 
   FloatPoint p10(-10, 180);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual,
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual,
                       r1.SquaredDistanceTo(p10), 12100.f);
 
   // `5`(& In) case
   FloatPoint p11(100, 100);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual,
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual,
                       r1.SquaredDistanceTo(p11), 0.f);
 
   FloatPoint p12(150, 100);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual,
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual,
                       r1.SquaredDistanceTo(p12), 0.f);
 
   FloatPoint p13(350, 100);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual,
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual,
                       r1.SquaredDistanceTo(p13), 0.f);
 
   FloatPoint p14(350, 150);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual,
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual,
                       r1.SquaredDistanceTo(p14), 0.f);
 
   FloatPoint p15(350, 250);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual,
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual,
                       r1.SquaredDistanceTo(p15), 0.f);
 
   FloatPoint p16(150, 250);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual,
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual,
                       r1.SquaredDistanceTo(p16), 0.f);
 
   FloatPoint p17(100, 250);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual,
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual,
                       r1.SquaredDistanceTo(p17), 0.f);
 
   FloatPoint p18(100, 150);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual,
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual,
                       r1.SquaredDistanceTo(p18), 0.f);
 
   FloatPoint p19(150, 150);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual,
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual,
                       r1.SquaredDistanceTo(p19), 0.f);
 
   // `6` case
   FloatPoint p20(380, 150);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual,
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual,
                       r1.SquaredDistanceTo(p20), 900.f);
 
   // `7` case
   FloatPoint p21(80, 280);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual,
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual,
                       r1.SquaredDistanceTo(p21), 1300.f);
 
   FloatPoint p22(-10, 300);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual,
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual,
                       r1.SquaredDistanceTo(p22), 14600.f);
 
   // `8` case
   FloatPoint p23(180, 300);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual,
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual,
                       r1.SquaredDistanceTo(p23), 2500.f);
 
   // `9` case
   FloatPoint p24(450, 450);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual,
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual,
                       r1.SquaredDistanceTo(p24), 50000.f);
 }
 

third_party/blink/renderer/platform/geometry/float_size_test.cc

@@ -12,20 +12,20 @@ namespace blink {
 TEST(FloatSizeTest, DiagonalLengthTest) {
   // Sanity check the Pythagorean triples 3-4-5 and 5-12-13
   FloatSize s1 = FloatSize(3.f, 4.f);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual, s1.DiagonalLength(),
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual, s1.DiagonalLength(),
                       5.f);
   FloatSize s2 = FloatSize(5.f, 12.f);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual, s2.DiagonalLength(),
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual, s2.DiagonalLength(),
                       13.f);
 
   // Test very small numbers.
   FloatSize s3 = FloatSize(.5e-20f, .5e-20f);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual, s3.DiagonalLength(),
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual, s3.DiagonalLength(),
                       .707106781186548e-20f);
 
   // Test very large numbers.
   FloatSize s4 = FloatSize(.5e20f, .5e20f);
-  EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual, s4.DiagonalLength(),
+  EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual, s4.DiagonalLength(),
                       .707106781186548e20f);
 }
 

third_party/blink/renderer/platform/geometry/geometry_test_helpers.cc

@@ -8,7 +8,7 @@
 #include <math.h>
 
 namespace blink {
-namespace GeometryTest {
+namespace geometry_test {
 
 bool ApproximatelyEqual(float a, float b, float test_epsilon) {
   float abs_a = ::fabs(a);
@@ -39,5 +39,5 @@ testing::AssertionResult AssertAlmostEqual(const char* actual_expr,
   return testing::AssertionSuccess();
 }
 
-}  // namespace GeometryTest
+}  // namespace geometry_test
 }  // namespace blink

third_party/blink/renderer/platform/geometry/geometry_test_helpers.h

@@ -8,7 +8,7 @@
 #include <gtest/gtest.h>
 
 namespace blink {
-namespace GeometryTest {
+namespace geometry_test {
 
 bool ApproximatelyEqual(float, float, float test_epsilon);
 testing::AssertionResult AssertAlmostEqual(const char* actual_expr,
@@ -17,7 +17,7 @@ testing::AssertionResult AssertAlmostEqual(const char* actual_expr,
                                            float expected,
                                            float test_epsilon = 1e-6);
 
-}  // namespace GeometryTest
+}  // namespace geometry_test
 }  // namespace blink
 
 #endif

third_party/blink/renderer/platform/graphics/paint/geometry_mapper_test.cc

@@ -53,16 +53,16 @@ class GeometryMapperTest : public testing::Test,
 
 INSTANTIATE_PAINT_TEST_CASE_P(GeometryMapperTest);
 
-#define EXPECT_FLOAT_RECT_NEAR(expected, actual)                            \
-  do {                                                                      \
-    EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual, (actual).X(),      \
-                        (expected).X());                                    \
-    EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual, (actual).Y(),      \
-                        (expected).Y());                                    \
-    EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual, (actual).Width(),  \
-                        (expected).Width());                                \
-    EXPECT_PRED_FORMAT2(GeometryTest::AssertAlmostEqual, (actual).Height(), \
-                        (expected).Height());                               \
+#define EXPECT_FLOAT_RECT_NEAR(expected, actual)                             \
+  do {                                                                       \
+    EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual, (actual).X(),      \
+                        (expected).X());                                     \
+    EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual, (actual).Y(),      \
+                        (expected).Y());                                     \
+    EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual, (actual).Width(),  \
+                        (expected).Width());                                 \
+    EXPECT_PRED_FORMAT2(geometry_test::AssertAlmostEqual, (actual).Height(), \
+                        (expected).Height());                                \
   } while (false)
 
 #define EXPECT_CLIP_RECT_EQ(expected, actual)                       \