Added comprehensive tests for views::Border.

ui/views/border_unittest.cc

Index: ui/views/border_unittest.cc
diff --git a/ui/views/border_unittest.cc b/ui/views/border_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..008f81329617cec87014d85bf4d2f0b8236c0a2c
--- /dev/null
+++ b/ui/views/border_unittest.cc
@@ -0,0 +1,228 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.

[sadrul, 2016/05/31 17:31:31]

This should be updated I guess.

[Matt Giuca, 2016/06/03 03:38:42]

Done.

+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/views/border.h"
+
+#include <vector>
+
+#include "base/memory/scoped_ptr.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkPaint.h"
+#include "third_party/skia/include/core/SkRRect.h"
+#include "third_party/skia/include/core/SkRect.h"
+#include "ui/gfx/canvas.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/views/painter.h"
+#include "ui/views/test/views_test_base.h"
+#include "ui/views/view.h"
+
+using namespace testing;
+
+namespace {
+
+class MockCanvas : public SkCanvas {
+ public:
+  struct DrawRectCall {
+    DrawRectCall(const SkRect& rect, const SkPaint& paint)
+        : rect(rect), paint(paint) {}
+
+    SkRect rect;
+    SkPaint paint;
+  };
+
+  struct DrawRRectCall {
+    DrawRRectCall(const SkRRect& rrect, const SkPaint& paint)
+        : rrect(rrect), paint(paint) {}
+
+    SkRRect rrect;
+    SkPaint paint;
+  };
+
+  MockCanvas(int width, int height) : SkCanvas(width, height) {}
+
+  const std::vector<DrawRectCall>& draw_rect_calls() {
+    return draw_rect_calls_;
+  }
+
+  const std::vector<DrawRRectCall>& draw_rrect_calls() {
+    return draw_rrect_calls_;
+  }
+
+  // SkCanvas overrides:
+  void onDrawRect(const SkRect& rect, const SkPaint& paint) override {
+    draw_rect_calls_.push_back(DrawRectCall(rect, paint));
+  }
+
+  void onDrawRRect(const SkRRect& rrect, const SkPaint& paint) override {
+    draw_rrect_calls_.push_back(DrawRRectCall(rrect, paint));
+  }
+
+ private:
+  // Stores all the calls for querying by the test.
+  std::vector<DrawRectCall> draw_rect_calls_;
+  std::vector<DrawRRectCall> draw_rrect_calls_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockCanvas);
+};
+
+// Simple Painter that will be used to test BorderPainter.
+class MockPainter : public views::Painter {
+ public:
+  MockPainter() : views::Painter() {}

[sadrul, 2016/05/31 17:31:30]

Is the : views::Painter() bit necessary?

[Matt Giuca, 2016/06/03 03:38:42]

Done.

+
+  // Gets the canvas given to the last call to Paint().
+  gfx::Canvas* given_canvas() const { return given_canvas_; }
+
+  // Gets the size given to the last call to Paint().
+  const gfx::Size& given_size() const { return given_size_; }
+
+  // Painter overrides:
+  gfx::Size GetMinimumSize() const override {
+    // Just return some arbitrary size.
+    return gfx::Size(60, 40);
+  }
+
+  void Paint(gfx::Canvas* canvas, const gfx::Size& size) override {
+    // Just record the arguments.
+    given_canvas_ = canvas;
+    given_size_ = size;
+  }
+
+ private:
+  gfx::Canvas* given_canvas_ = nullptr;
+  gfx::Size given_size_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockPainter);
+};
+
+}  // namespace
+
+namespace views {
+
+class BorderTest : public ViewsTestBase {
+ public:
+  void SetUp() override {
+    ViewsTestBase::SetUp();
+
+    view_.reset(new views::View());
+    view_->SetSize(gfx::Size(100, 50));
+    // The canvas should be much bigger than the view.
+    sk_canvas_.reset(new MockCanvas(1000, 500));
+    canvas_.reset(new gfx::Canvas(sk_canvas_.get(), 1.0f));
+  }
+
+  void TearDown() override {
+    ViewsTestBase::TearDown();
+
+    canvas_.reset();
+    sk_canvas_.reset();
+    view_.reset();
+  }
+
+ protected:
+  scoped_ptr<views::View> view_;
+  scoped_ptr<MockCanvas> sk_canvas_;
+  scoped_ptr<gfx::Canvas> canvas_;
+};
+
+TEST_F(BorderTest, NullBorder) {
+  scoped_ptr<Border> border(Border::NullBorder());
+  EXPECT_FALSE(border);
+}
+
+TEST_F(BorderTest, SolidBorder) {
+  scoped_ptr<Border> border(Border::CreateSolidBorder(3, SK_ColorBLUE));
+  EXPECT_EQ(gfx::Size(6, 6), border->GetMinimumSize());
+  EXPECT_EQ(gfx::Insets(3, 3, 3, 3), border->GetInsets());
+  border->Paint(*view_, canvas_.get());
+
+  auto draw_rect_calls = sk_canvas_->draw_rect_calls();
+  EXPECT_EQ(4u, draw_rect_calls.size());

[sadrul, 2016/05/31 17:31:30]

ASSERT_EQ

[Matt Giuca, 2016/06/03 03:38:42]

Done.

+  EXPECT_EQ(SkRect::MakeLTRB(0, 0, 100, 3), draw_rect_calls[0].rect);
+  EXPECT_EQ(SK_ColorBLUE, draw_rect_calls[0].paint.getColor());
+  EXPECT_EQ(SkRect::MakeLTRB(0, 3, 3, 47), draw_rect_calls[1].rect);
+  EXPECT_EQ(SK_ColorBLUE, draw_rect_calls[1].paint.getColor());
+  EXPECT_EQ(SkRect::MakeLTRB(0, 47, 100, 50), draw_rect_calls[2].rect);
+  EXPECT_EQ(SK_ColorBLUE, draw_rect_calls[2].paint.getColor());
+  EXPECT_EQ(SkRect::MakeLTRB(97, 3, 100, 47), draw_rect_calls[3].rect);
+  EXPECT_EQ(SK_ColorBLUE, draw_rect_calls[3].paint.getColor());

[sadrul, 2016/05/31 17:31:31]

Can you change this so the ordering of the calls do not matter?

[Matt Giuca, 2016/06/03 03:38:42]

Done. (Required operator< in the DrawRectCall and DrawRRectCall classes.)

+
+  EXPECT_TRUE(sk_canvas_->draw_rrect_calls().empty());
+}
+
+TEST_F(BorderTest, RoundedRectBorder) {
+  scoped_ptr<Border> border(
+      Border::CreateRoundedRectBorder(3, 4, SK_ColorBLUE));
+  EXPECT_EQ(gfx::Size(6, 6), border->GetMinimumSize());
+  EXPECT_EQ(gfx::Insets(3, 3, 3, 3), border->GetInsets());
+  border->Paint(*view_, canvas_.get());
+
+  SkRRect expected_rrect;
+  expected_rrect.setRectXY(SkRect::MakeLTRB(1.5, 1.5, 98.5, 48.5), 4, 4);
+  EXPECT_TRUE(sk_canvas_->draw_rect_calls().empty());
+  const auto& draw_rrect_calls = sk_canvas_->draw_rrect_calls();
+  EXPECT_EQ(1u, draw_rrect_calls.size());

[sadrul, 2016/05/31 17:31:30]

ASSERT_EQ

[Matt Giuca, 2016/06/03 03:38:42]

Done.

+  EXPECT_EQ(expected_rrect, draw_rrect_calls[0].rrect);
+  EXPECT_EQ(3, draw_rrect_calls[0].paint.getStrokeWidth());
+  EXPECT_EQ(SK_ColorBLUE, draw_rrect_calls[0].paint.getColor());
+  EXPECT_EQ(SkPaint::kStroke_Style, draw_rrect_calls[0].paint.getStyle());
+  EXPECT_TRUE(draw_rrect_calls[0].paint.isAntiAlias());
+}
+
+TEST_F(BorderTest, EmptyBorder) {
+  const gfx::Insets kInsets(1, 2, 3, 4);
+
+  scoped_ptr<Border> border(Border::CreateEmptyBorder(
+      kInsets.top(), kInsets.left(), kInsets.bottom(), kInsets.right()));
+  // The EmptyBorder has no minimum size despite nonzero insets.
+  EXPECT_EQ(gfx::Size(), border->GetMinimumSize());
+  EXPECT_EQ(kInsets, border->GetInsets());
+  // Should have no effect.
+  border->Paint(*view_, canvas_.get());
+
+  scoped_ptr<Border> border2(Border::CreateEmptyBorder(kInsets));
+  EXPECT_EQ(kInsets, border2->GetInsets());
+}
+
+TEST_F(BorderTest, SolidSidedBorder) {
+  const gfx::Insets kInsets(1, 2, 3, 4);
+
+  scoped_ptr<Border> border(Border::CreateSolidSidedBorder(
+      kInsets.top(), kInsets.left(), kInsets.bottom(), kInsets.right(),
+      SK_ColorBLUE));
+  EXPECT_EQ(gfx::Size(6, 4), border->GetMinimumSize());
+  EXPECT_EQ(kInsets, border->GetInsets());
+  border->Paint(*view_, canvas_.get());
+
+  const auto& draw_rect_calls = sk_canvas_->draw_rect_calls();
+  EXPECT_EQ(4u, draw_rect_calls.size());
+  EXPECT_EQ(SkRect::MakeLTRB(0, 0, 100, 1), draw_rect_calls[0].rect);
+  EXPECT_EQ(SK_ColorBLUE, draw_rect_calls[0].paint.getColor());
+  EXPECT_EQ(SkRect::MakeLTRB(0, 1, 2, 47), draw_rect_calls[1].rect);
+  EXPECT_EQ(SK_ColorBLUE, draw_rect_calls[1].paint.getColor());
+  EXPECT_EQ(SkRect::MakeLTRB(0, 47, 100, 50), draw_rect_calls[2].rect);
+  EXPECT_EQ(SK_ColorBLUE, draw_rect_calls[2].paint.getColor());
+  EXPECT_EQ(SkRect::MakeLTRB(96, 1, 100, 47), draw_rect_calls[3].rect);
+  EXPECT_EQ(SK_ColorBLUE, draw_rect_calls[3].paint.getColor());
+
+  EXPECT_TRUE(sk_canvas_->draw_rrect_calls().empty());
+}
+
+TEST_F(BorderTest, BorderPainter) {
+  const gfx::Insets kInsets(1, 2, 3, 4);
+
+  MockPainter* painter = new MockPainter();
+  scoped_ptr<Border> border(Border::CreateBorderPainter(painter, kInsets));
+  EXPECT_EQ(gfx::Size(60, 40), border->GetMinimumSize());
+  EXPECT_EQ(kInsets, border->GetInsets());
+
+  border->Paint(*view_, canvas_.get());
+
+  // Expect that the Painter was called with our canvas and the view's size.
+  EXPECT_EQ(canvas_.get(), painter->given_canvas());
+  EXPECT_EQ(view_->size(), painter->given_size());
+}
+
+}  // namespace views