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 <memory> | |
6 | |
7 #include "ash/common/system/tray/tri_view.h" | |
8 #include "base/memory/ptr_util.h" | |
9 #include "testing/gtest/include/gtest/gtest.h" | |
10 #include "ui/gfx/geometry/insets.h" | |
11 #include "ui/gfx/geometry/rect_conversions.h" | |
12 #include "ui/views/test/test_layout_manager.h" | |
13 #include "ui/views/test/test_views.h" | |
14 #include "ui/views/view.h" | |
15 | |
16 namespace ash { | |
17 | |
18 class TriViewTest : public testing::Test { | |
19 public: | |
20 TriViewTest(); | |
21 | |
22 protected: | |
23 // Returns the bounds of |child| in the coordinate space of | |
24 // |tri_view_|. | |
25 gfx::Rect GetBoundsInHost(const views::View* child) const; | |
26 | |
27 // Wrapper functions to access the internals of |tri_view_|. | |
28 views::View* GetContainer(TriView::Container container) const; | |
29 | |
30 // The test target. | |
31 std::unique_ptr<TriView> tri_view_; | |
32 | |
33 private: | |
34 DISALLOW_COPY_AND_ASSIGN(TriViewTest); | |
35 }; | |
36 | |
37 TriViewTest::TriViewTest() : tri_view_(base::MakeUnique<TriView>()) {} | |
38 | |
39 gfx::Rect TriViewTest::GetBoundsInHost(const views::View* child) const { | |
40 gfx::RectF rect_f(child->bounds()); | |
41 views::View::ConvertRectToTarget(child, tri_view_.get(), &rect_f); | |
42 return ToNearestRect(rect_f); | |
43 } | |
44 | |
45 views::View* TriViewTest::GetContainer(TriView::Container container) const { | |
46 return tri_view_->GetContainer(container); | |
47 } | |
48 | |
49 TEST_F(TriViewTest, PaddingBetweenContainers) { | |
50 const int kPaddingBetweenContainers = 3; | |
51 const int kViewWidth = 10; | |
52 const int kViewHeight = 10; | |
53 const gfx::Size kViewSize(kViewWidth, kViewHeight); | |
54 const int kStartChildExpectedX = 0; | |
55 const int kCenterChildExpectedX = | |
56 kStartChildExpectedX + kViewWidth + kPaddingBetweenContainers; | |
57 const int kEndChildExpectedX = | |
58 kCenterChildExpectedX + kViewWidth + kPaddingBetweenContainers; | |
59 | |
60 tri_view_ = base::MakeUnique<TriView>(kPaddingBetweenContainers); | |
61 tri_view_->SetBounds(0, 0, 100, 10); | |
62 | |
63 views::View* start_child = new views::StaticSizedView(kViewSize); | |
64 views::View* center_child = new views::StaticSizedView(kViewSize); | |
65 views::View* end_child = new views::StaticSizedView(kViewSize); | |
66 | |
67 tri_view_->AddView(TriView::Container::START, start_child); | |
68 tri_view_->AddView(TriView::Container::CENTER, center_child); | |
69 tri_view_->AddView(TriView::Container::END, end_child); | |
70 | |
71 tri_view_->Layout(); | |
72 | |
73 EXPECT_EQ(kStartChildExpectedX, GetBoundsInHost(start_child).x()); | |
74 EXPECT_EQ(kCenterChildExpectedX, GetBoundsInHost(center_child).x()); | |
75 EXPECT_EQ(kEndChildExpectedX, GetBoundsInHost(end_child).x()); | |
76 } | |
77 | |
78 TEST_F(TriViewTest, VerticalOrientation) { | |
79 const int kViewWidth = 10; | |
80 const int kViewHeight = 10; | |
81 const gfx::Size kViewSize(kViewWidth, kViewHeight); | |
82 | |
83 tri_view_ = base::MakeUnique<TriView>(TriView::Orientation::VERTICAL); | |
84 tri_view_->SetBounds(0, 0, 10, 100); | |
85 | |
86 views::View* start_child = new views::StaticSizedView(kViewSize); | |
87 views::View* center_child = new views::StaticSizedView(kViewSize); | |
88 views::View* end_child = new views::StaticSizedView(kViewSize); | |
89 | |
90 tri_view_->AddView(TriView::Container::START, start_child); | |
91 tri_view_->AddView(TriView::Container::CENTER, center_child); | |
92 tri_view_->AddView(TriView::Container::END, end_child); | |
93 | |
94 tri_view_->Layout(); | |
95 | |
96 EXPECT_EQ(0, GetBoundsInHost(start_child).y()); | |
97 EXPECT_EQ(kViewWidth, GetBoundsInHost(center_child).y()); | |
98 EXPECT_EQ(kViewWidth * 2, GetBoundsInHost(end_child).y()); | |
99 } | |
100 | |
101 TEST_F(TriViewTest, MinCrossAxisSize) { | |
102 const int kMinCrossAxisSize = 15; | |
103 EXPECT_EQ(0, tri_view_->GetPreferredSize().height()); | |
104 tri_view_->SetMinCrossAxisSize(kMinCrossAxisSize); | |
105 EXPECT_EQ(kMinCrossAxisSize, tri_view_->GetPreferredSize().height()); | |
106 EXPECT_EQ(kMinCrossAxisSize, tri_view_->GetHeightForWidth(0)); | |
107 } | |
108 | |
109 TEST_F(TriViewTest, MainAxisMinSize) { | |
110 tri_view_->SetBounds(0, 0, 100, 10); | |
111 const gfx::Size kMinSize(15, 10); | |
112 tri_view_->SetMinSize(TriView::Container::START, kMinSize); | |
113 views::View* child = new views::StaticSizedView(gfx::Size(10, 10)); | |
114 tri_view_->AddView(TriView::Container::CENTER, child); | |
115 | |
116 tri_view_->Layout(); | |
117 | |
118 EXPECT_EQ(kMinSize.width(), GetBoundsInHost(child).x()); | |
119 } | |
120 | |
121 TEST_F(TriViewTest, MainAxisMaxSize) { | |
122 tri_view_->SetBounds(0, 0, 100, 10); | |
123 const gfx::Size kMaxSize(10, 10); | |
124 | |
125 tri_view_->SetMaxSize(TriView::Container::START, kMaxSize); | |
126 views::View* start_child = new views::StaticSizedView(gfx::Size(20, 20)); | |
127 tri_view_->AddView(TriView::Container::START, start_child); | |
128 | |
129 views::View* center_child = new views::StaticSizedView(gfx::Size(10, 10)); | |
130 tri_view_->AddView(TriView::Container::CENTER, center_child); | |
131 | |
132 tri_view_->Layout(); | |
133 | |
134 EXPECT_EQ(kMaxSize.width(), GetBoundsInHost(center_child).x()); | |
135 } | |
136 | |
137 TEST_F(TriViewTest, ViewsAddedToCorrectContainers) { | |
138 views::View* start_child = new views::StaticSizedView(); | |
139 views::View* center_child = new views::StaticSizedView(); | |
140 views::View* end_child = new views::StaticSizedView(); | |
141 | |
142 tri_view_->AddView(TriView::Container::START, start_child); | |
143 tri_view_->AddView(TriView::Container::CENTER, center_child); | |
144 tri_view_->AddView(TriView::Container::END, end_child); | |
145 | |
146 EXPECT_TRUE(GetContainer(TriView::Container::START)->Contains(start_child)); | |
147 EXPECT_EQ(1, GetContainer(TriView::Container::START)->child_count()); | |
148 | |
149 EXPECT_TRUE(GetContainer(TriView::Container::CENTER)->Contains(center_child)); | |
150 EXPECT_EQ(1, GetContainer(TriView::Container::CENTER)->child_count()); | |
151 | |
152 EXPECT_TRUE(GetContainer(TriView::Container::END)->Contains(end_child)); | |
153 EXPECT_EQ(1, GetContainer(TriView::Container::END)->child_count()); | |
154 } | |
155 | |
156 TEST_F(TriViewTest, MultipleViewsAddedToTheSameContainer) { | |
157 views::View* child1 = new views::StaticSizedView(); | |
158 views::View* child2 = new views::StaticSizedView(); | |
159 | |
160 tri_view_->AddView(TriView::Container::START, child1); | |
161 tri_view_->AddView(TriView::Container::START, child2); | |
162 | |
163 EXPECT_TRUE(GetContainer(TriView::Container::START)->Contains(child1)); | |
164 EXPECT_TRUE(GetContainer(TriView::Container::START)->Contains(child2)); | |
165 } | |
166 | |
167 TEST_F(TriViewTest, ViewsRemovedOnRemoveAllChildren) { | |
168 views::View* child1 = new views::StaticSizedView(); | |
169 views::View* child2 = new views::StaticSizedView(); | |
170 | |
171 tri_view_->AddView(TriView::Container::START, child1); | |
172 tri_view_->AddView(TriView::Container::START, child2); | |
173 | |
174 EXPECT_TRUE(GetContainer(TriView::Container::START)->Contains(child1)); | |
175 EXPECT_TRUE(GetContainer(TriView::Container::START)->Contains(child2)); | |
176 EXPECT_EQ(2, GetContainer(TriView::Container::START)->child_count()); | |
177 | |
178 tri_view_->RemoveAllChildren(TriView::Container::START, false); | |
179 | |
180 EXPECT_FALSE(GetContainer(TriView::Container::START)->Contains(child1)); | |
181 EXPECT_FALSE(GetContainer(TriView::Container::START)->Contains(child2)); | |
182 EXPECT_EQ(0, GetContainer(TriView::Container::START)->child_count()); | |
183 } | |
184 | |
185 TEST_F(TriViewTest, Insets) { | |
186 const int kInset = 3; | |
187 const int kViewHeight = 10; | |
188 const int kExpectedViewHeight = kViewHeight - 2 * kInset; | |
189 const gfx::Size kStartViewSize(10, kViewHeight); | |
190 const gfx::Size kCenterViewSize(100, kViewHeight); | |
191 const gfx::Size kEndViewSize(10, kViewHeight); | |
192 const int kHostWidth = 100; | |
193 | |
194 tri_view_->SetBounds(0, 0, kHostWidth, kViewHeight); | |
195 tri_view_->SetInsets(gfx::Insets(kInset)); | |
196 | |
197 views::View* start_child = new views::StaticSizedView(kStartViewSize); | |
198 views::View* center_child = new views::StaticSizedView(kCenterViewSize); | |
199 views::View* end_child = new views::StaticSizedView(kEndViewSize); | |
200 | |
201 tri_view_->AddView(TriView::Container::START, start_child); | |
202 tri_view_->AddView(TriView::Container::CENTER, center_child); | |
203 tri_view_->AddView(TriView::Container::END, end_child); | |
204 | |
205 tri_view_->SetFlexForContainer(TriView::Container::CENTER, 1.f); | |
206 tri_view_->Layout(); | |
207 | |
208 EXPECT_EQ( | |
209 gfx::Rect(kInset, kInset, kStartViewSize.width(), kExpectedViewHeight), | |
210 GetBoundsInHost(start_child)); | |
211 EXPECT_EQ(gfx::Rect(kInset + kStartViewSize.width(), kInset, | |
212 kHostWidth - kStartViewSize.width() - | |
213 kEndViewSize.width() - 2 * kInset, | |
214 kExpectedViewHeight), | |
215 GetBoundsInHost(center_child)); | |
216 EXPECT_EQ(gfx::Rect(kHostWidth - kEndViewSize.width() - kInset, kInset, | |
217 kEndViewSize.width(), kExpectedViewHeight), | |
218 GetBoundsInHost(end_child)); | |
219 } | |
220 | |
221 TEST_F(TriViewTest, InvisibleContainerDoesntTakeUpSpace) { | |
222 const int kViewWidth = 10; | |
223 const int kViewHeight = 10; | |
224 const gfx::Size kViewSize(kViewWidth, kViewHeight); | |
225 | |
226 tri_view_->SetBounds(0, 0, 30, 10); | |
227 | |
228 views::View* start_child = new views::StaticSizedView(kViewSize); | |
229 views::View* center_child = new views::StaticSizedView(kViewSize); | |
230 views::View* end_child = new views::StaticSizedView(kViewSize); | |
231 | |
232 tri_view_->AddView(TriView::Container::START, start_child); | |
233 tri_view_->AddView(TriView::Container::CENTER, center_child); | |
234 tri_view_->AddView(TriView::Container::END, end_child); | |
235 | |
236 tri_view_->SetContainerVisible(TriView::Container::START, false); | |
237 tri_view_->Layout(); | |
238 | |
239 EXPECT_EQ(gfx::Rect(0, 0, 0, 0), GetBoundsInHost(start_child)); | |
240 EXPECT_EQ(0, GetBoundsInHost(center_child).x()); | |
241 EXPECT_EQ(kViewWidth, GetBoundsInHost(end_child).x()); | |
242 | |
243 tri_view_->SetContainerVisible(TriView::Container::START, true); | |
244 tri_view_->Layout(); | |
245 | |
246 EXPECT_EQ(0, GetBoundsInHost(start_child).x()); | |
247 EXPECT_EQ(kViewWidth, GetBoundsInHost(center_child).x()); | |
248 EXPECT_EQ(kViewWidth * 2, GetBoundsInHost(end_child).x()); | |
249 } | |
250 | |
251 TEST_F(TriViewTest, NonZeroFlex) { | |
252 const int kHostWidth = 100; | |
253 const gfx::Size kDefaultViewSize(10, 10); | |
254 const gfx::Size kCenterViewSize(100, 10); | |
255 const gfx::Size kExpectedCenterViewSize( | |
256 kHostWidth - 2 * kDefaultViewSize.width(), 10); | |
257 | |
258 tri_view_->SetBounds(0, 0, kHostWidth, 10); | |
259 | |
260 views::View* start_child = new views::StaticSizedView(kDefaultViewSize); | |
261 views::View* center_child = new views::StaticSizedView(kCenterViewSize); | |
262 views::View* end_child = new views::StaticSizedView(kDefaultViewSize); | |
263 | |
264 tri_view_->AddView(TriView::Container::START, start_child); | |
265 tri_view_->AddView(TriView::Container::CENTER, center_child); | |
266 tri_view_->AddView(TriView::Container::END, end_child); | |
267 | |
268 tri_view_->SetFlexForContainer(TriView::Container::CENTER, 1.f); | |
269 tri_view_->Layout(); | |
270 | |
271 EXPECT_EQ(kDefaultViewSize, GetBoundsInHost(start_child).size()); | |
272 EXPECT_EQ(kExpectedCenterViewSize, GetBoundsInHost(center_child).size()); | |
273 EXPECT_EQ(kDefaultViewSize, GetBoundsInHost(end_child).size()); | |
274 } | |
275 | |
276 TEST_F(TriViewTest, NonZeroFlexTakesPrecedenceOverMinSize) { | |
277 const int kHostWidth = 25; | |
278 const gfx::Size kViewSize(10, 10); | |
279 const gfx::Size kMinCenterSize = kViewSize; | |
280 const gfx::Size kExpectedCenterSize(kHostWidth - 2 * kViewSize.width(), 10); | |
281 | |
282 tri_view_->SetBounds(0, 0, kHostWidth, 10); | |
283 | |
284 views::View* start_child = new views::StaticSizedView(kViewSize); | |
285 views::View* center_child = new views::StaticSizedView(kViewSize); | |
286 views::View* end_child = new views::StaticSizedView(kViewSize); | |
287 | |
288 tri_view_->AddView(TriView::Container::START, start_child); | |
289 tri_view_->AddView(TriView::Container::CENTER, center_child); | |
290 tri_view_->AddView(TriView::Container::END, end_child); | |
291 | |
292 tri_view_->SetFlexForContainer(TriView::Container::CENTER, 1.f); | |
293 tri_view_->SetMinSize(TriView::Container::CENTER, kMinCenterSize); | |
294 tri_view_->Layout(); | |
295 | |
296 EXPECT_EQ(kViewSize, GetBoundsInHost(start_child).size()); | |
297 EXPECT_EQ(kExpectedCenterSize, | |
298 GetBoundsInHost(GetContainer(TriView::Container::CENTER)).size()); | |
299 EXPECT_EQ(kViewSize, GetBoundsInHost(end_child).size()); | |
300 } | |
301 | |
302 TEST_F(TriViewTest, NonZeroFlexTakesPrecedenceOverMaxSize) { | |
303 const int kHostWidth = 100; | |
304 const gfx::Size kViewSize(10, 10); | |
305 const gfx::Size kMaxCenterSize(20, 10); | |
306 const gfx::Size kExpectedCenterSize(kHostWidth - 2 * kViewSize.width(), 10); | |
307 | |
308 tri_view_->SetBounds(0, 0, kHostWidth, 10); | |
309 | |
310 views::View* start_child = new views::StaticSizedView(kViewSize); | |
311 views::View* center_child = new views::StaticSizedView(kViewSize); | |
312 views::View* end_child = new views::StaticSizedView(kViewSize); | |
313 | |
314 tri_view_->AddView(TriView::Container::START, start_child); | |
315 tri_view_->AddView(TriView::Container::CENTER, center_child); | |
316 tri_view_->AddView(TriView::Container::END, end_child); | |
317 | |
318 tri_view_->SetFlexForContainer(TriView::Container::CENTER, 1.f); | |
319 tri_view_->SetMaxSize(TriView::Container::CENTER, kMaxCenterSize); | |
320 tri_view_->Layout(); | |
321 | |
322 EXPECT_EQ(kViewSize, GetBoundsInHost(start_child).size()); | |
323 EXPECT_EQ(kExpectedCenterSize, | |
324 GetBoundsInHost(GetContainer(TriView::Container::CENTER)).size()); | |
325 EXPECT_EQ(kViewSize, GetBoundsInHost(end_child).size()); | |
326 } | |
327 | |
328 } // namespace ash | |
OLD | NEW |