// Copyright 2013 The Flutter 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 <memory>

#include "flutter/display_list/geometry/dl_path_builder.h"
#include "flutter/testing/testing.h"
#include "gtest/gtest.h"
#include "impeller/entity/contents/content_context.h"
#include "impeller/entity/contents/pipelines.h"
#include "impeller/entity/geometry/geometry.h"
#include "impeller/entity/geometry/round_rect_geometry.h"
#include "impeller/entity/geometry/stroke_path_geometry.h"
#include "impeller/geometry/constants.h"
#include "impeller/geometry/geometry_asserts.h"
#include "impeller/renderer/testing/mocks.h"

inline ::testing::AssertionResult SolidVerticesNear(
    std::vector<impeller::Point> a,
    std::vector<impeller::Point> b) {
  if (a.size() != b.size()) {
    return ::testing::AssertionFailure() << "Colors length does not match";
  }
  for (auto i = 0u; i < b.size(); i++) {
    if (!PointNear(a[i], b[i])) {
      return ::testing::AssertionFailure() << "Positions are not equal.";
    }
  }
  return ::testing::AssertionSuccess();
}

inline ::testing::AssertionResult TextureVerticesNear(
    std::vector<impeller::TextureFillVertexShader::PerVertexData> a,
    std::vector<impeller::TextureFillVertexShader::PerVertexData> b) {
  if (a.size() != b.size()) {
    return ::testing::AssertionFailure() << "Colors length does not match";
  }
  for (auto i = 0u; i < b.size(); i++) {
    if (!PointNear(a[i].position, b[i].position)) {
      return ::testing::AssertionFailure() << "Positions are not equal.";
    }
    if (!PointNear(a[i].texture_coords, b[i].texture_coords)) {
      return ::testing::AssertionFailure() << "Texture coords are not equal.";
    }
  }
  return ::testing::AssertionSuccess();
}

#define EXPECT_SOLID_VERTICES_NEAR(a, b) \
  EXPECT_PRED2(&::SolidVerticesNear, a, b)
#define EXPECT_TEXTURE_VERTICES_NEAR(a, b) \
  EXPECT_PRED2(&::TextureVerticesNear, a, b)

namespace impeller {

class ImpellerEntityUnitTestAccessor {
 public:
  static std::vector<Point> GenerateSolidStrokeVertices(
      const PathSource& path,
      const StrokeParameters& stroke,
      Scalar scale) {
    // We could create a single Tessellator instance for the whole suite,
    // but we don't really need performance for unit tests.
    Tessellator tessellator;
    return StrokePathGeometry::GenerateSolidStrokeVertices(  //
        tessellator, path, stroke, scale);
  }
};

namespace testing {

TEST(EntityGeometryTest, RectGeometryCoversArea) {
  auto geometry = Geometry::MakeRect(Rect::MakeLTRB(0, 0, 100, 100));
  ASSERT_TRUE(geometry->CoversArea({}, Rect::MakeLTRB(0, 0, 100, 100)));
  ASSERT_FALSE(geometry->CoversArea({}, Rect::MakeLTRB(-1, 0, 100, 100)));
  ASSERT_TRUE(geometry->CoversArea({}, Rect::MakeLTRB(1, 1, 100, 100)));
  ASSERT_TRUE(geometry->CoversArea({}, Rect()));
}

TEST(EntityGeometryTest, FillPathGeometryCoversArea) {
  auto path = flutter::DlPathBuilder{}
                  .AddRect(Rect::MakeLTRB(0, 0, 100, 100))
                  .TakePath();
  auto geometry = Geometry::MakeFillPath(
      path, /* inner rect */ Rect::MakeLTRB(0, 0, 100, 100));
  ASSERT_TRUE(geometry->CoversArea({}, Rect::MakeLTRB(0, 0, 100, 100)));
  ASSERT_FALSE(geometry->CoversArea({}, Rect::MakeLTRB(-1, 0, 100, 100)));
  ASSERT_TRUE(geometry->CoversArea({}, Rect::MakeLTRB(1, 1, 100, 100)));
  ASSERT_TRUE(geometry->CoversArea({}, Rect()));
}

TEST(EntityGeometryTest, FillPathGeometryCoversAreaNoInnerRect) {
  auto path = flutter::DlPathBuilder{}
                  .AddRect(Rect::MakeLTRB(0, 0, 100, 100))
                  .TakePath();
  auto geometry = Geometry::MakeFillPath(path);
  ASSERT_FALSE(geometry->CoversArea({}, Rect::MakeLTRB(0, 0, 100, 100)));
  ASSERT_FALSE(geometry->CoversArea({}, Rect::MakeLTRB(-1, 0, 100, 100)));
  ASSERT_FALSE(geometry->CoversArea({}, Rect::MakeLTRB(1, 1, 100, 100)));
  ASSERT_FALSE(geometry->CoversArea({}, Rect()));
}

TEST(EntityGeometryTest, FillArcGeometryCoverage) {
  Rect oval_bounds = Rect::MakeLTRB(100, 100, 200, 200);
  Matrix transform45 = Matrix::MakeTranslation(oval_bounds.GetCenter()) *
                       Matrix::MakeRotationZ(Degrees(45)) *
                       Matrix::MakeTranslation(-oval_bounds.GetCenter());

  {  // Sweeps <=-360 or >=360
    for (int start = -720; start <= 720; start += 10) {
      for (int sweep = 360; sweep <= 720; sweep += 30) {
        std::string label =
            "start: " + std::to_string(start) + " + " + std::to_string(sweep);
        auto geometry = Geometry::MakeFilledArc(oval_bounds, Degrees(start),
                                                Degrees(sweep), false);
        EXPECT_EQ(geometry->GetCoverage({}), oval_bounds)
            << "start: " << start << ", sweep: " << sweep;
        geometry = Geometry::MakeFilledArc(oval_bounds, Degrees(start),
                                           Degrees(-sweep), false);
        EXPECT_EQ(geometry->GetCoverage({}), oval_bounds)
            << "start: " << start << ", sweep: " << -sweep;
        geometry = Geometry::MakeFilledArc(oval_bounds, Degrees(start),
                                           Degrees(-sweep), true);
        EXPECT_EQ(geometry->GetCoverage({}), oval_bounds)
            << "start: " << start << ", sweep: " << -sweep << ", with center";
      }
    }
  }
  {  // Sweep from late in one quadrant to earlier in same quadrant
    for (int start = 60; start < 360; start += 90) {
      auto geometry = Geometry::MakeFilledArc(oval_bounds, Degrees(start),
                                              Degrees(330), false);
      EXPECT_EQ(geometry->GetCoverage({}), oval_bounds)
          << "start: " << start << " without center";
      geometry = Geometry::MakeFilledArc(oval_bounds, Degrees(start),
                                         Degrees(330), true);
      EXPECT_EQ(geometry->GetCoverage({}), oval_bounds)
          << "start: " << start << " with center";
    }
  }
  {  // Sweep from early in one quadrant backwards to later in same quadrant
    for (int start = 30; start < 360; start += 90) {
      auto geometry = Geometry::MakeFilledArc(oval_bounds, Degrees(start),
                                              Degrees(-330), false);
      EXPECT_EQ(geometry->GetCoverage({}), oval_bounds)
          << "start: " << start << " without center";
      geometry = Geometry::MakeFilledArc(oval_bounds, Degrees(start),
                                         Degrees(-330), true);
      EXPECT_EQ(geometry->GetCoverage({}), oval_bounds)
          << "start: " << start << " with center";
    }
  }
  {  // Sweep past each quadrant axis individually, no center
    for (int start = -360; start <= 720; start += 360) {
      {  // Quadrant 0
        auto geometry = Geometry::MakeFilledArc(
            oval_bounds, Degrees(start - 45), Degrees(90), false);
        Rect expected_bounds = Rect::MakeLTRB(150 + 50 * kSqrt2Over2,  //
                                              150 - 50 * kSqrt2Over2,  //
                                              200,                     //
                                              150 + 50 * kSqrt2Over2);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start - 45;
      }
      {  // Quadrant 1
        auto geometry = Geometry::MakeFilledArc(
            oval_bounds, Degrees(start + 45), Degrees(90), false);
        Rect expected_bounds = Rect::MakeLTRB(150 - 50 * kSqrt2Over2,  //
                                              150 + 50 * kSqrt2Over2,  //
                                              150 + 50 * kSqrt2Over2,  //
                                              200);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start + 45;
      }
      {  // Quadrant 2
        auto geometry = Geometry::MakeFilledArc(
            oval_bounds, Degrees(start + 135), Degrees(90), false);
        Rect expected_bounds = Rect::MakeLTRB(100,                     //
                                              150 - 50 * kSqrt2Over2,  //
                                              150 - 50 * kSqrt2Over2,  //
                                              150 + 50 * kSqrt2Over2);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start + 135;
      }
      {  // Quadrant 3
        auto geometry = Geometry::MakeFilledArc(
            oval_bounds, Degrees(start + 225), Degrees(90), false);
        Rect expected_bounds = Rect::MakeLTRB(150 - 50 * kSqrt2Over2,  //
                                              100,                     //
                                              150 + 50 * kSqrt2Over2,  //
                                              150 - 50 * kSqrt2Over2);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start + 225;
      }
    }
  }
  {  // Sweep past each quadrant axis individually, including the center
    for (int start = -360; start <= 720; start += 360) {
      {  // Quadrant 0
        auto geometry = Geometry::MakeFilledArc(
            oval_bounds, Degrees(start - 45), Degrees(90), true);
        Rect expected_bounds = Rect::MakeLTRB(150,                     //
                                              150 - 50 * kSqrt2Over2,  //
                                              200,                     //
                                              150 + 50 * kSqrt2Over2);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start - 45;
      }
      {  // Quadrant 1
        auto geometry = Geometry::MakeFilledArc(
            oval_bounds, Degrees(start + 45), Degrees(90), true);
        Rect expected_bounds = Rect::MakeLTRB(150 - 50 * kSqrt2Over2,  //
                                              150,                     //
                                              150 + 50 * kSqrt2Over2,  //
                                              200);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start + 45;
      }
      {  // Quadrant 2
        auto geometry = Geometry::MakeFilledArc(
            oval_bounds, Degrees(start + 135), Degrees(90), true);
        Rect expected_bounds = Rect::MakeLTRB(100,                     //
                                              150 - 50 * kSqrt2Over2,  //
                                              150,                     //
                                              150 + 50 * kSqrt2Over2);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start + 135;
      }
      {  // Quadrant 3
        auto geometry = Geometry::MakeFilledArc(
            oval_bounds, Degrees(start + 225), Degrees(90), true);
        Rect expected_bounds = Rect::MakeLTRB(150 - 50 * kSqrt2Over2,  //
                                              100,                     //
                                              150 + 50 * kSqrt2Over2,  //
                                              150);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start + 225;
      }
    }
  }
  {  // 45 degree tilted full circle
    auto geometry =
        Geometry::MakeFilledArc(oval_bounds, Degrees(0), Degrees(360), false);
    ASSERT_TRUE(oval_bounds.TransformBounds(transform45).Contains(oval_bounds));

    EXPECT_TRUE(geometry->GetCoverage(transform45)
                    .value_or(Rect())
                    .Contains(oval_bounds));
  }
  {  // 45 degree tilted mostly full circle
    auto geometry =
        Geometry::MakeFilledArc(oval_bounds, Degrees(3), Degrees(359), false);
    ASSERT_TRUE(oval_bounds.TransformBounds(transform45).Contains(oval_bounds));

    EXPECT_TRUE(geometry->GetCoverage(transform45)
                    .value_or(Rect())
                    .Contains(oval_bounds));
  }
}

TEST(EntityGeometryTest, StrokeArcGeometryCoverage) {
  Rect oval_bounds = Rect::MakeLTRB(100, 100, 200, 200);
  Rect expanded_bounds = Rect::MakeLTRB(95, 95, 205, 205);
  Rect squared_bounds = Rect::MakeLTRB(100 - 5 * kSqrt2, 100 - 5 * kSqrt2,
                                       200 + 5 * kSqrt2, 200 + 5 * kSqrt2);
  Matrix transform45 = Matrix::MakeTranslation(oval_bounds.GetCenter()) *
                       Matrix::MakeRotationZ(Degrees(45)) *
                       Matrix::MakeTranslation(-oval_bounds.GetCenter());

  StrokeParameters butt_params = {
      .width = 10.0f,
      .cap = Cap::kButt,
  };
  StrokeParameters square_params = {
      .width = 10.0f,
      .cap = Cap::kSquare,
  };

  {  // Sweeps <=-360 or >=360
    for (int start = -720; start <= 720; start += 10) {
      for (int sweep = 360; sweep <= 720; sweep += 30) {
        std::string label =
            "start: " + std::to_string(start) + " + " + std::to_string(sweep);
        auto geometry = Geometry::MakeStrokedArc(oval_bounds, Degrees(start),
                                                 Degrees(sweep), butt_params);
        EXPECT_EQ(geometry->GetCoverage({}), expanded_bounds)
            << "start: " << start << ", sweep: " << sweep;
        geometry = Geometry::MakeStrokedArc(oval_bounds, Degrees(start),
                                            Degrees(-sweep), butt_params);
        EXPECT_EQ(geometry->GetCoverage({}), expanded_bounds)
            << "start: " << start << ", sweep: " << -sweep;
        geometry = Geometry::MakeStrokedArc(oval_bounds, Degrees(start),
                                            Degrees(-sweep), square_params);
        EXPECT_EQ(geometry->GetCoverage({}), expanded_bounds)
            << "start: " << start << ", sweep: " << -sweep << ", square caps";
      }
    }
  }
  {  // Sweep from late in one quadrant to earlier in same quadrant
    for (int start = 60; start < 360; start += 90) {
      auto geometry = Geometry::MakeStrokedArc(oval_bounds, Degrees(start),
                                               Degrees(330), butt_params);
      EXPECT_EQ(geometry->GetCoverage({}), expanded_bounds)
          << "start: " << start << ", butt caps";
      geometry = Geometry::MakeStrokedArc(oval_bounds, Degrees(start),
                                          Degrees(330), square_params);
      EXPECT_EQ(geometry->GetCoverage({}), squared_bounds)
          << "start: " << start << ", square caps";
    }
  }
  {  // Sweep from early in one quadrant backwards to later in same quadrant
    for (int start = 30; start < 360; start += 90) {
      auto geometry = Geometry::MakeStrokedArc(oval_bounds, Degrees(start),
                                               Degrees(-330), butt_params);
      EXPECT_EQ(geometry->GetCoverage({}), expanded_bounds)
          << "start: " << start << " without center";
      geometry = Geometry::MakeStrokedArc(oval_bounds, Degrees(start),
                                          Degrees(-330), square_params);
      EXPECT_EQ(geometry->GetCoverage({}), squared_bounds)
          << "start: " << start << " with center";
    }
  }
  {  // Sweep past each quadrant axis individually with butt caps
    for (int start = -360; start <= 720; start += 360) {
      {  // Quadrant 0
        auto geometry = Geometry::MakeStrokedArc(
            oval_bounds, Degrees(start - 45), Degrees(90), butt_params);
        Rect expected_bounds = Rect::MakeLTRB(150 + 50 * kSqrt2Over2 - 5,  //
                                              150 - 50 * kSqrt2Over2 - 5,  //
                                              205,                         //
                                              150 + 50 * kSqrt2Over2 + 5);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start - 45;
      }
      {  // Quadrant 1
        auto geometry = Geometry::MakeStrokedArc(
            oval_bounds, Degrees(start + 45), Degrees(90), butt_params);
        Rect expected_bounds = Rect::MakeLTRB(150 - 50 * kSqrt2Over2 - 5,  //
                                              150 + 50 * kSqrt2Over2 - 5,  //
                                              150 + 50 * kSqrt2Over2 + 5,  //
                                              205);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start + 45;
      }
      {  // Quadrant 2
        auto geometry = Geometry::MakeStrokedArc(
            oval_bounds, Degrees(start + 135), Degrees(90), butt_params);
        Rect expected_bounds = Rect::MakeLTRB(95,                          //
                                              150 - 50 * kSqrt2Over2 - 5,  //
                                              150 - 50 * kSqrt2Over2 + 5,  //
                                              150 + 50 * kSqrt2Over2 + 5);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start + 135;
      }
      {  // Quadrant 3
        auto geometry = Geometry::MakeStrokedArc(
            oval_bounds, Degrees(start + 225), Degrees(90), butt_params);
        Rect expected_bounds = Rect::MakeLTRB(150 - 50 * kSqrt2Over2 - 5,  //
                                              95,                          //
                                              150 + 50 * kSqrt2Over2 + 5,  //
                                              150 - 50 * kSqrt2Over2 + 5);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start + 225;
      }
    }
  }
  {  // Sweep past each quadrant axis individually with square caps
    Scalar pad = 5 * kSqrt2;
    for (int start = -360; start <= 720; start += 360) {
      {  // Quadrant 0
        auto geometry = Geometry::MakeStrokedArc(
            oval_bounds, Degrees(start - 45), Degrees(90), square_params);
        Rect expected_bounds = Rect::MakeLTRB(150 + 50 * kSqrt2Over2 - pad,  //
                                              150 - 50 * kSqrt2Over2 - pad,  //
                                              200 + pad,                     //
                                              150 + 50 * kSqrt2Over2 + pad);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start - 45;
      }
      {  // Quadrant 1
        auto geometry = Geometry::MakeStrokedArc(
            oval_bounds, Degrees(start + 45), Degrees(90), square_params);
        Rect expected_bounds = Rect::MakeLTRB(150 - 50 * kSqrt2Over2 - pad,  //
                                              150 + 50 * kSqrt2Over2 - pad,  //
                                              150 + 50 * kSqrt2Over2 + pad,  //
                                              200 + pad);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start + 45;
      }
      {  // Quadrant 2
        auto geometry = Geometry::MakeStrokedArc(
            oval_bounds, Degrees(start + 135), Degrees(90), square_params);
        Rect expected_bounds = Rect::MakeLTRB(100 - pad,                     //
                                              150 - 50 * kSqrt2Over2 - pad,  //
                                              150 - 50 * kSqrt2Over2 + pad,  //
                                              150 + 50 * kSqrt2Over2 + pad);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start + 135;
      }
      {  // Quadrant 3
        auto geometry = Geometry::MakeStrokedArc(
            oval_bounds, Degrees(start + 225), Degrees(90), square_params);
        Rect expected_bounds = Rect::MakeLTRB(150 - 50 * kSqrt2Over2 - pad,  //
                                              100 - pad,                     //
                                              150 + 50 * kSqrt2Over2 + pad,  //
                                              150 - 50 * kSqrt2Over2 + pad);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start + 225;
      }
    }
  }
  {  // 45 degree tilted full circle, butt caps
    auto geometry = Geometry::MakeStrokedArc(  //
        oval_bounds, Degrees(0), Degrees(360), butt_params);
    ASSERT_TRUE(
        oval_bounds.TransformBounds(transform45).Contains(expanded_bounds));

    EXPECT_TRUE(geometry->GetCoverage(transform45)
                    .value_or(Rect())
                    .Contains(expanded_bounds));
  }
  {  // 45 degree tilted full circle, square caps
    auto geometry = Geometry::MakeStrokedArc(  //
        oval_bounds, Degrees(0), Degrees(360), square_params);
    ASSERT_TRUE(
        oval_bounds.TransformBounds(transform45).Contains(expanded_bounds));

    EXPECT_TRUE(geometry->GetCoverage(transform45)
                    .value_or(Rect())
                    .Contains(squared_bounds));
  }
  {  // 45 degree tilted mostly full circle, butt caps
    auto geometry = Geometry::MakeStrokedArc(  //
        oval_bounds, Degrees(3), Degrees(359), butt_params);
    ASSERT_TRUE(
        oval_bounds.TransformBounds(transform45).Contains(expanded_bounds));

    EXPECT_TRUE(geometry->GetCoverage(transform45)
                    .value_or(Rect())
                    .Contains(expanded_bounds));
  }
  {  // 45 degree tilted mostly full circle, square caps
    auto geometry = Geometry::MakeStrokedArc(  //
        oval_bounds, Degrees(3), Degrees(359), square_params);
    ASSERT_TRUE(
        oval_bounds.TransformBounds(transform45).Contains(expanded_bounds));

    EXPECT_TRUE(geometry->GetCoverage(transform45)
                    .value_or(Rect())
                    .Contains(squared_bounds));
  }
}

TEST(EntityGeometryTest, FillRoundRectGeometryCoversArea) {
  Rect bounds = Rect::MakeLTRB(100, 100, 200, 200);
  RoundRect round_rect =
      RoundRect::MakeRectRadii(bounds, RoundingRadii{
                                           .top_left = Size(1, 11),
                                           .top_right = Size(2, 12),
                                           .bottom_left = Size(3, 13),
                                           .bottom_right = Size(4, 14),
                                       });
  FillRoundRectGeometry geom(round_rect);

  // Tall middle rect should barely be covered.
  EXPECT_TRUE(geom.CoversArea({}, Rect::MakeLTRB(103, 100, 196, 200)));
  EXPECT_FALSE(geom.CoversArea({}, Rect::MakeLTRB(102, 100, 196, 200)));
  EXPECT_FALSE(geom.CoversArea({}, Rect::MakeLTRB(103, 99, 196, 200)));
  EXPECT_FALSE(geom.CoversArea({}, Rect::MakeLTRB(103, 100, 197, 200)));
  EXPECT_FALSE(geom.CoversArea({}, Rect::MakeLTRB(103, 100, 196, 201)));

  // Wide middle rect should barely be covered.
  EXPECT_TRUE(geom.CoversArea({}, Rect::MakeLTRB(100, 112, 200, 186)));
  EXPECT_FALSE(geom.CoversArea({}, Rect::MakeLTRB(99, 112, 200, 186)));
  EXPECT_FALSE(geom.CoversArea({}, Rect::MakeLTRB(100, 111, 200, 186)));
  EXPECT_FALSE(geom.CoversArea({}, Rect::MakeLTRB(100, 112, 201, 186)));
  EXPECT_FALSE(geom.CoversArea({}, Rect::MakeLTRB(100, 112, 200, 187)));
}

TEST(EntityGeometryTest, LineGeometryCoverage) {
  {
    auto geometry = Geometry::MakeLine(  //
        {10, 10}, {20, 10}, {.width = 2, .cap = Cap::kButt});
    EXPECT_EQ(geometry->GetCoverage({}), Rect::MakeLTRB(10, 9, 20, 11));
    EXPECT_TRUE(geometry->CoversArea({}, Rect::MakeLTRB(10, 9, 20, 11)));
  }

  {
    auto geometry = Geometry::MakeLine(  //
        {10, 10}, {20, 10}, {.width = 2, .cap = Cap::kSquare});
    EXPECT_EQ(geometry->GetCoverage({}), Rect::MakeLTRB(9, 9, 21, 11));
    EXPECT_TRUE(geometry->CoversArea({}, Rect::MakeLTRB(9, 9, 21, 11)));
  }

  {
    auto geometry = Geometry::MakeLine(  //
        {10, 10}, {10, 20}, {.width = 2, .cap = Cap::kButt});
    EXPECT_EQ(geometry->GetCoverage({}), Rect::MakeLTRB(9, 10, 11, 20));
    EXPECT_TRUE(geometry->CoversArea({}, Rect::MakeLTRB(9, 10, 11, 20)));
  }

  {
    auto geometry = Geometry::MakeLine(  //
        {10, 10}, {10, 20}, {.width = 2, .cap = Cap::kSquare});
    EXPECT_EQ(geometry->GetCoverage({}), Rect::MakeLTRB(9, 9, 11, 21));
    EXPECT_TRUE(geometry->CoversArea({}, Rect::MakeLTRB(9, 9, 11, 21)));
  }
}

TEST(EntityGeometryTest, RoundRectGeometryCoversArea) {
  auto geometry =
      Geometry::MakeRoundRect(Rect::MakeLTRB(0, 0, 100, 100), Size(20, 20));
  EXPECT_FALSE(geometry->CoversArea({}, Rect::MakeLTRB(15, 15, 85, 85)));
  EXPECT_TRUE(geometry->CoversArea({}, Rect::MakeLTRB(20, 20, 80, 80)));
  EXPECT_TRUE(geometry->CoversArea({}, Rect::MakeLTRB(30, 1, 70, 99)));
  EXPECT_TRUE(geometry->CoversArea({}, Rect::MakeLTRB(1, 30, 99, 70)));
}

TEST(EntityGeometryTest, GeometryResultHasReasonableDefaults) {
  GeometryResult result;
  EXPECT_EQ(result.type, PrimitiveType::kTriangleStrip);
  EXPECT_EQ(result.transform, Matrix());
  EXPECT_EQ(result.mode, GeometryResult::Mode::kNormal);
}

TEST(EntityGeometryTest, AlphaCoverageStrokePaths) {
  auto matrix = Matrix::MakeScale(Vector2{3.0, 3.0});
  EXPECT_EQ(Geometry::MakeStrokePath({}, {.width = 0.5f})
                ->ComputeAlphaCoverage(matrix),
            1.0f);
  EXPECT_NEAR(Geometry::MakeStrokePath({}, {.width = 0.1f})
                  ->ComputeAlphaCoverage(matrix),
              0.6, 0.05);
  EXPECT_NEAR(Geometry::MakeStrokePath({}, {.width = 0.05})
                  ->ComputeAlphaCoverage(matrix),
              0.3, 0.05);
  EXPECT_NEAR(Geometry::MakeStrokePath({}, {.width = 0.01})
                  ->ComputeAlphaCoverage(matrix),
              0.1, 0.1);
  EXPECT_NEAR(Geometry::MakeStrokePath({}, {.width = 0.0000005f})
                  ->ComputeAlphaCoverage(matrix),
              1e-05, 0.001);
  EXPECT_EQ(Geometry::MakeStrokePath({}, {.width = 0.0f})
                ->ComputeAlphaCoverage(matrix),
            1.0f);
  EXPECT_EQ(Geometry::MakeStrokePath({}, {.width = 40.0f})
                ->ComputeAlphaCoverage(matrix),
            1.0f);
}

TEST(EntityGeometryTest, SimpleTwoLineStrokeVerticesButtCap) {
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo({20, 20});
  path_builder.LineTo({30, 20});
  path_builder.MoveTo({120, 20});
  path_builder.LineTo({130, 20});
  flutter::DlPath path = path_builder.TakePath();

  auto points = ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
      path,
      {
          .width = 10.0f,
          .cap = Cap::kButt,
          .join = Join::kBevel,
          .miter_limit = 4.0f,
      },
      1.0f);

  std::vector<Point> expected = {
      // The points for the first segment (20, 20) -> (30, 20)
      Point(20, 25),
      Point(20, 15),
      Point(30, 25),
      Point(30, 15),

      // The glue points that allow us to "pick up the pen" between segments
      Point(30, 20),
      Point(30, 20),
      Point(120, 20),
      Point(120, 20),

      // The points for the second segment (120, 20) -> (130, 20)
      Point(120, 25),
      Point(120, 15),
      Point(130, 25),
      Point(130, 15),
  };

  EXPECT_EQ(points, expected);
}

TEST(EntityGeometryTest, SimpleTwoLineStrokeVerticesRoundCap) {
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo({20, 20});
  path_builder.LineTo({30, 20});
  path_builder.MoveTo({120, 20});
  path_builder.LineTo({130, 20});
  flutter::DlPath path = path_builder.TakePath();

  auto points = ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
      path,
      {
          .width = 10.0f,
          .cap = Cap::kRound,
          .join = Join::kBevel,
          .miter_limit = 4.0f,
      },
      1.0f);

  size_t count = points.size();
  ASSERT_TRUE((count & 0x1) == 0x0);  // Should always be even

  // For a scale factor of 1.0 and a stroke width of 10.0 we currently
  // generate 40 total points for the 2 line segments based on the number
  // of quadrant circle divisions for a radius of 5.0
  //
  // If the number of points changes because of a change in the way we
  // compute circle divisions, we need to recompute the circular offsets
  ASSERT_EQ(points.size(), 40u);

  // Compute the indicated circular end cap offset based on the current
  // step out of 4 divisions [1, 2, 3] (not 0 or 4) based on whether this
  // is the left or right side of the path and whether this is a backwards
  // (starting) cap or a forwards (ending) cap.
  auto offset = [](int step, bool left, bool backwards) -> Point {
    Radians angle(kPiOver2 * (step / 4.0f));
    Point along = Point(5.0f, 0.0f) * std::cos(angle.radians);
    Point across = Point(0.0f, 5.0f) * std::sin(angle.radians);
    Point center = backwards ? -along : along;
    return left ? center + across : center - across;
  };

  // The points for the first segment (20, 20) -> (30, 20)
  EXPECT_EQ(points[0], Point(15, 20));
  EXPECT_EQ(points[1], Point(20, 20) + offset(1, true, true));
  EXPECT_EQ(points[2], Point(20, 20) + offset(1, false, true));
  EXPECT_EQ(points[3], Point(20, 20) + offset(2, true, true));
  EXPECT_EQ(points[4], Point(20, 20) + offset(2, false, true));
  EXPECT_EQ(points[5], Point(20, 20) + offset(3, true, true));
  EXPECT_EQ(points[6], Point(20, 20) + offset(3, false, true));
  EXPECT_EQ(points[7], Point(20, 25));
  EXPECT_EQ(points[8], Point(20, 15));
  EXPECT_EQ(points[9], Point(30, 25));
  EXPECT_EQ(points[10], Point(30, 15));
  EXPECT_EQ(points[11], Point(30, 20) + offset(3, true, false));
  EXPECT_EQ(points[12], Point(30, 20) + offset(3, false, false));
  EXPECT_EQ(points[13], Point(30, 20) + offset(2, true, false));
  EXPECT_EQ(points[14], Point(30, 20) + offset(2, false, false));
  EXPECT_EQ(points[15], Point(30, 20) + offset(1, true, false));
  EXPECT_EQ(points[16], Point(30, 20) + offset(1, false, false));
  EXPECT_EQ(points[17], Point(35, 20));

  // The glue points that allow us to "pick up the pen" between segments
  EXPECT_EQ(points[18], Point(30, 20));
  EXPECT_EQ(points[19], Point(30, 20));
  EXPECT_EQ(points[20], Point(120, 20));
  EXPECT_EQ(points[21], Point(120, 20));

  // The points for the second segment (120, 20) -> (130, 20)
  EXPECT_EQ(points[22], Point(115, 20));
  EXPECT_EQ(points[23], Point(120, 20) + offset(1, true, true));
  EXPECT_EQ(points[24], Point(120, 20) + offset(1, false, true));
  EXPECT_EQ(points[25], Point(120, 20) + offset(2, true, true));
  EXPECT_EQ(points[26], Point(120, 20) + offset(2, false, true));
  EXPECT_EQ(points[27], Point(120, 20) + offset(3, true, true));
  EXPECT_EQ(points[28], Point(120, 20) + offset(3, false, true));
  EXPECT_EQ(points[29], Point(120, 25));
  EXPECT_EQ(points[30], Point(120, 15));
  EXPECT_EQ(points[31], Point(130, 25));
  EXPECT_EQ(points[32], Point(130, 15));
  EXPECT_EQ(points[33], Point(130, 20) + offset(3, true, false));
  EXPECT_EQ(points[34], Point(130, 20) + offset(3, false, false));
  EXPECT_EQ(points[35], Point(130, 20) + offset(2, true, false));
  EXPECT_EQ(points[36], Point(130, 20) + offset(2, false, false));
  EXPECT_EQ(points[37], Point(130, 20) + offset(1, true, false));
  EXPECT_EQ(points[38], Point(130, 20) + offset(1, false, false));
  EXPECT_EQ(points[39], Point(135, 20));
}

TEST(EntityGeometryTest, SimpleTwoLineStrokeVerticesSquareCap) {
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo({20, 20});
  path_builder.LineTo({30, 20});
  path_builder.MoveTo({120, 20});
  path_builder.LineTo({130, 20});
  flutter::DlPath path = path_builder.TakePath();

  auto points = ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
      path,
      {
          .width = 10.0f,
          .cap = Cap::kSquare,
          .join = Join::kBevel,
          .miter_limit = 4.0f,
      },
      1.0f);

  // clang-format off
  std::vector<Point> expected = {
      // The points for the first segment (20, 20) -> (30, 20)
      Point(15, 25),
      Point(15, 15),
      Point(20, 25),
      Point(20, 15),
      Point(30, 25),
      Point(30, 15),
      Point(35, 25),
      Point(35, 15),

      // The glue points that allow us to "pick up the pen" between segments
      Point(30, 20),
      Point(30, 20),
      Point(120, 20),
      Point(120, 20),

      // The points for the second segment (120, 20) -> (130, 20)
      Point(115, 25),
      Point(115, 15),
      Point(120, 25),
      Point(120, 15),
      Point(130, 25),
      Point(130, 15),
      Point(135, 25),
      Point(135, 15),
  };
  // clang-format on

  EXPECT_EQ(points, expected);
}

TEST(EntityGeometryTest, TwoLineSegmentsRightTurnStrokeVerticesBevelJoin) {
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo({20, 20});
  path_builder.LineTo({30, 20});
  path_builder.LineTo({30, 30});
  flutter::DlPath path = path_builder.TakePath();

  auto points = ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
      path,
      {
          .width = 10.0f,
          .cap = Cap::kButt,
          .join = Join::kBevel,
          .miter_limit = 4.0f,
      },
      1.0f);

  std::vector<Point> expected = {
      // The points for the first segment (20, 20) -> (30, 20)
      Point(20, 25),
      Point(20, 15),
      Point(30, 25),
      Point(30, 15),

      // The points for the second segment (120, 20) -> (130, 20)
      Point(25, 20),
      Point(35, 20),
      Point(25, 30),
      Point(35, 30),
  };

  EXPECT_EQ(points, expected);
}

TEST(EntityGeometryTest, TwoLineSegmentsLeftTurnStrokeVerticesBevelJoin) {
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo({20, 20});
  path_builder.LineTo({30, 20});
  path_builder.LineTo({30, 10});
  flutter::DlPath path = path_builder.TakePath();

  auto points = ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
      path,
      {
          .width = 10.0f,
          .cap = Cap::kButt,
          .join = Join::kBevel,
          .miter_limit = 4.0f,
      },
      1.0f);

  std::vector<Point> expected = {
      // The points for the first segment (20, 20) -> (30, 20)
      Point(20, 25),
      Point(20, 15),
      Point(30, 25),
      Point(30, 15),

      // The points for the second segment (120, 20) -> (130, 20)
      Point(35, 20),
      Point(25, 20),
      Point(35, 10),
      Point(25, 10),
  };

  EXPECT_EQ(points, expected);
}

TEST(EntityGeometryTest, TwoLineSegmentsRightTurnStrokeVerticesMiterJoin) {
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo({20, 20});
  path_builder.LineTo({30, 20});
  path_builder.LineTo({30, 30});
  flutter::DlPath path = path_builder.TakePath();

  auto points = ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
      path,
      {
          .width = 10.0f,
          .cap = Cap::kButt,
          .join = Join::kMiter,
          .miter_limit = 4.0f,
      },
      1.0f);

  std::vector<Point> expected = {
      // The points for the first segment (20, 20) -> (30, 20)
      Point(20, 25),
      Point(20, 15),
      Point(30, 25),
      Point(30, 15),

      // And one point makes a Miter
      Point(35, 15),

      // The points for the second segment (120, 20) -> (130, 20)
      Point(25, 20),
      Point(35, 20),
      Point(25, 30),
      Point(35, 30),
  };

  EXPECT_EQ(points, expected);
}

TEST(EntityGeometryTest, TwoLineSegmentsLeftTurnStrokeVerticesMiterJoin) {
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo({20, 20});
  path_builder.LineTo({30, 20});
  path_builder.LineTo({30, 10});
  flutter::DlPath path = path_builder.TakePath();

  auto points = ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
      path,
      {
          .width = 10.0f,
          .cap = Cap::kButt,
          .join = Join::kMiter,
          .miter_limit = 4.0f,
      },
      1.0f);

  std::vector<Point> expected = {
      // The points for the first segment (20, 20) -> (30, 20)
      Point(20, 25),
      Point(20, 15),
      Point(30, 25),
      Point(30, 15),

      // And one point makes a Miter
      Point(35, 25),

      // The points for the second segment (120, 20) -> (130, 20)
      Point(35, 20),
      Point(25, 20),
      Point(35, 10),
      Point(25, 10),
  };

  EXPECT_EQ(points, expected);
}

TEST(EntityGeometryTest, TinyQuadGeneratesCaps) {
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo({20, 20});
  path_builder.QuadraticCurveTo({20.125, 20}, {20.250, 20});
  flutter::DlPath path = path_builder.TakePath();

  auto points = ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
      path,
      {
          .width = 4.0f,
          .cap = Cap::kSquare,
          .join = Join::kBevel,
          .miter_limit = 4.0f,
      },
      1.0f);

  std::vector<Point> expected = {
      // The points for the opening square cap
      Point(18, 22),
      Point(18, 18),

      // The points for the start of the curve
      Point(20, 22),
      Point(20, 18),

      // The points for the end of the curve
      Point(20.25, 22),
      Point(20.25, 18),

      // The points for the closing square cap
      Point(22.25, 22),
      Point(22.25, 18),
  };

  EXPECT_EQ(points, expected);
}

TEST(EntityGeometryTest, TinyConicGeneratesCaps) {
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo({20, 20});
  path_builder.ConicCurveTo({20.125, 20}, {20.250, 20}, 0.6);
  flutter::DlPath path = path_builder.TakePath();

  auto points = ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
      path,
      {
          .width = 4.0f,
          .cap = Cap::kSquare,
          .join = Join::kBevel,
          .miter_limit = 4.0f,
      },
      1.0f);

  std::vector<Point> expected = {
      // The points for the opening square cap
      Point(18, 22),
      Point(18, 18),

      // The points for the start of the curve
      Point(20, 22),
      Point(20, 18),

      // The points for the end of the curve
      Point(20.25, 22),
      Point(20.25, 18),

      // The points for the closing square cap
      Point(22.25, 22),
      Point(22.25, 18),
  };

  EXPECT_EQ(points, expected);
}

TEST(EntityGeometryTest, TinyCubicGeneratesCaps) {
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo({20, 20});
  path_builder.CubicCurveTo({20.0625, 20}, {20.125, 20}, {20.250, 20});
  flutter::DlPath path = path_builder.TakePath();

  auto points = ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
      path,
      {
          .width = 4.0f,
          .cap = Cap::kSquare,
          .join = Join::kBevel,
          .miter_limit = 4.0f,
      },
      1.0f);

  std::vector<Point> expected = {
      // The points for the opening square cap
      Point(18, 22),
      Point(18, 18),

      // The points for the start of the curve
      Point(20, 22),
      Point(20, 18),

      // The points for the end of the curve
      Point(20.25, 22),
      Point(20.25, 18),

      // The points for the closing square cap
      Point(22.25, 22),
      Point(22.25, 18),
  };

  EXPECT_EQ(points, expected);
}

TEST(EntityGeometryTest, TwoLineSegmentsMiterLimit) {
  // degrees is the angle that the line deviates from "straight ahead"
  for (int degrees = 10; degrees < 180; degrees += 10) {
    // Start with a width of 2 since line widths of 1 usually decide
    // that they don't need join geometry at a scale of 1.0
    for (int width = 2; width <= 10; width++) {
      Degrees d(degrees);
      Radians r(d);
      Point pixel_delta = Point(std::cos(r.radians), std::sin(r.radians));

      if (pixel_delta.GetDistance(Point(1, 0)) * width < 1.0f) {
        // Some combinations of angle and width result in a join that is
        // less than a pixel in size. We don't care about compliance on
        // such a small join delta (and, in fact, the implementation may
        // decide to elide those small joins).
        continue;
      }

      // Miter limits are based on angle between the vectors/segments
      Degrees between(180 - degrees);
      Radians r_between(between);
      Scalar limit = 1.0f / std::sin(r_between.radians / 2.0f);

      flutter::DlPathBuilder path_builder;
      path_builder.MoveTo(Point(20, 20));
      path_builder.LineTo(Point(30, 20));
      path_builder.LineTo(Point(30, 20) + pixel_delta * 10.0f);
      flutter::DlPath path = path_builder.TakePath();

      // Miter limit too small (99% of required) to allow a miter
      auto points1 =
          ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
              path,
              {
                  .width = static_cast<Scalar>(width),
                  .cap = Cap::kButt,
                  .join = Join::kMiter,
                  .miter_limit = limit * 0.99f,
              },
              1.0f);
      EXPECT_EQ(points1.size(), 8u)
          << "degrees: " << degrees << ", width: " << width << ", "
          << points1[4];

      // Miter limit large enough (101% of required) to allow a miter
      auto points2 =
          ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
              path,
              {
                  .width = static_cast<Scalar>(width),
                  .cap = Cap::kButt,
                  .join = Join::kMiter,
                  .miter_limit = limit * 1.01f,
              },
              1.0f);
      EXPECT_EQ(points2.size(), 9u)
          << "degrees: " << degrees << ", width: " << width;
      EXPECT_LE(points2[4].GetDistance({30, 20}), width * limit * 1.05f)
          << "degrees: " << degrees << ", width: " << width << ", "
          << points2[4];
    }
  }
}

TEST(EntityGeometryTest, TwoLineSegments180DegreeJoins) {
  // First, create a path that doubles back on itself.
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo(Point(10, 10));
  path_builder.LineTo(Point(100, 10));
  path_builder.LineTo(Point(10, 10));
  flutter::DlPath path = path_builder.TakePath();

  auto points_bevel =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kBevel,
              .miter_limit = 4.0f,
          },
          1.0f);
  // Generates no join - because it is a bevel join
  EXPECT_EQ(points_bevel.size(), 8u);

  auto points_miter =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kMiter,
              .miter_limit = 400.0f,
          },
          1.0f);
  // Generates no join - even with a very large miter limit
  EXPECT_EQ(points_miter.size(), 8u);

  auto points_round =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kRound,
              .miter_limit = 4.0f,
          },
          1.0f);
  // Generates lots of join points - to round off the 180 degree bend
  EXPECT_EQ(points_round.size(), 19u);
}

TEST(EntityGeometryTest, TightQuadratic180DegreeJoins) {
  // First, create a mild quadratic that helps us verify how many points
  // should normally be on a quad with 2 legs of length 90.
  flutter::DlPathBuilder path_builder_refrence;
  path_builder_refrence.MoveTo(Point(10, 10));
  path_builder_refrence.QuadraticCurveTo(Point(100, 10), Point(100, 100));
  flutter::DlPath path_reference = path_builder_refrence.TakePath();

  auto points_bevel_reference =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path_reference,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kBevel,
              .miter_limit = 4.0f,
          },
          1.0f);
  // Generates no joins because the curve is smooth
  EXPECT_EQ(points_bevel_reference.size(), 74u);

  // Now create a path that doubles back on itself with a quadratic.
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo(Point(10, 10));
  path_builder.QuadraticCurveTo(Point(100, 10), Point(10, 10));
  flutter::DlPath path = path_builder.TakePath();

  auto points_bevel =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kBevel,
              .miter_limit = 4.0f,
          },
          1.0f);
  // Generates round join because it is in the middle of a curved segment
  EXPECT_GT(points_bevel.size(), points_bevel_reference.size());

  auto points_miter =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kMiter,
              .miter_limit = 400.0f,
          },
          1.0f);
  // Generates round join because it is in the middle of a curved segment
  EXPECT_GT(points_miter.size(), points_bevel_reference.size());

  auto points_round =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kRound,
              .miter_limit = 4.0f,
          },
          1.0f);
  // Generates round join because it is in the middle of a curved segment
  EXPECT_GT(points_round.size(), points_bevel_reference.size());
}

TEST(EntityGeometryTest, TightConic180DegreeJoins) {
  // First, create a mild conic that helps us verify how many points
  // should normally be on a quad with 2 legs of length 90.
  flutter::DlPathBuilder path_builder_refrence;
  path_builder_refrence.MoveTo(Point(10, 10));
  path_builder_refrence.ConicCurveTo(Point(100, 10), Point(100, 100), 0.9f);
  flutter::DlPath path_reference = path_builder_refrence.TakePath();

  auto points_bevel_reference =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path_reference,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kBevel,
              .miter_limit = 4.0f,
          },
          1.0f);
  // Generates no joins because the curve is smooth
  EXPECT_EQ(points_bevel_reference.size(), 78u);

  // Now create a path that doubles back on itself with a conic.
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo(Point(10, 10));
  path_builder.QuadraticCurveTo(Point(100, 10), Point(10, 10));
  flutter::DlPath path = path_builder.TakePath();

  auto points_bevel =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kBevel,
              .miter_limit = 4.0f,
          },
          1.0f);
  // Generates round join because it is in the middle of a curved segment
  EXPECT_GT(points_bevel.size(), points_bevel_reference.size());

  auto points_miter =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kMiter,
              .miter_limit = 400.0f,
          },
          1.0f);
  // Generates round join because it is in the middle of a curved segment
  EXPECT_GT(points_miter.size(), points_bevel_reference.size());

  auto points_round =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kRound,
              .miter_limit = 4.0f,
          },
          1.0f);
  // Generates round join because it is in the middle of a curved segment
  EXPECT_GT(points_round.size(), points_bevel_reference.size());
}

TEST(EntityGeometryTest, TightCubic180DegreeJoins) {
  // First, create a mild cubic that helps us verify how many points
  // should normally be on a quad with 3 legs of length ~50.
  flutter::DlPathBuilder path_builder_reference;
  path_builder_reference.MoveTo(Point(10, 10));
  path_builder_reference.CubicCurveTo(Point(60, 10), Point(100, 40),
                                      Point(100, 90));
  flutter::DlPath path_reference = path_builder_reference.TakePath();

  auto points_reference =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path_reference,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kBevel,
              .miter_limit = 4.0f,
          },
          1.0f);
  // Generates no joins because the curve is smooth
  EXPECT_EQ(points_reference.size(), 76u);

  // Now create a path that doubles back on itself with a cubic.
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo(Point(10, 10));
  path_builder.CubicCurveTo(Point(60, 10), Point(100, 40), Point(60, 10));
  flutter::DlPath path = path_builder.TakePath();

  auto points_bevel =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kBevel,
              .miter_limit = 4.0f,
          },
          1.0f);
  // Generates round join because it is in the middle of a curved segment
  EXPECT_GT(points_bevel.size(), points_reference.size());

  auto points_miter =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kMiter,
              .miter_limit = 400.0f,
          },
          1.0f);
  // Generates round join because it is in the middle of a curved segment
  EXPECT_GT(points_miter.size(), points_reference.size());

  auto points_round =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kRound,
              .miter_limit = 4.0f,
          },
          1.0f);
  // Generates round join because it is in the middle of a curved segment
  EXPECT_GT(points_round.size(), points_reference.size());
}

TEST(EntityGeometryTest, RotatedFilledCircleGeometryCoverage) {
  Point center = Point(50, 50);
  auto geometry = Geometry::MakeCircle(center, 50);
  Rect circle_bounds = Rect::MakeLTRB(0, 0, 100, 100);
  ASSERT_EQ(geometry->GetCoverage({}).value_or(Rect()), circle_bounds);

  Matrix transform45 = Matrix::MakeTranslation(center) *
                       Matrix::MakeRotationZ(Degrees(45)) *
                       Matrix::MakeTranslation(-center);

  EXPECT_TRUE(geometry->GetCoverage(transform45).has_value());
  Rect bounds = geometry->GetCoverage(transform45).value_or(Rect());
  EXPECT_TRUE(bounds.Contains(circle_bounds))
      << "geometry bounds: " << bounds << std::endl
      << "  circle bounds: " << circle_bounds;
}

TEST(EntityGeometryTest, RotatedStrokedCircleGeometryCoverage) {
  Point center = Point(50, 50);
  auto geometry = Geometry::MakeStrokedCircle(center, 50, 10);
  Rect circle_bounds = Rect::MakeLTRB(0, 0, 100, 100).Expand(5);
  ASSERT_EQ(geometry->GetCoverage({}).value_or(Rect()), circle_bounds);

  Matrix transform45 = Matrix::MakeTranslation(center) *
                       Matrix::MakeRotationZ(Degrees(45)) *
                       Matrix::MakeTranslation(-center);

  EXPECT_TRUE(geometry->GetCoverage(transform45).has_value());
  Rect bounds = geometry->GetCoverage(transform45).value_or(Rect());
  EXPECT_TRUE(bounds.Contains(circle_bounds))
      << "geometry bounds: " << bounds << std::endl
      << "  circle bounds: " << circle_bounds;
}

}  // namespace testing
}  // namespace impeller