size_range_layout_unittest.cc 6.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192
  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. #include <memory>
  5. #include "ash/system/tray/size_range_layout.h"
  6. #include "testing/gtest/include/gtest/gtest.h"
  7. #include "ui/views/test/test_layout_manager.h"
  8. #include "ui/views/view.h"
  9. namespace ash {
  10. class SizeRangeLayoutTest : public testing::Test {
  11. public:
  12. SizeRangeLayoutTest();
  13. SizeRangeLayoutTest(const SizeRangeLayoutTest&) = delete;
  14. SizeRangeLayoutTest& operator=(const SizeRangeLayoutTest&) = delete;
  15. // Wrapper function to access the minimum preferred size of |layout|.
  16. gfx::Size GetMinSize(const SizeRangeLayout* layout) const;
  17. // Wrapper function to access the maximum preferred size of |layout|.
  18. gfx::Size GetMaxSize(const SizeRangeLayout* layout) const;
  19. protected:
  20. views::View host_;
  21. const gfx::Size kAbsoluteMinSize;
  22. const gfx::Size kAbsoluteMaxSize;
  23. };
  24. SizeRangeLayoutTest::SizeRangeLayoutTest()
  25. : kAbsoluteMinSize(SizeRangeLayout::kAbsoluteMinSize,
  26. SizeRangeLayout::kAbsoluteMinSize),
  27. kAbsoluteMaxSize(SizeRangeLayout::kAbsoluteMaxSize,
  28. SizeRangeLayout::kAbsoluteMaxSize) {}
  29. gfx::Size SizeRangeLayoutTest::GetMinSize(const SizeRangeLayout* layout) const {
  30. return layout->min_size_;
  31. }
  32. gfx::Size SizeRangeLayoutTest::GetMaxSize(const SizeRangeLayout* layout) const {
  33. return layout->max_size_;
  34. }
  35. TEST_F(SizeRangeLayoutTest, SizeRangeForDefaultConstruction) {
  36. SizeRangeLayout layout;
  37. EXPECT_EQ(kAbsoluteMinSize, GetMinSize(&layout));
  38. EXPECT_EQ(kAbsoluteMaxSize, GetMaxSize(&layout));
  39. }
  40. TEST_F(SizeRangeLayoutTest, SizeRangeForExplicitConstruction) {
  41. const gfx::Size kSmallSize = gfx::Size(13, 14);
  42. const gfx::Size kLargeSize = gfx::Size(25, 26);
  43. SizeRangeLayout layout(kSmallSize, kLargeSize);
  44. EXPECT_EQ(kSmallSize, GetMinSize(&layout));
  45. EXPECT_EQ(kLargeSize, GetMaxSize(&layout));
  46. }
  47. TEST_F(SizeRangeLayoutTest, InvalidMinSizeForExplicitConstruction) {
  48. const gfx::Size kInvalidSmallSize(-1, 2);
  49. const gfx::Size kExpectedMinSize(0, 2);
  50. SizeRangeLayout layout(kInvalidSmallSize, kAbsoluteMaxSize);
  51. EXPECT_EQ(kExpectedMinSize, GetMinSize(&layout));
  52. }
  53. TEST_F(SizeRangeLayoutTest, InvalidMaxSizeForExplicitConstruction) {
  54. const gfx::Size kInvalidSmallSize(-1, 2);
  55. const gfx::Size kExpectedMinSize(0, 2);
  56. SizeRangeLayout layout(kInvalidSmallSize, kAbsoluteMaxSize);
  57. EXPECT_EQ(kExpectedMinSize, GetMinSize(&layout));
  58. }
  59. TEST_F(SizeRangeLayoutTest, MaxSizeSmallerThanMinSizeConstruction) {
  60. const gfx::Size kMinSize(10, 11);
  61. const gfx::Size kMaxSize(5, 6);
  62. SizeRangeLayout layout(kMinSize, kMaxSize);
  63. EXPECT_EQ(kMaxSize, GetMinSize(&layout));
  64. EXPECT_EQ(kMaxSize, GetMaxSize(&layout));
  65. }
  66. TEST_F(SizeRangeLayoutTest, SizeRangeForExplicitSetSize) {
  67. const gfx::Size kSize = gfx::Size(13, 14);
  68. SizeRangeLayout layout;
  69. EXPECT_NE(kSize, GetMinSize(&layout));
  70. EXPECT_NE(kSize, GetMaxSize(&layout));
  71. layout.SetSize(kSize);
  72. EXPECT_EQ(kSize, GetMinSize(&layout));
  73. EXPECT_EQ(kSize, GetMaxSize(&layout));
  74. }
  75. TEST_F(SizeRangeLayoutTest, InvalidSizeRangesForExplicitSetSize) {
  76. const gfx::Size kInvalidSize(-7, 8);
  77. const gfx::Size kExpectedSize(0, 8);
  78. SizeRangeLayout layout;
  79. layout.SetSize(kInvalidSize);
  80. EXPECT_EQ(kExpectedSize, GetMinSize(&layout));
  81. EXPECT_EQ(kExpectedSize, GetMaxSize(&layout));
  82. }
  83. TEST_F(SizeRangeLayoutTest, InternalLayoutManagerPreferredSizeIsUsed) {
  84. const gfx::Size kSize(7, 8);
  85. std::unique_ptr<views::test::TestLayoutManager> child_layout =
  86. std::make_unique<views::test::TestLayoutManager>();
  87. child_layout->SetPreferredSize(kSize);
  88. SizeRangeLayout* const layout =
  89. host_.SetLayoutManager(std::make_unique<SizeRangeLayout>());
  90. EXPECT_NE(kSize, layout->GetPreferredSize(&host_));
  91. layout->SetLayoutManager(std::move(child_layout));
  92. EXPECT_EQ(kSize, layout->GetPreferredSize(&host_));
  93. }
  94. TEST_F(SizeRangeLayoutTest, SmallPreferredSizeIsClamped) {
  95. const gfx::Size kMinSize(10, 10);
  96. const gfx::Size kMaxSize(20, 20);
  97. const gfx::Size kLayoutPreferredSize(5, 5);
  98. std::unique_ptr<views::test::TestLayoutManager> child_layout =
  99. std::make_unique<views::test::TestLayoutManager>();
  100. child_layout->SetPreferredSize(kLayoutPreferredSize);
  101. SizeRangeLayout layout;
  102. layout.SetLayoutManager(std::move(child_layout));
  103. layout.SetMinSize(kMinSize);
  104. layout.SetMaxSize(kMaxSize);
  105. EXPECT_EQ(kMinSize, layout.GetPreferredSize(&host_));
  106. }
  107. TEST_F(SizeRangeLayoutTest, LargePreferredSizeIsClamped) {
  108. const gfx::Size kMinSize(10, 10);
  109. const gfx::Size kMaxSize(20, 20);
  110. const gfx::Size kLayoutPreferredSize(25, 25);
  111. std::unique_ptr<views::test::TestLayoutManager> child_layout =
  112. std::make_unique<views::test::TestLayoutManager>();
  113. child_layout->SetPreferredSize(kLayoutPreferredSize);
  114. SizeRangeLayout layout;
  115. layout.SetLayoutManager(std::move(child_layout));
  116. layout.SetMinSize(kMinSize);
  117. layout.SetMaxSize(kMaxSize);
  118. EXPECT_EQ(kMaxSize, layout.GetPreferredSize(&host_));
  119. }
  120. TEST_F(SizeRangeLayoutTest, MaxSizeLargerThanMinSizeUpdatesMinSize) {
  121. const gfx::Size kMinSize(10, 10);
  122. const gfx::Size kMaxSize(5, 5);
  123. SizeRangeLayout layout;
  124. layout.SetMinSize(kMinSize);
  125. EXPECT_EQ(kMinSize, GetMinSize(&layout));
  126. layout.SetMaxSize(kMaxSize);
  127. EXPECT_EQ(kMaxSize, GetMinSize(&layout));
  128. }
  129. TEST_F(SizeRangeLayoutTest, MinSizeSmallerThanMaxSizeUpdatesMaxSize) {
  130. const gfx::Size kMinSize(10, 10);
  131. const gfx::Size kMaxSize(5, 5);
  132. SizeRangeLayout layout;
  133. layout.SetMaxSize(kMaxSize);
  134. EXPECT_EQ(kMaxSize, GetMaxSize(&layout));
  135. layout.SetMinSize(kMinSize);
  136. EXPECT_EQ(kMinSize, GetMaxSize(&layout));
  137. }
  138. TEST_F(SizeRangeLayoutTest,
  139. InternalLayoutManagerPreferredHeightForWidthIsUsed) {
  140. const int kWidth = 5;
  141. const int kHeight = 9;
  142. std::unique_ptr<views::test::TestLayoutManager> child_layout =
  143. std::make_unique<views::test::TestLayoutManager>();
  144. child_layout->set_preferred_height_for_width(kHeight);
  145. SizeRangeLayout* const layout =
  146. host_.SetLayoutManager(std::make_unique<SizeRangeLayout>());
  147. EXPECT_NE(kHeight, layout->GetPreferredHeightForWidth(&host_, kWidth));
  148. layout->SetLayoutManager(std::move(child_layout));
  149. EXPECT_EQ(kHeight, layout->GetPreferredHeightForWidth(&host_, kWidth));
  150. }
  151. } // namespace ash