diff options
Diffstat (limited to 'views/layout/grid_layout_unittest.cc')
| -rw-r--r-- | views/layout/grid_layout_unittest.cc | 608 |
1 files changed, 608 insertions, 0 deletions
diff --git a/views/layout/grid_layout_unittest.cc b/views/layout/grid_layout_unittest.cc new file mode 100644 index 0000000..4cd2eae --- /dev/null +++ b/views/layout/grid_layout_unittest.cc @@ -0,0 +1,608 @@ +// Copyright (c) 2011 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. + +#include "testing/gtest/include/gtest/gtest.h" +#include "views/layout/grid_layout.h" +#include "views/view.h" + +using views::ColumnSet; +using views::GridLayout; +using views::View; + +static void ExpectViewBoundsEquals(int x, int y, int w, int h, + const View* view) { + EXPECT_EQ(x, view->x()); + EXPECT_EQ(y, view->y()); + EXPECT_EQ(w, view->width()); + EXPECT_EQ(h, view->height()); +} + +class SettableSizeView : public View { + public: + explicit SettableSizeView(const gfx::Size& pref) { + pref_ = pref; + } + + virtual gfx::Size GetPreferredSize() { + return pref_; + } + + private: + gfx::Size pref_; +}; + +// A view with fixed circumference that trades height for width. +class FlexibleView : public View { + public: + explicit FlexibleView(int circumference) { + circumference_ = circumference; + } + + virtual gfx::Size GetPreferredSize() { + return gfx::Size(0, circumference_ / 2); + } + + virtual int GetHeightForWidth(int width) { + return std::max(0, circumference_ / 2 - width); + } + + private: + int circumference_; +}; + +class GridLayoutTest : public testing::Test { + public: + virtual void SetUp() { + layout = new GridLayout(&host); + } + + virtual void TearDown() { + delete layout; + } + + virtual void RemoveAll() { + for (int i = host.GetChildViewCount() - 1; i >= 0; i--) { + host.RemoveChildView(host.GetChildViewAt(i)); + } + } + + void GetPreferredSize() { + pref = layout->GetPreferredSize(&host); + } + + gfx::Size pref; + gfx::Rect bounds; + View host; + GridLayout* layout; +}; + +class GridLayoutAlignmentTest : public testing::Test { + public: + GridLayoutAlignmentTest() : + host(), + v1(gfx::Size(10, 20)), + layout(new GridLayout(&host)) {} + + virtual void SetUp() { + } + + virtual void TearDown() { + delete layout; + } + + virtual void RemoveAll() { + for (int i = host.GetChildViewCount() - 1; i >= 0; i--) { + host.RemoveChildView(host.GetChildViewAt(i)); + } + } + + void TestAlignment(GridLayout::Alignment alignment, gfx::Rect* bounds) { + ColumnSet* c1 = layout->AddColumnSet(0); + c1->AddColumn(alignment, alignment, 1, GridLayout::USE_PREF, 0, 0); + layout->StartRow(1, 0); + layout->AddView(&v1); + gfx::Size pref = layout->GetPreferredSize(&host); + EXPECT_EQ(gfx::Size(10, 20), pref); + host.SetBounds(0, 0, 100, 100); + layout->Layout(&host); + *bounds = v1.bounds(); + RemoveAll(); + } + + View host; + SettableSizeView v1; + GridLayout* layout; +}; + +TEST_F(GridLayoutAlignmentTest, Fill) { + gfx::Rect bounds; + TestAlignment(GridLayout::FILL, &bounds); + EXPECT_EQ(gfx::Rect(0, 0, 100, 100), bounds); +} + +TEST_F(GridLayoutAlignmentTest, Leading) { + gfx::Rect bounds; + TestAlignment(GridLayout::LEADING, &bounds); + EXPECT_EQ(gfx::Rect(0, 0, 10, 20), bounds); +} + +TEST_F(GridLayoutAlignmentTest, Center) { + gfx::Rect bounds; + TestAlignment(GridLayout::CENTER, &bounds); + EXPECT_EQ(gfx::Rect(45, 40, 10, 20), bounds); +} + +TEST_F(GridLayoutAlignmentTest, Trailing) { + gfx::Rect bounds; + TestAlignment(GridLayout::TRAILING, &bounds); + EXPECT_EQ(gfx::Rect(90, 80, 10, 20), bounds); +} + +TEST_F(GridLayoutTest, TwoColumns) { + SettableSizeView v1(gfx::Size(10, 20)); + SettableSizeView v2(gfx::Size(20, 20)); + ColumnSet* c1 = layout->AddColumnSet(0); + c1->AddColumn(GridLayout::LEADING, GridLayout::LEADING, + 0, GridLayout::USE_PREF, 0, 0); + c1->AddColumn(GridLayout::LEADING, GridLayout::LEADING, + 0, GridLayout::USE_PREF, 0, 0); + layout->StartRow(0, 0); + layout->AddView(&v1); + layout->AddView(&v2); + + GetPreferredSize(); + EXPECT_EQ(gfx::Size(30, 20), pref); + + host.SetBounds(0, 0, pref.width(), pref.height()); + layout->Layout(&host); + ExpectViewBoundsEquals(0, 0, 10, 20, &v1); + ExpectViewBoundsEquals(10, 0, 20, 20, &v2); + + RemoveAll(); +} + +TEST_F(GridLayoutTest, ColSpan1) { + SettableSizeView v1(gfx::Size(100, 20)); + SettableSizeView v2(gfx::Size(10, 40)); + ColumnSet* c1 = layout->AddColumnSet(0); + c1->AddColumn(GridLayout::LEADING, GridLayout::LEADING, + 0, GridLayout::USE_PREF, 0, 0); + c1->AddColumn(GridLayout::LEADING, GridLayout::LEADING, + 1, GridLayout::USE_PREF, 0, 0); + layout->StartRow(0, 0); + layout->AddView(&v1, 2, 1); + layout->StartRow(0, 0); + layout->AddView(&v2); + + GetPreferredSize(); + EXPECT_EQ(gfx::Size(100, 60), pref); + + host.SetBounds(0, 0, pref.width(), pref.height()); + layout->Layout(&host); + ExpectViewBoundsEquals(0, 0, 100, 20, &v1); + ExpectViewBoundsEquals(0, 20, 10, 40, &v2); + + RemoveAll(); +} + +TEST_F(GridLayoutTest, ColSpan2) { + SettableSizeView v1(gfx::Size(100, 20)); + SettableSizeView v2(gfx::Size(10, 20)); + ColumnSet* c1 = layout->AddColumnSet(0); + c1->AddColumn(GridLayout::LEADING, GridLayout::LEADING, + 1, GridLayout::USE_PREF, 0, 0); + c1->AddColumn(GridLayout::LEADING, GridLayout::LEADING, + 0, GridLayout::USE_PREF, 0, 0); + layout->StartRow(0, 0); + layout->AddView(&v1, 2, 1); + layout->StartRow(0, 0); + layout->SkipColumns(1); + layout->AddView(&v2); + + GetPreferredSize(); + EXPECT_EQ(gfx::Size(100, 40), pref); + + host.SetBounds(0, 0, pref.width(), pref.height()); + layout->Layout(&host); + ExpectViewBoundsEquals(0, 0, 100, 20, &v1); + ExpectViewBoundsEquals(90, 20, 10, 20, &v2); + + RemoveAll(); +} + +TEST_F(GridLayoutTest, ColSpan3) { + SettableSizeView v1(gfx::Size(100, 20)); + SettableSizeView v2(gfx::Size(10, 20)); + SettableSizeView v3(gfx::Size(10, 20)); + ColumnSet* c1 = layout->AddColumnSet(0); + c1->AddColumn(GridLayout::LEADING, GridLayout::LEADING, + 0, GridLayout::USE_PREF, 0, 0); + c1->AddColumn(GridLayout::LEADING, GridLayout::LEADING, + 0, GridLayout::USE_PREF, 0, 0); + layout->StartRow(0, 0); + layout->AddView(&v1, 2, 1); + layout->StartRow(0, 0); + layout->AddView(&v2); + layout->AddView(&v3); + + GetPreferredSize(); + EXPECT_EQ(gfx::Size(100, 40), pref); + + host.SetBounds(0, 0, pref.width(), pref.height()); + layout->Layout(&host); + ExpectViewBoundsEquals(0, 0, 100, 20, &v1); + ExpectViewBoundsEquals(0, 20, 10, 20, &v2); + ExpectViewBoundsEquals(50, 20, 10, 20, &v3); + + RemoveAll(); +} + + +TEST_F(GridLayoutTest, ColSpan4) { + views::ColumnSet* set = layout->AddColumnSet(0); + + set->AddColumn(GridLayout::LEADING, GridLayout::LEADING, 0, + GridLayout::USE_PREF, 0, 0); + set->AddColumn(GridLayout::LEADING, GridLayout::LEADING, 0, + GridLayout::USE_PREF, 0, 0); + + SettableSizeView v1(gfx::Size(10, 10)); + SettableSizeView v2(gfx::Size(10, 10)); + SettableSizeView v3(gfx::Size(25, 20)); + layout->StartRow(0, 0); + layout->AddView(&v1); + layout->AddView(&v2); + layout->StartRow(0, 0); + layout->AddView(&v3, 2, 1); + + GetPreferredSize(); + EXPECT_EQ(gfx::Size(25, 30), pref); + + host.SetBounds(0, 0, pref.width(), pref.height()); + layout->Layout(&host); + ExpectViewBoundsEquals(0, 0, 10, 10, &v1); + ExpectViewBoundsEquals(12, 0, 10, 10, &v2); + ExpectViewBoundsEquals(0, 10, 25, 20, &v3); + + RemoveAll(); +} + +TEST_F(GridLayoutTest, SameSizeColumns) { + SettableSizeView v1(gfx::Size(50, 20)); + SettableSizeView v2(gfx::Size(10, 10)); + ColumnSet* c1 = layout->AddColumnSet(0); + c1->AddColumn(GridLayout::LEADING, GridLayout::LEADING, + 0, GridLayout::USE_PREF, 0, 0); + c1->AddColumn(GridLayout::LEADING, GridLayout::LEADING, + 0, GridLayout::USE_PREF, 0, 0); + c1->LinkColumnSizes(0, 1, -1); + layout->StartRow(0, 0); + layout->AddView(&v1); + layout->AddView(&v2); + + gfx::Size pref = layout->GetPreferredSize(&host); + EXPECT_EQ(gfx::Size(100, 20), pref); + + host.SetBounds(0, 0, pref.width(), pref.height()); + layout->Layout(&host); + ExpectViewBoundsEquals(0, 0, 50, 20, &v1); + ExpectViewBoundsEquals(50, 0, 10, 10, &v2); + + RemoveAll(); +} + +TEST_F(GridLayoutTest, HorizontalResizeTest1) { + SettableSizeView v1(gfx::Size(50, 20)); + SettableSizeView v2(gfx::Size(10, 10)); + ColumnSet* c1 = layout->AddColumnSet(0); + c1->AddColumn(GridLayout::FILL, GridLayout::LEADING, + 1, GridLayout::USE_PREF, 0, 0); + c1->AddColumn(GridLayout::LEADING, GridLayout::LEADING, + 0, GridLayout::USE_PREF, 0, 0); + layout->StartRow(0, 0); + layout->AddView(&v1); + layout->AddView(&v2); + + host.SetBounds(0, 0, 110, 20); + layout->Layout(&host); + ExpectViewBoundsEquals(0, 0, 100, 20, &v1); + ExpectViewBoundsEquals(100, 0, 10, 10, &v2); + + RemoveAll(); +} + +TEST_F(GridLayoutTest, HorizontalResizeTest2) { + SettableSizeView v1(gfx::Size(50, 20)); + SettableSizeView v2(gfx::Size(10, 10)); + ColumnSet* c1 = layout->AddColumnSet(0); + c1->AddColumn(GridLayout::FILL, GridLayout::LEADING, + 1, GridLayout::USE_PREF, 0, 0); + c1->AddColumn(GridLayout::TRAILING, GridLayout::LEADING, + 1, GridLayout::USE_PREF, 0, 0); + layout->StartRow(0, 0); + layout->AddView(&v1); + layout->AddView(&v2); + + host.SetBounds(0, 0, 120, 20); + layout->Layout(&host); + ExpectViewBoundsEquals(0, 0, 80, 20, &v1); + ExpectViewBoundsEquals(110, 0, 10, 10, &v2); + + RemoveAll(); +} + +TEST_F(GridLayoutTest, TestVerticalResize1) { + SettableSizeView v1(gfx::Size(50, 20)); + SettableSizeView v2(gfx::Size(10, 10)); + ColumnSet* c1 = layout->AddColumnSet(0); + c1->AddColumn(GridLayout::FILL, GridLayout::FILL, + 1, GridLayout::USE_PREF, 0, 0); + layout->StartRow(1, 0); + layout->AddView(&v1); + layout->StartRow(0, 0); + layout->AddView(&v2); + + GetPreferredSize(); + EXPECT_EQ(gfx::Size(50, 30), pref); + + host.SetBounds(0, 0, 50, 100); + layout->Layout(&host); + ExpectViewBoundsEquals(0, 0, 50, 90, &v1); + ExpectViewBoundsEquals(0, 90, 50, 10, &v2); + + RemoveAll(); +} + +TEST_F(GridLayoutTest, Insets) { + SettableSizeView v1(gfx::Size(10, 20)); + ColumnSet* c1 = layout->AddColumnSet(0); + layout->SetInsets(1, 2, 3, 4); + c1->AddColumn(GridLayout::LEADING, GridLayout::LEADING, + 0, GridLayout::USE_PREF, 0, 0); + layout->StartRow(0, 0); + layout->AddView(&v1); + + GetPreferredSize(); + EXPECT_EQ(gfx::Size(16, 24), pref); + + host.SetBounds(0, 0, pref.width(), pref.height()); + layout->Layout(&host); + ExpectViewBoundsEquals(2, 1, 10, 20, &v1); + + RemoveAll(); +} + +TEST_F(GridLayoutTest, FixedSize) { + layout->SetInsets(2, 2, 2, 2); + + views::ColumnSet* set = layout->AddColumnSet(0); + + int column_count = 4; + int title_width = 100; + int row_count = 2; + int pref_width = 10; + int pref_height = 20; + + for (int i = 0; i < column_count; ++i) { + set->AddColumn(views::GridLayout::CENTER, + views::GridLayout::CENTER, + 0, + views::GridLayout::FIXED, + title_width, + title_width); + } + + for (int row = 0; row < row_count; ++row) { + layout->StartRow(0, 0); + for (int col = 0; col < column_count; ++col) { + layout->AddView(new SettableSizeView(gfx::Size(pref_width, pref_height))); + } + } + + layout->Layout(&host); + + for (int i = 0; i < column_count; ++i) { + for (int row = 0; row < row_count; ++row) { + View* view = host.GetChildViewAt(row * column_count + i); + ExpectViewBoundsEquals( + 2 + title_width * i + (title_width - pref_width) / 2, + 2 + pref_height * row, + pref_width, + pref_height, view); + } + } + + GetPreferredSize(); + EXPECT_EQ(gfx::Size(column_count * title_width + 4, + row_count * pref_height + 4), pref); +} + +TEST_F(GridLayoutTest, RowSpanWithPaddingRow) { + views::ColumnSet* set = layout->AddColumnSet(0); + + set->AddColumn(views::GridLayout::CENTER, + views::GridLayout::CENTER, + 0, + views::GridLayout::FIXED, + 10, + 10); + + layout->StartRow(0, 0); + layout->AddView(new SettableSizeView(gfx::Size(10, 10)), 1, 2); + layout->AddPaddingRow(0, 10); +} + +TEST_F(GridLayoutTest, RowSpan) { + views::ColumnSet* set = layout->AddColumnSet(0); + + set->AddColumn(views::GridLayout::LEADING, + views::GridLayout::LEADING, + 0, + views::GridLayout::USE_PREF, + 0, + 0); + set->AddColumn(views::GridLayout::LEADING, + views::GridLayout::LEADING, + 0, + views::GridLayout::USE_PREF, + 0, + 0); + + layout->StartRow(0, 0); + layout->AddView(new SettableSizeView(gfx::Size(20, 10))); + layout->AddView(new SettableSizeView(gfx::Size(20, 40)), 1, 2); + layout->StartRow(1, 0); + views::View* s3 = new SettableSizeView(gfx::Size(20, 10)); + layout->AddView(s3); + + GetPreferredSize(); + EXPECT_EQ(gfx::Size(40, 40), pref); + + host.SetBounds(0, 0, pref.width(), pref.height()); + layout->Layout(&host); + ExpectViewBoundsEquals(0, 10, 20, 10, s3); +} + +TEST_F(GridLayoutTest, RowSpan2) { + views::ColumnSet* set = layout->AddColumnSet(0); + + set->AddColumn(GridLayout::LEADING, GridLayout::LEADING, + 0, GridLayout::USE_PREF, 0, 0); + set->AddColumn(GridLayout::LEADING, GridLayout::LEADING, + 0,GridLayout::USE_PREF, 0, 0); + + layout->StartRow(0, 0); + layout->AddView(new SettableSizeView(gfx::Size(20, 20))); + views::View* s3 = new SettableSizeView(gfx::Size(64, 64)); + layout->AddView(s3, 1, 3); + + layout->AddPaddingRow(0, 10); + + layout->StartRow(0, 0); + layout->AddView(new SettableSizeView(gfx::Size(10, 20))); + + GetPreferredSize(); + EXPECT_EQ(gfx::Size(84, 64), pref); + + host.SetBounds(0, 0, pref.width(), pref.height()); + layout->Layout(&host); + ExpectViewBoundsEquals(20, 0, 64, 64, s3); +} + +TEST_F(GridLayoutTest, FixedViewWidth) { + views::ColumnSet* set = layout->AddColumnSet(0); + + set->AddColumn(GridLayout::LEADING, GridLayout::LEADING, + 0, GridLayout::USE_PREF, 0, 0); + set->AddColumn(GridLayout::LEADING, GridLayout::LEADING, + 0,GridLayout::USE_PREF, 0, 0); + + layout->StartRow(0, 0); + View* view = new SettableSizeView(gfx::Size(30, 40)); + layout->AddView(view, 1, 1, GridLayout::LEADING, GridLayout::LEADING, 10, 0); + + GetPreferredSize(); + EXPECT_EQ(10, pref.width()); + EXPECT_EQ(40, pref.height()); + + host.SetBounds(0, 0, pref.width(), pref.height()); + layout->Layout(&host); + ExpectViewBoundsEquals(0, 0, 10, 40, view); +} + +TEST_F(GridLayoutTest, FixedViewHeight) { + views::ColumnSet* set = layout->AddColumnSet(0); + + set->AddColumn(GridLayout::LEADING, GridLayout::LEADING, + 0, GridLayout::USE_PREF, 0, 0); + set->AddColumn(GridLayout::LEADING, GridLayout::LEADING, + 0,GridLayout::USE_PREF, 0, 0); + + layout->StartRow(0, 0); + View* view = new SettableSizeView(gfx::Size(30, 40)); + layout->AddView(view, 1, 1, GridLayout::LEADING, GridLayout::LEADING, 0, 10); + + GetPreferredSize(); + EXPECT_EQ(30, pref.width()); + EXPECT_EQ(10, pref.height()); + + host.SetBounds(0, 0, pref.width(), pref.height()); + layout->Layout(&host); + ExpectViewBoundsEquals(0, 0, 30, 10, view); +} + +// Make sure that for views that span columns the underlying columns are resized +// based on the resize percent of the column. +TEST_F(GridLayoutTest, ColumnSpanResizing) { + views::ColumnSet* set = layout->AddColumnSet(0); + + set->AddColumn(views::GridLayout::FILL, views::GridLayout::CENTER, + 2, views::GridLayout::USE_PREF, 0, 0); + set->AddColumn(views::GridLayout::FILL, views::GridLayout::CENTER, + 4, views::GridLayout::USE_PREF, 0, 0); + + layout->StartRow(0, 0); + // span_view spans two columns and is twice as big the views added below. + View* span_view = new SettableSizeView(gfx::Size(12, 40)); + layout->AddView(span_view, 2, 1, GridLayout::LEADING, GridLayout::LEADING); + + layout->StartRow(0, 0); + View* view1 = new SettableSizeView(gfx::Size(2, 40)); + View* view2 = new SettableSizeView(gfx::Size(4, 40)); + layout->AddView(view1); + layout->AddView(view2); + + host.SetBounds(0, 0, 12, 80); + layout->Layout(&host); + + ExpectViewBoundsEquals(0, 0, 12, 40, span_view); + + // view1 should be 4 pixels wide + // column_pref + (remaining_width * column_resize / total_column_resize) = + // 2 + (6 * 2 / 6). + ExpectViewBoundsEquals(0, 40, 4, 40, view1); + + // And view2 should be 8 pixels wide: + // 4 + (6 * 4 / 6). + ExpectViewBoundsEquals(4, 40, 8, 40, view2); +} + +// Check that GetPreferredSize() takes resizing of columns into account when +// there is additional space in the case we have column sets of different +// preferred sizes. +TEST_F(GridLayoutTest, ColumnResizingOnGetPreferredSize) { + views::ColumnSet* set = layout->AddColumnSet(0); + set->AddColumn(views::GridLayout::FILL, views::GridLayout::CENTER, + 1, views::GridLayout::USE_PREF, 0, 0); + + set = layout->AddColumnSet(1); + set->AddColumn(views::GridLayout::FILL, views::GridLayout::CENTER, + 1, views::GridLayout::USE_PREF, 0, 0); + + set = layout->AddColumnSet(2); + set->AddColumn(views::GridLayout::FILL, views::GridLayout::CENTER, + 1, views::GridLayout::USE_PREF, 0, 0); + + // Make a row containing a flexible view that trades width for height. + layout->StartRow(0, 0); + View* view1 = new FlexibleView(100); + layout->AddView(view1, 1, 1, GridLayout::FILL, GridLayout::LEADING); + + // The second row contains a view of fixed size that will enforce a column + // width of 20 pixels. + layout->StartRow(0, 1); + View* view2 = new SettableSizeView(gfx::Size(20, 20)); + layout->AddView(view2, 1, 1, GridLayout::FILL, GridLayout::LEADING); + + // Add another flexible view in row three in order to ensure column set + // ordering doesn't influence sizing behaviour. + layout->StartRow(0, 2); + View* view3 = new FlexibleView(40); + layout->AddView(view3, 1, 1, GridLayout::FILL, GridLayout::LEADING); + + // We expect a height of 50: 30 from the variable width view in the first row + // plus 20 from the statically sized view in the second row. The flexible + // view in the third row should contribute no height. + EXPECT_EQ(gfx::Size(20, 50), layout->GetPreferredSize(&host)); +} |