Enhance unit tests for normals.

cc/quads/draw_polygon_unittest.cc

 // Copyright 2014 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.
 
 // We would like to use M_PI on windows too.
 #ifdef _WIN32
 #define _USE_MATH_DEFINES
 #endif
 
 #include <stddef.h>
@@ skipping 56 matching lines @@
   std::vector<gfx::Point3F> vertices;
   vertices.push_back(gfx::Point3F(0.0f, 10.0f, 0.0f));
   vertices.push_back(gfx::Point3F(0.0f, 0.0f, 0.0f));
   vertices.push_back(gfx::Point3F(10.0f, 0.0f, 0.0f));
   vertices.push_back(gfx::Point3F(10.0f, 10.0f, 0.0f));
 
   CREATE_TEST_DRAW_POLYGON(polygon, vertices, 1);
   EXPECT_NORMAL(polygon, 0.0f, 0.0f, 1.0f);
 }
 
-TEST(DrawPolygonConstructionTest, InverseNormal) {
-  std::vector<gfx::Point3F> vertices;
-  vertices.push_back(gfx::Point3F(0.0f, 10.0f, 0.0f));
-  vertices.push_back(gfx::Point3F(10.0f, 10.0f, 0.0f));
-  vertices.push_back(gfx::Point3F(10.0f, 0.0f, 0.0f));
-  vertices.push_back(gfx::Point3F(0.0f, 0.0f, 0.0f));
-
-  CREATE_TEST_DRAW_POLYGON(polygon, vertices, 1);
-  EXPECT_NORMAL(polygon, 0.0f, 0.0f, -1.0f);
-}
-
 TEST(DrawPolygonConstructionTest, ClippedNormal) {
   std::vector<gfx::Point3F> vertices;
   vertices.push_back(gfx::Point3F(0.1f, 10.0f, 0.0f));
   vertices.push_back(gfx::Point3F(0.0f, 9.9f, 0.0f));
   vertices.push_back(gfx::Point3F(0.0f, 10.0f, 0.0f));
   vertices.push_back(gfx::Point3F(0.0f, 0.0f, 0.0f));
   vertices.push_back(gfx::Point3F(10.0f, 0.0f, 0.0f));
   vertices.push_back(gfx::Point3F(10.0f, 10.0f, 0.0f));
 
   CREATE_TEST_DRAW_POLYGON(polygon, vertices, 1);
@@ skipping 20 matching lines @@
                                       sin(i * M_PI / 50) + 99.0f, 100.0f));
   }
   CREATE_TEST_DRAW_POLYGON(polygon_c, vertices_c, 3);
   EXPECT_NORMAL(polygon_c, 0.0f, 0.0f, 1.0f);
 
   CREATE_TEST_DRAW_POLYGON(polygon_d, vertices_d, 4);
   EXPECT_NORMAL(polygon_c, 0.0f, 0.0f, 1.0f);
 }
 
 // A simple rect being transformed.
-TEST(DrawPolygonConstructionTest, DizzyNormal) {
+TEST(DrawPolygonConstructionTest, SimpleNormal) {
   gfx::RectF src(-0.1f, -10.0f, 0.2f, 20.0f);
 
   gfx::Transform transform_i(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
   DrawPolygon polygon_i(NULL, src, transform_i, 1);
 
   EXPECT_NORMAL(polygon_i, 0.0f, 0.0f, 1.0f);
+}
 
-  gfx::Transform tranform_a(0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
-  DrawPolygon polygon_a(NULL, src, tranform_a, 2);
-  EXPECT_NORMAL(polygon_a, 0.0f, 0.0f, -1.0f);
+TEST(DrawPolygonConstructionTest, DISABLED_NormalInvertXY) {
+  gfx::RectF src(-0.1f, -10.0f, 0.2f, 20.0f);
 
-  gfx::Transform tranform_b(0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1);
-  DrawPolygon polygon_b(NULL, src, tranform_b, 3);
-  EXPECT_NORMAL(polygon_b, -1.0f, 0.0f, 0.0f);
+  gfx::Transform transform(0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
+  DrawPolygon polygon_a(NULL, src, transform, 2);
 
-  gfx::Transform tranform_c(1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1);
-  DrawPolygon polygon_c(NULL, src, tranform_c, 4);
-  EXPECT_NORMAL(polygon_c, 0.0f, -1.0f, 0.0f);
+  EXPECT_NORMAL(polygon_a, 0.0f, 0.0f, 1.0f);
+}
 
-  gfx::Transform tranform_d(-1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
-  DrawPolygon polygon_d(NULL, src, tranform_d, 5);
+TEST(DrawPolygonConstructionTest, DISABLED_NormalInvertXZ) {
+  gfx::RectF src(-0.1f, -10.0f, 0.2f, 20.0f);
+
+  gfx::Transform transform(0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1);
+  DrawPolygon polygon_b(NULL, src, transform, 3);
+
+  EXPECT_NORMAL(polygon_b, 1.0f, 0.0f, 0.0f);
+}
+
+TEST(DrawPolygonConstructionTest, DISABLED_NormalInvertYZ) {
+  gfx::RectF src(-0.1f, -10.0f, 0.2f, 20.0f);
+
+  gfx::Transform transform(1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1);
+  DrawPolygon polygon_c(NULL, src, transform, 4);
+
+  EXPECT_NORMAL(polygon_c, 0.0f, 1.0f, 0.0f);
+}
+
+TEST(DrawPolygonConstructionTest, NormalRotate90) {
+  gfx::RectF src(-0.1f, -10.0f, 0.2f, 20.0f);
+
+  gfx::Transform transform(0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1);
+  DrawPolygon polygon_b(NULL, src, transform, 3);
+
+  EXPECT_NORMAL(polygon_b, 0.0f, 0.0f, 1.0f);
+}
+
+// Bug https://bugs.chromium.org/p/chromium/issues/detail?id=595820
+TEST(DrawPolygonConstructionTest, DISABLED_InvertXNormal) {
+  gfx::RectF src(-0.1f, -10.0f, 0.2f, 20.0f);
+
+  gfx::Transform transform(-1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
+  DrawPolygon polygon_d(NULL, src, transform, 5);
+
+  EXPECT_NORMAL(polygon_d, 0.0f, 0.0f, 1.0f);
+}
+
+TEST(DrawPolygonConstructionTest, DISABLED_InvertYNormal) {
+  gfx::RectF src(-0.1f, -10.0f, 0.2f, 20.0f);
+
+  gfx::Transform transform(1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
+  DrawPolygon polygon_d(NULL, src, transform, 5);
+
+  EXPECT_NORMAL(polygon_d, 0.0f, 0.0f, 1.0f);
+}
+
+TEST(DrawPolygonConstructionTest, DISABLED_InvertZNormal) {
+  gfx::RectF src(-0.1f, -10.0f, 0.2f, 20.0f);
+
+  gfx::Transform transform(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1);
+  DrawPolygon polygon_d(NULL, src, transform, 5);
+
   EXPECT_NORMAL(polygon_d, 0.0f, 0.0f, -1.0f);
 }
 
 // Two quads are nearly touching but definitely ordered. Second one should
 // compare in front.
 TEST(DrawPolygonSplitTest, NearlyTouchingOrder) {
   std::vector<gfx::Point3F> vertices_a;
   vertices_a.push_back(gfx::Point3F(0.0f, 10.0f, 0.0f));
   vertices_a.push_back(gfx::Point3F(0.0f, 0.0f, 0.0f));
   vertices_a.push_back(gfx::Point3F(10.0f, 0.0f, 0.0f));
@@ skipping 39 matching lines @@
 
 // Two quads are definitely not touching and so no split should occur.
 TEST(DrawPolygonSplitTest, NotTouchingNoSplit) {
   std::vector<gfx::Point3F> vertices_a;
   vertices_a.push_back(gfx::Point3F(0.0f, 10.0f, 0.0f));
   vertices_a.push_back(gfx::Point3F(0.0f, 0.0f, 0.0f));
   vertices_a.push_back(gfx::Point3F(10.0f, 0.0f, 0.0f));
   vertices_a.push_back(gfx::Point3F(10.0f, 10.0f, 0.0f));
   std::vector<gfx::Point3F> vertices_b;
   vertices_b.push_back(gfx::Point3F(5.0f, 10.0f, 5.0f));
+  vertices_b.push_back(gfx::Point3F(5.0f, 10.0f, 15.0f));
   vertices_b.push_back(gfx::Point3F(5.0f, 0.0f, 15.0f));
-  vertices_b.push_back(gfx::Point3F(5.0f, 0.0f, 15.0f));
-  vertices_b.push_back(gfx::Point3F(5.0f, 10.0f, 5.0f));
+  vertices_b.push_back(gfx::Point3F(5.0f, 0.0f, 5.0f));
 
   CREATE_NEW_DRAW_POLYGON(
       polygon_a, vertices_a, gfx::Vector3dF(0.0f, 0.0f, 1.0f), 0);
   CREATE_NEW_DRAW_POLYGON(
       polygon_b, vertices_b, gfx::Vector3dF(-1.0f, 0.0f, 0.0f), 1);
 
   EXPECT_EQ(BSP_FRONT, DrawPolygon::SideCompare(polygon_b, polygon_a));
 }
 
 // One quad is resting against another, but doesn't cross its plane so no split
 // should occur.
 TEST(DrawPolygonSplitTest, BarelyTouchingNoSplit) {
   std::vector<gfx::Point3F> vertices_a;
   vertices_a.push_back(gfx::Point3F(0.0f, 10.0f, 0.0f));
   vertices_a.push_back(gfx::Point3F(0.0f, 0.0f, 0.0f));
   vertices_a.push_back(gfx::Point3F(10.0f, 0.0f, 0.0f));
   vertices_a.push_back(gfx::Point3F(10.0f, 10.0f, 0.0f));
   std::vector<gfx::Point3F> vertices_b;
   vertices_b.push_back(gfx::Point3F(5.0f, 10.0f, 0.0f));
+  vertices_b.push_back(gfx::Point3F(5.0f, 10.0f, -10.0f));
   vertices_b.push_back(gfx::Point3F(5.0f, 0.0f, -10.0f));
-  vertices_b.push_back(gfx::Point3F(5.0f, 0.0f, -10.0f));
-  vertices_b.push_back(gfx::Point3F(5.0f, 10.0f, 0.0f));
+  vertices_b.push_back(gfx::Point3F(5.0f, 0.0f, 0.0f));
 
   CREATE_NEW_DRAW_POLYGON(
       polygon_a, vertices_a, gfx::Vector3dF(0.0f, 0.0f, 1.0f), 0);
   CREATE_NEW_DRAW_POLYGON(
       polygon_b, vertices_b, gfx::Vector3dF(-1.0f, 0.0f, 0.0f), 1);
 
   EXPECT_EQ(BSP_BACK, DrawPolygon::SideCompare(polygon_b, polygon_a));
 }
 
 // One quad intersects another and becomes two pieces.
@@ skipping 107 matching lines @@
 
   // Note: We use EXPECT_FLOAT_WITHIN_EPSILON instead of EXPECT_FLOAT_EQUAL here
   // because some architectures (e.g., Arm64) employ a fused multiply-add
   // instruction which causes rounding asymmetry and reduces precision.
   // http://crbug.com/401117.
   EXPECT_NORMAL(polygon_a, 0.0f, 0.0f, -1.0f);
 }
 
 }  // namespace
 }  // namespace cc