OLD | NEW |
(Empty) | |
| 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "ash/common/system/tray/size_range_layout.h" |
| 6 #include "base/memory/ptr_util.h" |
| 7 #include "testing/gtest/include/gtest/gtest.h" |
| 8 #include "ui/views/test/test_layout_manager.h" |
| 9 #include "ui/views/view.h" |
| 10 |
| 11 namespace ash { |
| 12 |
| 13 class SizeRangeLayoutTest : public testing::Test { |
| 14 public: |
| 15 SizeRangeLayoutTest(); |
| 16 |
| 17 // Wrapper function to access the minimum preferred size of |layout|. |
| 18 gfx::Size GetMinSize(const SizeRangeLayout* layout) const; |
| 19 |
| 20 // Wrapper function to access the maximum preferred size of |layout|. |
| 21 gfx::Size GetMaxSize(const SizeRangeLayout* layout) const; |
| 22 |
| 23 protected: |
| 24 views::View host_; |
| 25 |
| 26 private: |
| 27 DISALLOW_COPY_AND_ASSIGN(SizeRangeLayoutTest); |
| 28 }; |
| 29 |
| 30 SizeRangeLayoutTest::SizeRangeLayoutTest() {} |
| 31 |
| 32 gfx::Size SizeRangeLayoutTest::GetMinSize(const SizeRangeLayout* layout) const { |
| 33 return layout->min_size_; |
| 34 } |
| 35 |
| 36 gfx::Size SizeRangeLayoutTest::GetMaxSize(const SizeRangeLayout* layout) const { |
| 37 return layout->max_size_; |
| 38 } |
| 39 |
| 40 TEST_F(SizeRangeLayoutTest, SizeRangeForDefaultConstruction) { |
| 41 SizeRangeLayout layout; |
| 42 EXPECT_EQ(SizeRangeLayout::AbsoluteMinSize(), GetMinSize(&layout)); |
| 43 EXPECT_EQ(SizeRangeLayout::AbsoluteMaxSize(), GetMaxSize(&layout)); |
| 44 } |
| 45 |
| 46 TEST_F(SizeRangeLayoutTest, SizeRangeForExplicitConstruction) { |
| 47 const gfx::Size kSmallSize = gfx::Size(13, 14); |
| 48 const gfx::Size kLargeSize = gfx::Size(25, 26); |
| 49 |
| 50 SizeRangeLayout layout(kSmallSize, kLargeSize); |
| 51 EXPECT_EQ(kSmallSize, GetMinSize(&layout)); |
| 52 EXPECT_EQ(kLargeSize, GetMaxSize(&layout)); |
| 53 } |
| 54 |
| 55 TEST_F(SizeRangeLayoutTest, InvalidMinSizeForExplicitConstruction) { |
| 56 const gfx::Size kInvalidSmallSize(-1, 2); |
| 57 const gfx::Size kExpectedMinSize(0, 2); |
| 58 |
| 59 SizeRangeLayout layout(kInvalidSmallSize, SizeRangeLayout::AbsoluteMaxSize()); |
| 60 EXPECT_EQ(kExpectedMinSize, GetMinSize(&layout)); |
| 61 } |
| 62 |
| 63 TEST_F(SizeRangeLayoutTest, InvalidMaxSizeForExplicitConstruction) { |
| 64 const gfx::Size kInvalidSmallSize(-1, 2); |
| 65 const gfx::Size kExpectedMinSize(0, 2); |
| 66 |
| 67 SizeRangeLayout layout(kInvalidSmallSize, SizeRangeLayout::AbsoluteMaxSize()); |
| 68 EXPECT_EQ(kExpectedMinSize, GetMinSize(&layout)); |
| 69 } |
| 70 |
| 71 TEST_F(SizeRangeLayoutTest, MaxSizeSmallerThanMinSizeConstruction) { |
| 72 const gfx::Size kMinSize(10, 11); |
| 73 const gfx::Size kMaxSize(5, 6); |
| 74 |
| 75 SizeRangeLayout layout(kMinSize, kMaxSize); |
| 76 EXPECT_EQ(kMaxSize, GetMinSize(&layout)); |
| 77 EXPECT_EQ(kMaxSize, GetMaxSize(&layout)); |
| 78 } |
| 79 |
| 80 TEST_F(SizeRangeLayoutTest, SizeRangeForExplicitSetSize) { |
| 81 const gfx::Size kSize = gfx::Size(13, 14); |
| 82 |
| 83 SizeRangeLayout layout; |
| 84 EXPECT_NE(kSize, GetMinSize(&layout)); |
| 85 EXPECT_NE(kSize, GetMaxSize(&layout)); |
| 86 |
| 87 layout.SetSize(kSize); |
| 88 EXPECT_EQ(kSize, GetMinSize(&layout)); |
| 89 EXPECT_EQ(kSize, GetMaxSize(&layout)); |
| 90 } |
| 91 |
| 92 TEST_F(SizeRangeLayoutTest, InvalidSizeRangesForExplicitSetSize) { |
| 93 const gfx::Size kInvalidSize(-7, 8); |
| 94 const gfx::Size kExpectedSize(0, 8); |
| 95 |
| 96 SizeRangeLayout layout; |
| 97 layout.SetSize(kInvalidSize); |
| 98 EXPECT_EQ(kExpectedSize, GetMinSize(&layout)); |
| 99 EXPECT_EQ(kExpectedSize, GetMaxSize(&layout)); |
| 100 } |
| 101 |
| 102 TEST_F(SizeRangeLayoutTest, InternalLayoutManagerPreferredSizeIsUsed) { |
| 103 const gfx::Size kSize(7, 8); |
| 104 std::unique_ptr<views::test::TestLayoutManager> child_layout = |
| 105 base::MakeUnique<views::test::TestLayoutManager>(); |
| 106 child_layout->set_preferred_size(kSize); |
| 107 |
| 108 SizeRangeLayout layout; |
| 109 EXPECT_NE(kSize, layout.GetPreferredSize(&host_)); |
| 110 |
| 111 layout.SetLayoutManager(std::move(child_layout)); |
| 112 EXPECT_EQ(kSize, layout.GetPreferredSize(&host_)); |
| 113 } |
| 114 |
| 115 TEST_F(SizeRangeLayoutTest, SmallPreferredSizeIsClamped) { |
| 116 const gfx::Size kMinSize(10, 10); |
| 117 const gfx::Size kMaxSize(20, 20); |
| 118 const gfx::Size kLayoutPreferredSize(5, 5); |
| 119 std::unique_ptr<views::test::TestLayoutManager> child_layout = |
| 120 base::MakeUnique<views::test::TestLayoutManager>(); |
| 121 child_layout->set_preferred_size(kLayoutPreferredSize); |
| 122 |
| 123 SizeRangeLayout layout; |
| 124 layout.SetLayoutManager(std::move(child_layout)); |
| 125 layout.SetMinSize(kMinSize); |
| 126 layout.SetMaxSize(kMaxSize); |
| 127 EXPECT_EQ(kMinSize, layout.GetPreferredSize(&host_)); |
| 128 } |
| 129 |
| 130 TEST_F(SizeRangeLayoutTest, LargePreferredSizeIsClamped) { |
| 131 const gfx::Size kMinSize(10, 10); |
| 132 const gfx::Size kMaxSize(20, 20); |
| 133 const gfx::Size kLayoutPreferredSize(25, 25); |
| 134 std::unique_ptr<views::test::TestLayoutManager> child_layout = |
| 135 base::MakeUnique<views::test::TestLayoutManager>(); |
| 136 child_layout->set_preferred_size(kLayoutPreferredSize); |
| 137 |
| 138 SizeRangeLayout layout; |
| 139 layout.SetLayoutManager(std::move(child_layout)); |
| 140 layout.SetMinSize(kMinSize); |
| 141 layout.SetMaxSize(kMaxSize); |
| 142 EXPECT_EQ(kMaxSize, layout.GetPreferredSize(&host_)); |
| 143 } |
| 144 |
| 145 TEST_F(SizeRangeLayoutTest, MaxSizeLargerThanMinSizeUpdatesMinSize) { |
| 146 const gfx::Size kMinSize(10, 10); |
| 147 const gfx::Size kMaxSize(5, 5); |
| 148 |
| 149 SizeRangeLayout layout; |
| 150 layout.SetMinSize(kMinSize); |
| 151 EXPECT_EQ(kMinSize, GetMinSize(&layout)); |
| 152 layout.SetMaxSize(kMaxSize); |
| 153 EXPECT_EQ(kMaxSize, GetMinSize(&layout)); |
| 154 } |
| 155 |
| 156 TEST_F(SizeRangeLayoutTest, MinSizeSmallerThanMaxSizeUpdatesMaxSize) { |
| 157 const gfx::Size kMinSize(10, 10); |
| 158 const gfx::Size kMaxSize(5, 5); |
| 159 |
| 160 SizeRangeLayout layout; |
| 161 layout.SetMaxSize(kMaxSize); |
| 162 EXPECT_EQ(kMaxSize, GetMaxSize(&layout)); |
| 163 layout.SetMinSize(kMinSize); |
| 164 EXPECT_EQ(kMinSize, GetMaxSize(&layout)); |
| 165 } |
| 166 |
| 167 TEST_F(SizeRangeLayoutTest, |
| 168 InternalLayoutManagerPreferredHeightForWidthIsUsed) { |
| 169 const int kWidth = 5; |
| 170 const int kHeight = 9; |
| 171 std::unique_ptr<views::test::TestLayoutManager> child_layout = |
| 172 base::MakeUnique<views::test::TestLayoutManager>(); |
| 173 child_layout->set_preferred_height_for_width(kHeight); |
| 174 |
| 175 SizeRangeLayout layout; |
| 176 EXPECT_NE(kHeight, layout.GetPreferredHeightForWidth(&host_, kWidth)); |
| 177 |
| 178 layout.SetLayoutManager(std::move(child_layout)); |
| 179 EXPECT_EQ(kHeight, layout.GetPreferredHeightForWidth(&host_, kWidth)); |
| 180 } |
| 181 |
| 182 } // namespace ash |
OLD | NEW |