OLD | NEW |
1 // Copyright 2012 The Chromium Authors. All rights reserved. | 1 // Copyright 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/mac/scoped_nsobject.h" | |
6 #include "ios/chrome/browser/ui/rtl_geometry.h" | 5 #include "ios/chrome/browser/ui/rtl_geometry.h" |
7 #import "ios/chrome/browser/ui/stack_view/card_stack_layout_manager.h" | 6 #import "ios/chrome/browser/ui/stack_view/card_stack_layout_manager.h" |
8 #import "ios/chrome/browser/ui/stack_view/stack_card.h" | 7 #import "ios/chrome/browser/ui/stack_view/stack_card.h" |
9 #include "testing/gtest/include/gtest/gtest.h" | 8 #include "testing/gtest/include/gtest/gtest.h" |
10 #include "testing/platform_test.h" | 9 #include "testing/platform_test.h" |
11 | 10 |
| 11 #if !defined(__has_feature) || !__has_feature(objc_arc) |
| 12 #error "This file requires ARC support." |
| 13 #endif |
| 14 |
12 @interface CardStackLayoutManager (Private) | 15 @interface CardStackLayoutManager (Private) |
13 - (CGFloat)minStackStaggerAmount; | 16 - (CGFloat)minStackStaggerAmount; |
14 - (CGFloat)scrollCardAwayFromNeighborAmount; | 17 - (CGFloat)scrollCardAwayFromNeighborAmount; |
15 - (CGFloat)staggerOffsetForIndexFromEdge:(NSInteger)countFromEdge; | 18 - (CGFloat)staggerOffsetForIndexFromEdge:(NSInteger)countFromEdge; |
16 - (CGFloat)maximumCardSeparation; | 19 - (CGFloat)maximumCardSeparation; |
17 @end | 20 @end |
18 | 21 |
19 // A mock version of StackCard. | 22 // A mock version of StackCard. |
20 @interface MockStackCard : NSObject | 23 @interface MockStackCard : NSObject |
21 | 24 |
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
106 } | 109 } |
107 } | 110 } |
108 | 111 |
109 // Creates a new |CardStackLayoutManager|, adds |n| cards to it, and sets | 112 // Creates a new |CardStackLayoutManager|, adds |n| cards to it, and sets |
110 // dimensional/positioning parameters to the constants defined above. | 113 // dimensional/positioning parameters to the constants defined above. |
111 CardStackLayoutManager* newStackOfNCards(unsigned int n, BOOL layoutIsVertical) | 114 CardStackLayoutManager* newStackOfNCards(unsigned int n, BOOL layoutIsVertical) |
112 NS_RETURNS_RETAINED { | 115 NS_RETURNS_RETAINED { |
113 CardStackLayoutManager* stack = [[CardStackLayoutManager alloc] init]; | 116 CardStackLayoutManager* stack = [[CardStackLayoutManager alloc] init]; |
114 stack.layoutIsVertical = layoutIsVertical; | 117 stack.layoutIsVertical = layoutIsVertical; |
115 for (unsigned int i = 0; i < n; ++i) { | 118 for (unsigned int i = 0; i < n; ++i) { |
116 base::scoped_nsobject<StackCard> card( | 119 StackCard* card = static_cast<StackCard*>([[MockStackCard alloc] init]); |
117 (StackCard*)[[MockStackCard alloc] init]); | |
118 [stack addCard:card]; | 120 [stack addCard:card]; |
119 } | 121 } |
120 | 122 |
121 CGSize cardSize = CGSizeMake(kCardWidth, kCardHeight); | 123 CGSize cardSize = CGSizeMake(kCardWidth, kCardHeight); |
122 [stack setCardSize:cardSize]; | 124 [stack setCardSize:cardSize]; |
123 [stack setStartLimit:kMargin]; | 125 [stack setStartLimit:kMargin]; |
124 [stack setMaxStagger:kMaxStagger]; | 126 [stack setMaxStagger:kMaxStagger]; |
125 [stack setLayoutAxisPosition:kAxisPosition]; | 127 [stack setLayoutAxisPosition:kAxisPosition]; |
126 CGFloat cardLength = layoutIsVertical ? cardSize.height : cardSize.width; | 128 CGFloat cardLength = layoutIsVertical ? cardSize.height : cardSize.width; |
127 [stack setMaximumOverextensionAmount:cardLength / 2.0]; | 129 [stack setMaximumOverextensionAmount:cardLength / 2.0]; |
128 | 130 |
129 return stack; | 131 return stack; |
130 } | 132 } |
131 | 133 |
132 TEST_F(CardStackLayoutManagerTest, CardSizing) { | 134 TEST_F(CardStackLayoutManagerTest, CardSizing) { |
133 BOOL boolValues[2] = {NO, YES}; | 135 BOOL boolValues[2] = {NO, YES}; |
134 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 136 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
135 base::scoped_nsobject<CardStackLayoutManager> stack( | 137 CardStackLayoutManager* stack = [[CardStackLayoutManager alloc] init]; |
136 [[CardStackLayoutManager alloc] init]); | 138 stack.layoutIsVertical = boolValues[i]; |
137 stack.get().layoutIsVertical = boolValues[i]; | |
138 | 139 |
139 base::scoped_nsobject<StackCard> view1( | 140 StackCard* view1 = static_cast<StackCard*>([[MockStackCard alloc] init]); |
140 (StackCard*)[[MockStackCard alloc] init]); | 141 StackCard* view2 = static_cast<StackCard*>([[MockStackCard alloc] init]); |
141 base::scoped_nsobject<StackCard> view2( | 142 StackCard* view3 = static_cast<StackCard*>([[MockStackCard alloc] init]); |
142 (StackCard*)[[MockStackCard alloc] init]); | 143 [stack addCard:view1]; |
143 base::scoped_nsobject<StackCard> view3( | 144 [stack addCard:view2]; |
144 (StackCard*)[[MockStackCard alloc] init]); | 145 [stack addCard:view3]; |
145 [stack addCard:view1.get()]; | |
146 [stack addCard:view2.get()]; | |
147 [stack addCard:view3.get()]; | |
148 // Ensure that removed cards are not altered. | 146 // Ensure that removed cards are not altered. |
149 [stack removeCard:view2]; | 147 [stack removeCard:view2]; |
150 | 148 |
151 CGSize cardSize = CGSizeMake(111, 222); | 149 CGSize cardSize = CGSizeMake(111, 222); |
152 [stack setCardSize:cardSize]; | 150 [stack setCardSize:cardSize]; |
153 | 151 |
154 EXPECT_FLOAT_EQ(cardSize.width, [view1 size].width); | 152 EXPECT_FLOAT_EQ(cardSize.width, [view1 size].width); |
155 EXPECT_FLOAT_EQ(cardSize.height, [view1 size].height); | 153 EXPECT_FLOAT_EQ(cardSize.height, [view1 size].height); |
156 EXPECT_FLOAT_EQ(0.0, [view2 size].width); | 154 EXPECT_FLOAT_EQ(0.0, [view2 size].width); |
157 EXPECT_FLOAT_EQ(0.0, [view2 size].height); | 155 EXPECT_FLOAT_EQ(0.0, [view2 size].height); |
158 EXPECT_FLOAT_EQ(cardSize.width, [view3 size].width); | 156 EXPECT_FLOAT_EQ(cardSize.width, [view3 size].width); |
159 EXPECT_FLOAT_EQ(cardSize.height, [view3 size].height); | 157 EXPECT_FLOAT_EQ(cardSize.height, [view3 size].height); |
160 | 158 |
161 // But it should be automatically updated when it's added again. | 159 // But it should be automatically updated when it's added again. |
162 [stack addCard:view2]; | 160 [stack addCard:view2]; |
163 EXPECT_FLOAT_EQ(cardSize.width, [view2 size].width); | 161 EXPECT_FLOAT_EQ(cardSize.width, [view2 size].width); |
164 EXPECT_FLOAT_EQ(cardSize.height, [view2 size].height); | 162 EXPECT_FLOAT_EQ(cardSize.height, [view2 size].height); |
165 } | 163 } |
166 } | 164 } |
167 | 165 |
168 TEST_F(CardStackLayoutManagerTest, StackSizes) { | 166 TEST_F(CardStackLayoutManagerTest, StackSizes) { |
169 BOOL boolValues[2] = {NO, YES}; | 167 BOOL boolValues[2] = {NO, YES}; |
170 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 168 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
171 base::scoped_nsobject<CardStackLayoutManager> stack( | 169 CardStackLayoutManager* stack = [[CardStackLayoutManager alloc] init]; |
172 [[CardStackLayoutManager alloc] init]); | 170 stack.layoutIsVertical = boolValues[i]; |
173 stack.get().layoutIsVertical = boolValues[i]; | |
174 CGRect cardFrame = CGRectMake(0, 0, 100, 200); | 171 CGRect cardFrame = CGRectMake(0, 0, 100, 200); |
175 [stack setCardSize:cardFrame.size]; | 172 [stack setCardSize:cardFrame.size]; |
176 [stack setMaxStagger:30]; | 173 [stack setMaxStagger:30]; |
177 | 174 |
178 // Asking the size for a collapsed stack should give the same result. | 175 // Asking the size for a collapsed stack should give the same result. |
179 CGFloat emptyCollapsedSize = [stack fullyCollapsedStackLength]; | 176 CGFloat emptyCollapsedSize = [stack fullyCollapsedStackLength]; |
180 for (int i = 0; i < 10; ++i) { | 177 for (int i = 0; i < 10; ++i) { |
181 base::scoped_nsobject<StackCard> card( | 178 StackCard* card = |
182 (StackCard*)[[UIView alloc] initWithFrame:cardFrame]); | 179 static_cast<StackCard*>([[UIView alloc] initWithFrame:cardFrame]); |
183 [stack addCard:card]; | 180 [stack addCard:card]; |
184 } | 181 } |
185 CGFloat largeCollapsedSize = [stack fullyCollapsedStackLength]; | 182 CGFloat largeCollapsedSize = [stack fullyCollapsedStackLength]; |
186 EXPECT_FLOAT_EQ(emptyCollapsedSize, largeCollapsedSize); | 183 EXPECT_FLOAT_EQ(emptyCollapsedSize, largeCollapsedSize); |
187 | 184 |
188 // But a fanned-out stack should get bigger, and the maximum stack size | 185 // But a fanned-out stack should get bigger, and the maximum stack size |
189 // should be larger still. | 186 // should be larger still. |
190 CGFloat largeExpandedSize = [stack fannedStackLength]; | 187 CGFloat largeExpandedSize = [stack fannedStackLength]; |
191 EXPECT_GT(largeExpandedSize, largeCollapsedSize); | 188 EXPECT_GT(largeExpandedSize, largeCollapsedSize); |
192 CGFloat largeMaximumSize = [stack maximumStackLength]; | 189 CGFloat largeMaximumSize = [stack maximumStackLength]; |
193 EXPECT_GT(largeMaximumSize, largeExpandedSize); | 190 EXPECT_GT(largeMaximumSize, largeExpandedSize); |
194 base::scoped_nsobject<StackCard> card( | 191 StackCard* card = static_cast<StackCard*>([[MockStackCard alloc] init]); |
195 (StackCard*)[[MockStackCard alloc] init]); | |
196 [stack addCard:card]; | 192 [stack addCard:card]; |
197 CGFloat evenLargerExpandedSize = [stack fannedStackLength]; | 193 CGFloat evenLargerExpandedSize = [stack fannedStackLength]; |
198 EXPECT_LT(largeExpandedSize, evenLargerExpandedSize); | 194 EXPECT_LT(largeExpandedSize, evenLargerExpandedSize); |
199 CGFloat evenLargerMaximumSize = [stack maximumStackLength]; | 195 CGFloat evenLargerMaximumSize = [stack maximumStackLength]; |
200 EXPECT_LT(largeMaximumSize, evenLargerMaximumSize); | 196 EXPECT_LT(largeMaximumSize, evenLargerMaximumSize); |
201 | 197 |
202 // And start limit shouldn't matter. | 198 // And start limit shouldn't matter. |
203 [stack setStartLimit:10]; | 199 [stack setStartLimit:10]; |
204 EXPECT_FLOAT_EQ(emptyCollapsedSize, [stack fullyCollapsedStackLength]); | 200 EXPECT_FLOAT_EQ(emptyCollapsedSize, [stack fullyCollapsedStackLength]); |
205 EXPECT_FLOAT_EQ(evenLargerExpandedSize, [stack fannedStackLength]); | 201 EXPECT_FLOAT_EQ(evenLargerExpandedSize, [stack fannedStackLength]); |
206 EXPECT_FLOAT_EQ(evenLargerMaximumSize, [stack maximumStackLength]); | 202 EXPECT_FLOAT_EQ(evenLargerMaximumSize, [stack maximumStackLength]); |
207 } | 203 } |
208 } | 204 } |
209 | 205 |
210 TEST_F(CardStackLayoutManagerTest, StackLayout) { | 206 TEST_F(CardStackLayoutManagerTest, StackLayout) { |
211 BOOL boolValues[2] = {NO, YES}; | 207 BOOL boolValues[2] = {NO, YES}; |
212 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 208 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
213 const unsigned int kCardCount = 30; | 209 const unsigned int kCardCount = 30; |
214 base::scoped_nsobject<CardStackLayoutManager> stack( | 210 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
215 newStackOfNCards(kCardCount, boolValues[i])); | |
216 | 211 |
217 const float kEndLimit = | 212 const float kEndLimit = |
218 kDefaultEndLimitFraction * [stack fannedStackLength]; | 213 kDefaultEndLimitFraction * [stack fannedStackLength]; |
219 [stack setEndLimit:kEndLimit]; | 214 [stack setEndLimit:kEndLimit]; |
220 [stack fanOutCardsWithStartIndex:0]; | 215 [stack fanOutCardsWithStartIndex:0]; |
221 | 216 |
222 EXPECT_EQ(kCardCount, [[stack cards] count]); | 217 EXPECT_EQ(kCardCount, [[stack cards] count]); |
223 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 218 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
224 EXPECT_EQ(0, [stack lastStartStackCardIndex]); | 219 EXPECT_EQ(0, [stack lastStartStackCardIndex]); |
225 EXPECT_LT(0, [stack firstEndStackCardIndex]); | 220 EXPECT_LT(0, [stack firstEndStackCardIndex]); |
226 for (NSInteger i = 0; i < [stack firstEndStackCardIndex]; i++) { | 221 for (NSInteger i = 0; i < [stack firstEndStackCardIndex]; i++) { |
227 StackCard* card = [[stack cards] objectAtIndex:i]; | 222 StackCard* card = [[stack cards] objectAtIndex:i]; |
228 EXPECT_FLOAT_EQ(kMargin + i * kMaxStagger, | 223 EXPECT_FLOAT_EQ(kMargin + i * kMaxStagger, |
229 LayoutOffset(stack, card.layout.position)); | 224 LayoutOffset(stack, card.layout.position)); |
230 } | 225 } |
231 } | 226 } |
232 } | 227 } |
233 | 228 |
234 TEST_F(CardStackLayoutManagerTest, PreservingPositionsOnCardSizeChange) { | 229 TEST_F(CardStackLayoutManagerTest, PreservingPositionsOnCardSizeChange) { |
235 BOOL boolValues[2] = {NO, YES}; | 230 BOOL boolValues[2] = {NO, YES}; |
236 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 231 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
237 const unsigned int kCardCount = 3; | 232 const unsigned int kCardCount = 3; |
238 base::scoped_nsobject<CardStackLayoutManager> stack( | 233 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
239 newStackOfNCards(kCardCount, boolValues[i])); | |
240 | 234 |
241 const float kEndLimit = | 235 const float kEndLimit = |
242 kDefaultEndLimitFraction * [stack fannedStackLength]; | 236 kDefaultEndLimitFraction * [stack fannedStackLength]; |
243 [stack setEndLimit:kEndLimit]; | 237 [stack setEndLimit:kEndLimit]; |
244 [stack fanOutCardsWithStartIndex:0]; | 238 [stack fanOutCardsWithStartIndex:0]; |
245 | 239 |
246 EXPECT_EQ(kCardCount, [[stack cards] count]); | 240 EXPECT_EQ(kCardCount, [[stack cards] count]); |
247 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 241 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
248 EXPECT_EQ(0, [stack lastStartStackCardIndex]); | 242 EXPECT_EQ(0, [stack lastStartStackCardIndex]); |
249 EXPECT_LT(0, [stack firstEndStackCardIndex]); | 243 EXPECT_LT(0, [stack firstEndStackCardIndex]); |
(...skipping 15 matching lines...) Expand all Loading... |
265 EXPECT_FLOAT_EQ(kMargin + i * kMaxStagger, | 259 EXPECT_FLOAT_EQ(kMargin + i * kMaxStagger, |
266 LayoutOffset(stack, card.layout.position)); | 260 LayoutOffset(stack, card.layout.position)); |
267 } | 261 } |
268 } | 262 } |
269 } | 263 } |
270 | 264 |
271 TEST_F(CardStackLayoutManagerTest, SwappingPositionsOnOrientationChange) { | 265 TEST_F(CardStackLayoutManagerTest, SwappingPositionsOnOrientationChange) { |
272 BOOL boolValues[2] = {NO, YES}; | 266 BOOL boolValues[2] = {NO, YES}; |
273 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 267 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
274 const unsigned int kCardCount = 3; | 268 const unsigned int kCardCount = 3; |
275 base::scoped_nsobject<CardStackLayoutManager> stack( | 269 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
276 newStackOfNCards(kCardCount, boolValues[i])); | |
277 | 270 |
278 const float kEndLimit = | 271 const float kEndLimit = |
279 kDefaultEndLimitFraction * [stack fannedStackLength]; | 272 kDefaultEndLimitFraction * [stack fannedStackLength]; |
280 [stack setEndLimit:kEndLimit]; | 273 [stack setEndLimit:kEndLimit]; |
281 [stack fanOutCardsWithStartIndex:0]; | 274 [stack fanOutCardsWithStartIndex:0]; |
282 | 275 |
283 EXPECT_EQ(kCardCount, [[stack cards] count]); | 276 EXPECT_EQ(kCardCount, [[stack cards] count]); |
284 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 277 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
285 EXPECT_EQ(0, [stack lastStartStackCardIndex]); | 278 EXPECT_EQ(0, [stack lastStartStackCardIndex]); |
286 EXPECT_LT(0, [stack firstEndStackCardIndex]); | 279 EXPECT_LT(0, [stack firstEndStackCardIndex]); |
(...skipping 14 matching lines...) Expand all Loading... |
301 StackCard* card = [[stack cards] objectAtIndex:i]; | 294 StackCard* card = [[stack cards] objectAtIndex:i]; |
302 EXPECT_FLOAT_EQ(kMargin + i * kMaxStagger, | 295 EXPECT_FLOAT_EQ(kMargin + i * kMaxStagger, |
303 LayoutOffset(stack, card.layout.position)); | 296 LayoutOffset(stack, card.layout.position)); |
304 } | 297 } |
305 } | 298 } |
306 } | 299 } |
307 TEST_F(CardStackLayoutManagerTest, EndStackRecomputationOnEndLimitChange) { | 300 TEST_F(CardStackLayoutManagerTest, EndStackRecomputationOnEndLimitChange) { |
308 BOOL boolValues[2] = {NO, YES}; | 301 BOOL boolValues[2] = {NO, YES}; |
309 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 302 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
310 const unsigned int kCardCount = 3; | 303 const unsigned int kCardCount = 3; |
311 base::scoped_nsobject<CardStackLayoutManager> stack( | 304 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
312 newStackOfNCards(kCardCount, boolValues[i])); | |
313 | 305 |
314 CGFloat endLimit = [stack maximumStackLength]; | 306 CGFloat endLimit = [stack maximumStackLength]; |
315 [stack setEndLimit:endLimit]; | 307 [stack setEndLimit:endLimit]; |
316 [stack fanOutCardsWithStartIndex:0]; | 308 [stack fanOutCardsWithStartIndex:0]; |
317 | 309 |
318 EXPECT_EQ(kCardCount, [[stack cards] count]); | 310 EXPECT_EQ(kCardCount, [[stack cards] count]); |
319 ValidateCardPositioningConstraints(stack, endLimit, true); | 311 ValidateCardPositioningConstraints(stack, endLimit, true); |
320 EXPECT_EQ(0, [stack lastStartStackCardIndex]); | 312 EXPECT_EQ(0, [stack lastStartStackCardIndex]); |
321 EXPECT_EQ((int)kCardCount, [stack firstEndStackCardIndex]); | 313 EXPECT_EQ((int)kCardCount, [stack firstEndStackCardIndex]); |
322 for (NSInteger i = 0; i < [stack firstEndStackCardIndex]; i++) { | 314 for (NSInteger i = 0; i < [stack firstEndStackCardIndex]; i++) { |
(...skipping 25 matching lines...) Expand all Loading... |
348 EXPECT_FLOAT_EQ(kMargin + i * kMaxStagger, | 340 EXPECT_FLOAT_EQ(kMargin + i * kMaxStagger, |
349 LayoutOffset(stack, card.layout.position)); | 341 LayoutOffset(stack, card.layout.position)); |
350 } | 342 } |
351 } | 343 } |
352 } | 344 } |
353 | 345 |
354 TEST_F(CardStackLayoutManagerTest, StackLayoutAtSpecificIndex) { | 346 TEST_F(CardStackLayoutManagerTest, StackLayoutAtSpecificIndex) { |
355 BOOL boolValues[2] = {NO, YES}; | 347 BOOL boolValues[2] = {NO, YES}; |
356 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 348 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
357 const unsigned int kCardCount = 30; | 349 const unsigned int kCardCount = 30; |
358 base::scoped_nsobject<CardStackLayoutManager> stack( | 350 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
359 newStackOfNCards(kCardCount, boolValues[i])); | |
360 | 351 |
361 NSInteger startIndex = 10; | 352 NSInteger startIndex = 10; |
362 | 353 |
363 const float kEndLimit = | 354 const float kEndLimit = |
364 kDefaultEndLimitFraction * [stack fannedStackLength]; | 355 kDefaultEndLimitFraction * [stack fannedStackLength]; |
365 [stack setEndLimit:kEndLimit]; | 356 [stack setEndLimit:kEndLimit]; |
366 [stack fanOutCardsWithStartIndex:startIndex]; | 357 [stack fanOutCardsWithStartIndex:startIndex]; |
367 | 358 |
368 EXPECT_EQ(kCardCount, [[stack cards] count]); | 359 EXPECT_EQ(kCardCount, [[stack cards] count]); |
369 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 360 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
370 EXPECT_EQ(startIndex, [stack lastStartStackCardIndex]); | 361 EXPECT_EQ(startIndex, [stack lastStartStackCardIndex]); |
371 // Take into account start stack when verifying position of card at | 362 // Take into account start stack when verifying position of card at |
372 // |startIndex|. | 363 // |startIndex|. |
373 StackCard* startCard = [[stack cards] objectAtIndex:startIndex]; | 364 StackCard* startCard = [[stack cards] objectAtIndex:startIndex]; |
374 EXPECT_FLOAT_EQ(kMargin + [stack staggerOffsetForIndexFromEdge:startIndex], | 365 EXPECT_FLOAT_EQ(kMargin + [stack staggerOffsetForIndexFromEdge:startIndex], |
375 LayoutOffset(stack, startCard.layout.position)); | 366 LayoutOffset(stack, startCard.layout.position)); |
376 NSInteger firstEndStackCardIndex = [stack firstEndStackCardIndex]; | 367 NSInteger firstEndStackCardIndex = [stack firstEndStackCardIndex]; |
377 for (NSInteger i = startIndex + 1; i < firstEndStackCardIndex; i++) { | 368 for (NSInteger i = startIndex + 1; i < firstEndStackCardIndex; i++) { |
378 StackCard* card = [[stack cards] objectAtIndex:i]; | 369 StackCard* card = [[stack cards] objectAtIndex:i]; |
379 EXPECT_FLOAT_EQ(kMargin + (i - startIndex) * kMaxStagger, | 370 EXPECT_FLOAT_EQ(kMargin + (i - startIndex) * kMaxStagger, |
380 LayoutOffset(stack, card.layout.position)); | 371 LayoutOffset(stack, card.layout.position)); |
381 } | 372 } |
382 } | 373 } |
383 } | 374 } |
384 | 375 |
385 TEST_F(CardStackLayoutManagerTest, CardIsCovered) { | 376 TEST_F(CardStackLayoutManagerTest, CardIsCovered) { |
386 BOOL boolValues[2] = {NO, YES}; | 377 BOOL boolValues[2] = {NO, YES}; |
387 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 378 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
388 const unsigned int kCardCount = 3; | 379 const unsigned int kCardCount = 3; |
389 base::scoped_nsobject<CardStackLayoutManager> stack( | 380 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
390 newStackOfNCards(kCardCount, boolValues[i])); | |
391 | 381 |
392 const float kEndLimit = | 382 const float kEndLimit = |
393 kDefaultEndLimitFraction * [stack fannedStackLength]; | 383 kDefaultEndLimitFraction * [stack fannedStackLength]; |
394 [stack setEndLimit:kEndLimit]; | 384 [stack setEndLimit:kEndLimit]; |
395 [stack fanOutCardsWithStartIndex:0]; | 385 [stack fanOutCardsWithStartIndex:0]; |
396 | 386 |
397 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 387 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
398 EXPECT_EQ(0, [stack lastStartStackCardIndex]); | 388 EXPECT_EQ(0, [stack lastStartStackCardIndex]); |
399 EXPECT_EQ((int)kCardCount, [stack firstEndStackCardIndex]); | 389 EXPECT_EQ((int)kCardCount, [stack firstEndStackCardIndex]); |
400 // Since no cards are hidden in the start or end stack, all cards should | 390 // Since no cards are hidden in the start or end stack, all cards should |
401 // be visible (i.e., not covered). | 391 // be visible (i.e., not covered). |
402 for (NSUInteger i = 0; i < kCardCount; i++) { | 392 for (NSUInteger i = 0; i < kCardCount; i++) { |
403 StackCard* card = [[stack cards] objectAtIndex:i]; | 393 StackCard* card = [[stack cards] objectAtIndex:i]; |
404 EXPECT_FALSE([stack cardIsCovered:card]); | 394 EXPECT_FALSE([stack cardIsCovered:card]); |
405 } | 395 } |
406 // Moving the second card to the same location as the third card should | 396 // Moving the second card to the same location as the third card should |
407 // result in the third card covering the second card. | 397 // result in the third card covering the second card. |
408 StackCard* secondCard = [[stack cards] objectAtIndex:1]; | 398 StackCard* secondCard = [[stack cards] objectAtIndex:1]; |
409 StackCard* thirdCard = [[stack cards] objectAtIndex:2]; | 399 StackCard* thirdCard = [[stack cards] objectAtIndex:2]; |
410 secondCard.layout = thirdCard.layout; | 400 secondCard.layout = thirdCard.layout; |
411 EXPECT_TRUE([stack cardIsCovered:secondCard]); | 401 EXPECT_TRUE([stack cardIsCovered:secondCard]); |
412 EXPECT_FALSE([stack cardIsCovered:thirdCard]); | 402 EXPECT_FALSE([stack cardIsCovered:thirdCard]); |
413 } | 403 } |
414 } | 404 } |
415 | 405 |
416 TEST_F(CardStackLayoutManagerTest, CardIsCollapsed) { | 406 TEST_F(CardStackLayoutManagerTest, CardIsCollapsed) { |
417 BOOL boolValues[2] = {NO, YES}; | 407 BOOL boolValues[2] = {NO, YES}; |
418 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 408 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
419 const unsigned int kCardCount = 3; | 409 const unsigned int kCardCount = 3; |
420 base::scoped_nsobject<CardStackLayoutManager> stack( | 410 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
421 newStackOfNCards(kCardCount, boolValues[i])); | |
422 | 411 |
423 const float kEndLimit = | 412 const float kEndLimit = |
424 kDefaultEndLimitFraction * [stack fannedStackLength]; | 413 kDefaultEndLimitFraction * [stack fannedStackLength]; |
425 [stack setEndLimit:kEndLimit]; | 414 [stack setEndLimit:kEndLimit]; |
426 [stack fanOutCardsWithStartIndex:0]; | 415 [stack fanOutCardsWithStartIndex:0]; |
427 | 416 |
428 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 417 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
429 EXPECT_EQ(0, [stack lastStartStackCardIndex]); | 418 EXPECT_EQ(0, [stack lastStartStackCardIndex]); |
430 EXPECT_EQ((int)kCardCount, [stack firstEndStackCardIndex]); | 419 EXPECT_EQ((int)kCardCount, [stack firstEndStackCardIndex]); |
431 // Since the cards are fully fanned out, no cards should be collapsed. | 420 // Since the cards are fully fanned out, no cards should be collapsed. |
(...skipping 12 matching lines...) Expand all Loading... |
444 collapsedLayout.position.leading -= [stack minStackStaggerAmount]; | 433 collapsedLayout.position.leading -= [stack minStackStaggerAmount]; |
445 secondCard.layout = collapsedLayout; | 434 secondCard.layout = collapsedLayout; |
446 EXPECT_TRUE([stack cardIsCollapsed:secondCard]); | 435 EXPECT_TRUE([stack cardIsCollapsed:secondCard]); |
447 } | 436 } |
448 } | 437 } |
449 | 438 |
450 TEST_F(CardStackLayoutManagerTest, BasicScroll) { | 439 TEST_F(CardStackLayoutManagerTest, BasicScroll) { |
451 BOOL boolValues[2] = {NO, YES}; | 440 BOOL boolValues[2] = {NO, YES}; |
452 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 441 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
453 const unsigned int kCardCount = 3; | 442 const unsigned int kCardCount = 3; |
454 base::scoped_nsobject<CardStackLayoutManager> stack( | 443 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
455 newStackOfNCards(kCardCount, boolValues[i])); | |
456 StackCard* firstCard = [[stack cards] objectAtIndex:0]; | 444 StackCard* firstCard = [[stack cards] objectAtIndex:0]; |
457 | 445 |
458 const float kEndLimit = | 446 const float kEndLimit = |
459 kDefaultEndLimitFraction * [stack fannedStackLength]; | 447 kDefaultEndLimitFraction * [stack fannedStackLength]; |
460 [stack setEndLimit:kEndLimit]; | 448 [stack setEndLimit:kEndLimit]; |
461 [stack fanOutCardsWithStartIndex:0]; | 449 [stack fanOutCardsWithStartIndex:0]; |
462 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 450 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
463 EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position)); | 451 EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position)); |
464 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1)); | 452 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1)); |
465 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2)); | 453 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2)); |
(...skipping 18 matching lines...) Expand all Loading... |
484 EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position)); | 472 EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position)); |
485 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1)); | 473 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1)); |
486 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2)); | 474 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2)); |
487 } | 475 } |
488 } | 476 } |
489 | 477 |
490 TEST_F(CardStackLayoutManagerTest, ScrollCardAwayFromNeighbor) { | 478 TEST_F(CardStackLayoutManagerTest, ScrollCardAwayFromNeighbor) { |
491 BOOL boolValues[2] = {NO, YES}; | 479 BOOL boolValues[2] = {NO, YES}; |
492 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 480 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
493 const unsigned int kCardCount = 3; | 481 const unsigned int kCardCount = 3; |
494 base::scoped_nsobject<CardStackLayoutManager> stack( | 482 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
495 newStackOfNCards(kCardCount, boolValues[i])); | |
496 StackCard* firstCard = [[stack cards] objectAtIndex:0]; | 483 StackCard* firstCard = [[stack cards] objectAtIndex:0]; |
497 | 484 |
498 // Configure the stack so that the first card is > the scroll-away distance | 485 // Configure the stack so that the first card is > the scroll-away distance |
499 // from the end stack, but the second card is not. | 486 // from the end stack, but the second card is not. |
500 const float kEndLimit = | 487 const float kEndLimit = |
501 [stack scrollCardAwayFromNeighborAmount] + 2 * [stack maxStagger]; | 488 [stack scrollCardAwayFromNeighborAmount] + 2 * [stack maxStagger]; |
502 [stack setEndLimit:kEndLimit]; | 489 [stack setEndLimit:kEndLimit]; |
503 [stack fanOutCardsWithStartIndex:0]; | 490 [stack fanOutCardsWithStartIndex:0]; |
504 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 491 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
505 EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position)); | 492 EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position)); |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
551 EXPECT_FLOAT_EQ(separation, | 538 EXPECT_FLOAT_EQ(separation, |
552 kEndLimit - LayoutOffset(stack, thirdCard.layout.position)); | 539 kEndLimit - LayoutOffset(stack, thirdCard.layout.position)); |
553 EXPECT_EQ(3, [stack firstEndStackCardIndex]); | 540 EXPECT_EQ(3, [stack firstEndStackCardIndex]); |
554 } | 541 } |
555 } | 542 } |
556 | 543 |
557 TEST_F(CardStackLayoutManagerTest, ScrollNotScrollingLeadingCards) { | 544 TEST_F(CardStackLayoutManagerTest, ScrollNotScrollingLeadingCards) { |
558 BOOL boolValues[2] = {NO, YES}; | 545 BOOL boolValues[2] = {NO, YES}; |
559 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 546 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
560 const unsigned int kCardCount = 4; | 547 const unsigned int kCardCount = 4; |
561 base::scoped_nsobject<CardStackLayoutManager> stack( | 548 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
562 newStackOfNCards(kCardCount, boolValues[i])); | |
563 StackCard* firstCard = [[stack cards] objectAtIndex:0]; | 549 StackCard* firstCard = [[stack cards] objectAtIndex:0]; |
564 | 550 |
565 // Make the stack large enough to fan out all its cards to avoid having to | 551 // Make the stack large enough to fan out all its cards to avoid having to |
566 // worry about the end stack below. | 552 // worry about the end stack below. |
567 const float kEndLimit = [stack fannedStackLength]; | 553 const float kEndLimit = [stack fannedStackLength]; |
568 [stack setEndLimit:kEndLimit]; | 554 [stack setEndLimit:kEndLimit]; |
569 [stack fanOutCardsWithStartIndex:0]; | 555 [stack fanOutCardsWithStartIndex:0]; |
570 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 556 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
571 EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position)); | 557 EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position)); |
572 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1)); | 558 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1)); |
(...skipping 30 matching lines...) Expand all Loading... |
603 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1)); | 589 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1)); |
604 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2)); | 590 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2)); |
605 EXPECT_FLOAT_EQ(kMaxStagger - 10, SeparationOnLayoutAxis(stack, 2, 3)); | 591 EXPECT_FLOAT_EQ(kMaxStagger - 10, SeparationOnLayoutAxis(stack, 2, 3)); |
606 } | 592 } |
607 } | 593 } |
608 | 594 |
609 TEST_F(CardStackLayoutManagerTest, ScrollCollapseExpansionOfLargeStack) { | 595 TEST_F(CardStackLayoutManagerTest, ScrollCollapseExpansionOfLargeStack) { |
610 BOOL boolValues[2] = {NO, YES}; | 596 BOOL boolValues[2] = {NO, YES}; |
611 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 597 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
612 const unsigned int kCardCount = 10; | 598 const unsigned int kCardCount = 10; |
613 base::scoped_nsobject<CardStackLayoutManager> stack( | 599 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
614 newStackOfNCards(kCardCount, boolValues[i])); | |
615 | 600 |
616 const float kEndLimit = | 601 const float kEndLimit = |
617 kDefaultEndLimitFraction * [stack fannedStackLength]; | 602 kDefaultEndLimitFraction * [stack fannedStackLength]; |
618 [stack setEndLimit:kEndLimit]; | 603 [stack setEndLimit:kEndLimit]; |
619 | 604 |
620 [stack fanOutCardsWithStartIndex:0]; | 605 [stack fanOutCardsWithStartIndex:0]; |
621 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 606 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
622 EXPECT_TRUE([stack stackIsFullyFannedOut]); | 607 EXPECT_TRUE([stack stackIsFullyFannedOut]); |
623 EXPECT_FALSE([stack stackIsFullyCollapsed]); | 608 EXPECT_FALSE([stack stackIsFullyCollapsed]); |
624 EXPECT_FALSE([stack stackIsFullyOverextended]); | 609 EXPECT_FALSE([stack stackIsFullyOverextended]); |
(...skipping 30 matching lines...) Expand all Loading... |
655 EXPECT_FALSE([stack stackIsFullyFannedOut]); | 640 EXPECT_FALSE([stack stackIsFullyFannedOut]); |
656 EXPECT_TRUE([stack stackIsFullyCollapsed]); | 641 EXPECT_TRUE([stack stackIsFullyCollapsed]); |
657 EXPECT_TRUE([stack stackIsFullyOverextended]); | 642 EXPECT_TRUE([stack stackIsFullyOverextended]); |
658 } | 643 } |
659 } | 644 } |
660 | 645 |
661 TEST_F(CardStackLayoutManagerTest, ScrollCollapseExpansionOfStackCornerCases) { | 646 TEST_F(CardStackLayoutManagerTest, ScrollCollapseExpansionOfStackCornerCases) { |
662 BOOL boolValues[2] = {NO, YES}; | 647 BOOL boolValues[2] = {NO, YES}; |
663 const unsigned int kCardCount = 1; | 648 const unsigned int kCardCount = 1; |
664 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 649 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
665 base::scoped_nsobject<CardStackLayoutManager> stack( | 650 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
666 newStackOfNCards(kCardCount, boolValues[i])); | |
667 | 651 |
668 // A laid-out stack with one card is fully collapsed and fully fanned out, | 652 // A laid-out stack with one card is fully collapsed and fully fanned out, |
669 // but not fully overextended. | 653 // but not fully overextended. |
670 [stack fanOutCardsWithStartIndex:0]; | 654 [stack fanOutCardsWithStartIndex:0]; |
671 EXPECT_TRUE([stack stackIsFullyFannedOut]); | 655 EXPECT_TRUE([stack stackIsFullyFannedOut]); |
672 EXPECT_TRUE([stack stackIsFullyCollapsed]); | 656 EXPECT_TRUE([stack stackIsFullyCollapsed]); |
673 EXPECT_FALSE([stack stackIsFullyOverextended]); | 657 EXPECT_FALSE([stack stackIsFullyOverextended]); |
674 | 658 |
675 // A stack with no cards is fully collapsed, fully fanned out, and fully | 659 // A stack with no cards is fully collapsed, fully fanned out, and fully |
676 // overextended. | 660 // overextended. |
677 [stack removeCard:[[stack cards] objectAtIndex:0]]; | 661 [stack removeCard:[[stack cards] objectAtIndex:0]]; |
678 EXPECT_TRUE([stack stackIsFullyFannedOut]); | 662 EXPECT_TRUE([stack stackIsFullyFannedOut]); |
679 EXPECT_TRUE([stack stackIsFullyCollapsed]); | 663 EXPECT_TRUE([stack stackIsFullyCollapsed]); |
680 EXPECT_TRUE([stack stackIsFullyOverextended]); | 664 EXPECT_TRUE([stack stackIsFullyOverextended]); |
681 } | 665 } |
682 } | 666 } |
683 | 667 |
684 TEST_F(CardStackLayoutManagerTest, OneCardOverscroll) { | 668 TEST_F(CardStackLayoutManagerTest, OneCardOverscroll) { |
685 BOOL boolValues[2] = {NO, YES}; | 669 BOOL boolValues[2] = {NO, YES}; |
686 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 670 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
687 const unsigned int kCardCount = 1; | 671 const unsigned int kCardCount = 1; |
688 const float kScrollAwayAmount = 20.0; | 672 const float kScrollAwayAmount = 20.0; |
689 base::scoped_nsobject<CardStackLayoutManager> stack( | 673 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
690 newStackOfNCards(kCardCount, boolValues[i])); | |
691 StackCard* firstCard = [[stack cards] objectAtIndex:0]; | 674 StackCard* firstCard = [[stack cards] objectAtIndex:0]; |
692 | 675 |
693 const float kEndLimit = | 676 const float kEndLimit = |
694 kDefaultEndLimitFraction * [stack fannedStackLength]; | 677 kDefaultEndLimitFraction * [stack fannedStackLength]; |
695 [stack setEndLimit:kEndLimit]; | 678 [stack setEndLimit:kEndLimit]; |
696 [stack fanOutCardsWithStartIndex:0]; | 679 [stack fanOutCardsWithStartIndex:0]; |
697 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 680 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
698 EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position)); | 681 EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position)); |
699 | 682 |
700 // Scrolling toward end should result in overscroll. | 683 // Scrolling toward end should result in overscroll. |
(...skipping 26 matching lines...) Expand all Loading... |
727 EXPECT_FLOAT_EQ(kMargin - kScrollAwayAmount, | 710 EXPECT_FLOAT_EQ(kMargin - kScrollAwayAmount, |
728 LayoutOffset(stack, firstCard.layout.position)); | 711 LayoutOffset(stack, firstCard.layout.position)); |
729 } | 712 } |
730 } | 713 } |
731 | 714 |
732 TEST_F(CardStackLayoutManagerTest, MaximumOverextensionAmount) { | 715 TEST_F(CardStackLayoutManagerTest, MaximumOverextensionAmount) { |
733 BOOL boolValues[2] = {NO, YES}; | 716 BOOL boolValues[2] = {NO, YES}; |
734 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 717 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
735 const unsigned int kCardCount = 1; | 718 const unsigned int kCardCount = 1; |
736 const float kScrollAwayAmount = 20.0; | 719 const float kScrollAwayAmount = 20.0; |
737 base::scoped_nsobject<CardStackLayoutManager> stack( | 720 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
738 newStackOfNCards(kCardCount, boolValues[i])); | |
739 StackCard* firstCard = [[stack cards] objectAtIndex:0]; | 721 StackCard* firstCard = [[stack cards] objectAtIndex:0]; |
740 | 722 |
741 const float kEndLimit = | 723 const float kEndLimit = |
742 kDefaultEndLimitFraction * [stack fannedStackLength]; | 724 kDefaultEndLimitFraction * [stack fannedStackLength]; |
743 [stack setEndLimit:kEndLimit]; | 725 [stack setEndLimit:kEndLimit]; |
744 [stack fanOutCardsWithStartIndex:0]; | 726 [stack fanOutCardsWithStartIndex:0]; |
745 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 727 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
746 EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position)); | 728 EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position)); |
747 | 729 |
748 // Scrolling toward start/end should have no impact. | 730 // Scrolling toward start/end should have no impact. |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
800 LayoutOffset(stack, firstCard.layout.position)); | 782 LayoutOffset(stack, firstCard.layout.position)); |
801 EXPECT_FLOAT_EQ(maxOverextensionAmount, [stack overextensionAmount]); | 783 EXPECT_FLOAT_EQ(maxOverextensionAmount, [stack overextensionAmount]); |
802 } | 784 } |
803 } | 785 } |
804 | 786 |
805 TEST_F(CardStackLayoutManagerTest, DecayOnOverscroll) { | 787 TEST_F(CardStackLayoutManagerTest, DecayOnOverscroll) { |
806 BOOL boolValues[2] = {NO, YES}; | 788 BOOL boolValues[2] = {NO, YES}; |
807 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 789 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
808 const unsigned int kCardCount = 1; | 790 const unsigned int kCardCount = 1; |
809 const float kScrollAwayAmount = 10.0; | 791 const float kScrollAwayAmount = 10.0; |
810 base::scoped_nsobject<CardStackLayoutManager> stack( | 792 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
811 newStackOfNCards(kCardCount, boolValues[i])); | |
812 StackCard* firstCard = [[stack cards] objectAtIndex:0]; | 793 StackCard* firstCard = [[stack cards] objectAtIndex:0]; |
813 | 794 |
814 const float kEndLimit = | 795 const float kEndLimit = |
815 kDefaultEndLimitFraction * [stack fannedStackLength]; | 796 kDefaultEndLimitFraction * [stack fannedStackLength]; |
816 [stack setEndLimit:kEndLimit]; | 797 [stack setEndLimit:kEndLimit]; |
817 [stack fanOutCardsWithStartIndex:0]; | 798 [stack fanOutCardsWithStartIndex:0]; |
818 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 799 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
819 EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position)); | 800 EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position)); |
820 | 801 |
821 // Scrolling toward end by |kScrollAwayAmount| should result in overscroll. | 802 // Scrolling toward end by |kScrollAwayAmount| should result in overscroll. |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
856 EXPECT_GT(kMargin + 3 * kScrollAwayAmount, | 837 EXPECT_GT(kMargin + 3 * kScrollAwayAmount, |
857 LayoutOffset(stack, firstCard.layout.position)); | 838 LayoutOffset(stack, firstCard.layout.position)); |
858 } | 839 } |
859 } | 840 } |
860 | 841 |
861 TEST_F(CardStackLayoutManagerTest, EliminateOverextension) { | 842 TEST_F(CardStackLayoutManagerTest, EliminateOverextension) { |
862 BOOL boolValues[2] = {NO, YES}; | 843 BOOL boolValues[2] = {NO, YES}; |
863 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 844 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
864 const unsigned int kCardCount = 2; | 845 const unsigned int kCardCount = 2; |
865 const float kScrollAwayAmount = 20.0; | 846 const float kScrollAwayAmount = 20.0; |
866 base::scoped_nsobject<CardStackLayoutManager> stack( | 847 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
867 newStackOfNCards(kCardCount, boolValues[i])); | |
868 StackCard* firstCard = [[stack cards] objectAtIndex:0]; | 848 StackCard* firstCard = [[stack cards] objectAtIndex:0]; |
869 StackCard* secondCard = [[stack cards] objectAtIndex:1]; | 849 StackCard* secondCard = [[stack cards] objectAtIndex:1]; |
870 | 850 |
871 const float kEndLimit = | 851 const float kEndLimit = |
872 kDefaultEndLimitFraction * [stack fannedStackLength]; | 852 kDefaultEndLimitFraction * [stack fannedStackLength]; |
873 [stack setEndLimit:kEndLimit]; | 853 [stack setEndLimit:kEndLimit]; |
874 [stack fanOutCardsWithStartIndex:0]; | 854 [stack fanOutCardsWithStartIndex:0]; |
875 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 855 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
876 EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position)); | 856 EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position)); |
877 | 857 |
(...skipping 71 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
949 EXPECT_FLOAT_EQ(secondCardInitialOrigin + kScrollAwayAmount, | 929 EXPECT_FLOAT_EQ(secondCardInitialOrigin + kScrollAwayAmount, |
950 LayoutOffset(stack, secondCard.layout.position)); | 930 LayoutOffset(stack, secondCard.layout.position)); |
951 } | 931 } |
952 } | 932 } |
953 | 933 |
954 TEST_F(CardStackLayoutManagerTest, MultiCardOverscroll) { | 934 TEST_F(CardStackLayoutManagerTest, MultiCardOverscroll) { |
955 BOOL boolValues[2] = {NO, YES}; | 935 BOOL boolValues[2] = {NO, YES}; |
956 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 936 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
957 const unsigned int kCardCount = 3; | 937 const unsigned int kCardCount = 3; |
958 const float kScrollAwayAmount = 100.0; | 938 const float kScrollAwayAmount = 100.0; |
959 base::scoped_nsobject<CardStackLayoutManager> stack( | 939 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
960 newStackOfNCards(kCardCount, boolValues[i])); | |
961 StackCard* firstCard = [[stack cards] objectAtIndex:0]; | 940 StackCard* firstCard = [[stack cards] objectAtIndex:0]; |
962 | 941 |
963 const float kEndLimit = | 942 const float kEndLimit = |
964 kDefaultEndLimitFraction * [stack fannedStackLength]; | 943 kDefaultEndLimitFraction * [stack fannedStackLength]; |
965 [stack setEndLimit:kEndLimit]; | 944 [stack setEndLimit:kEndLimit]; |
966 [stack fanOutCardsWithStartIndex:0]; | 945 [stack fanOutCardsWithStartIndex:0]; |
967 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 946 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
968 EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position)); | 947 EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position)); |
969 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1)); | 948 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1)); |
970 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2)); | 949 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2)); |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1006 EXPECT_TRUE([stack overextensionTowardStartOnCardAtIndex:0]); | 985 EXPECT_TRUE([stack overextensionTowardStartOnCardAtIndex:0]); |
1007 EXPECT_FLOAT_EQ(kMargin - 10, | 986 EXPECT_FLOAT_EQ(kMargin - 10, |
1008 LayoutOffset(stack, firstCard.layout.position)); | 987 LayoutOffset(stack, firstCard.layout.position)); |
1009 } | 988 } |
1010 } | 989 } |
1011 | 990 |
1012 TEST_F(CardStackLayoutManagerTest, Fling) { | 991 TEST_F(CardStackLayoutManagerTest, Fling) { |
1013 BOOL boolValues[2] = {NO, YES}; | 992 BOOL boolValues[2] = {NO, YES}; |
1014 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 993 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
1015 const unsigned int kCardCount = 3; | 994 const unsigned int kCardCount = 3; |
1016 base::scoped_nsobject<CardStackLayoutManager> stack( | 995 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
1017 newStackOfNCards(kCardCount, boolValues[i])); | |
1018 StackCard* firstCard = [[stack cards] objectAtIndex:0]; | 996 StackCard* firstCard = [[stack cards] objectAtIndex:0]; |
1019 | 997 |
1020 const float kEndLimit = | 998 const float kEndLimit = |
1021 kDefaultEndLimitFraction * [stack fannedStackLength]; | 999 kDefaultEndLimitFraction * [stack fannedStackLength]; |
1022 [stack setEndLimit:kEndLimit]; | 1000 [stack setEndLimit:kEndLimit]; |
1023 [stack fanOutCardsWithStartIndex:0]; | 1001 [stack fanOutCardsWithStartIndex:0]; |
1024 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 1002 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
1025 EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position)); | 1003 EXPECT_FLOAT_EQ(kMargin, LayoutOffset(stack, firstCard.layout.position)); |
1026 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1)); | 1004 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1)); |
1027 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2)); | 1005 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2)); |
(...skipping 16 matching lines...) Expand all Loading... |
1044 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 1022 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
1045 EXPECT_TRUE([stack overextensionTowardStartOnCardAtIndex:0]); | 1023 EXPECT_TRUE([stack overextensionTowardStartOnCardAtIndex:0]); |
1046 EXPECT_FALSE([stack overextensionTowardEndOnFirstCard]); | 1024 EXPECT_FALSE([stack overextensionTowardEndOnFirstCard]); |
1047 } | 1025 } |
1048 } | 1026 } |
1049 | 1027 |
1050 TEST_F(CardStackLayoutManagerTest, ScrollAroundStartStack) { | 1028 TEST_F(CardStackLayoutManagerTest, ScrollAroundStartStack) { |
1051 BOOL boolValues[2] = {NO, YES}; | 1029 BOOL boolValues[2] = {NO, YES}; |
1052 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 1030 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
1053 const unsigned int kCardCount = 3; | 1031 const unsigned int kCardCount = 3; |
1054 base::scoped_nsobject<CardStackLayoutManager> stack( | 1032 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
1055 newStackOfNCards(kCardCount, boolValues[i])); | |
1056 | 1033 |
1057 const float kEndLimit = | 1034 const float kEndLimit = |
1058 kDefaultEndLimitFraction * [stack fannedStackLength]; | 1035 kDefaultEndLimitFraction * [stack fannedStackLength]; |
1059 [stack setEndLimit:kEndLimit]; | 1036 [stack setEndLimit:kEndLimit]; |
1060 [stack fanOutCardsWithStartIndex:0]; | 1037 [stack fanOutCardsWithStartIndex:0]; |
1061 | 1038 |
1062 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1)); | 1039 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1)); |
1063 EXPECT_EQ(0, [stack lastStartStackCardIndex]); | 1040 EXPECT_EQ(0, [stack lastStartStackCardIndex]); |
1064 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 1041 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
1065 | 1042 |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1107 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 1084 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
1108 EXPECT_EQ(0, [stack lastStartStackCardIndex]); | 1085 EXPECT_EQ(0, [stack lastStartStackCardIndex]); |
1109 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2)); | 1086 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2)); |
1110 } | 1087 } |
1111 } | 1088 } |
1112 | 1089 |
1113 TEST_F(CardStackLayoutManagerTest, ScrollAroundEndStack) { | 1090 TEST_F(CardStackLayoutManagerTest, ScrollAroundEndStack) { |
1114 BOOL boolValues[2] = {NO, YES}; | 1091 BOOL boolValues[2] = {NO, YES}; |
1115 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 1092 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
1116 const unsigned int kCardCount = 7; | 1093 const unsigned int kCardCount = 7; |
1117 base::scoped_nsobject<CardStackLayoutManager> stack( | 1094 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
1118 newStackOfNCards(kCardCount, boolValues[i])); | |
1119 | 1095 |
1120 const float kEndLimit = 0.2 * [stack fannedStackLength]; | 1096 const float kEndLimit = 0.2 * [stack fannedStackLength]; |
1121 [stack setEndLimit:kEndLimit]; | 1097 [stack setEndLimit:kEndLimit]; |
1122 [stack fanOutCardsWithStartIndex:4]; | 1098 [stack fanOutCardsWithStartIndex:4]; |
1123 | 1099 |
1124 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 5, 6)); | 1100 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 5, 6)); |
1125 EXPECT_EQ(4, [stack lastStartStackCardIndex]); | 1101 EXPECT_EQ(4, [stack lastStartStackCardIndex]); |
1126 EXPECT_EQ(7, [stack firstEndStackCardIndex]); | 1102 EXPECT_EQ(7, [stack firstEndStackCardIndex]); |
1127 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 1103 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
1128 | 1104 |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1171 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 1147 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
1172 EXPECT_EQ([stack firstEndStackCardIndex], 7); | 1148 EXPECT_EQ([stack firstEndStackCardIndex], 7); |
1173 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 5, 6)); | 1149 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 5, 6)); |
1174 } | 1150 } |
1175 } | 1151 } |
1176 | 1152 |
1177 TEST_F(CardStackLayoutManagerTest, BasicMultitouch) { | 1153 TEST_F(CardStackLayoutManagerTest, BasicMultitouch) { |
1178 BOOL boolValues[2] = {NO, YES}; | 1154 BOOL boolValues[2] = {NO, YES}; |
1179 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 1155 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
1180 const unsigned int kCardCount = 3; | 1156 const unsigned int kCardCount = 3; |
1181 base::scoped_nsobject<CardStackLayoutManager> stack( | 1157 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
1182 newStackOfNCards(kCardCount, boolValues[i])); | |
1183 | 1158 |
1184 const float kEndLimit = | 1159 const float kEndLimit = |
1185 kDefaultEndLimitFraction * [stack fannedStackLength]; | 1160 kDefaultEndLimitFraction * [stack fannedStackLength]; |
1186 [stack setEndLimit:kEndLimit]; | 1161 [stack setEndLimit:kEndLimit]; |
1187 [stack fanOutCardsWithStartIndex:0]; | 1162 [stack fanOutCardsWithStartIndex:0]; |
1188 | 1163 |
1189 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 1164 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
1190 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1)); | 1165 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1)); |
1191 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2)); | 1166 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2)); |
1192 | 1167 |
1193 [stack handleMultitouchWithFirstDelta:-10 | 1168 [stack handleMultitouchWithFirstDelta:-10 |
1194 secondDelta:50 | 1169 secondDelta:50 |
1195 firstCardIndex:1 | 1170 firstCardIndex:1 |
1196 secondCardIndex:2 | 1171 secondCardIndex:2 |
1197 decayOnOverpinch:YES]; | 1172 decayOnOverpinch:YES]; |
1198 ValidateCardPositioningConstraints(stack, kEndLimit, false); | 1173 ValidateCardPositioningConstraints(stack, kEndLimit, false); |
1199 EXPECT_FLOAT_EQ(kMaxStagger - 10, SeparationOnLayoutAxis(stack, 0, 1)); | 1174 EXPECT_FLOAT_EQ(kMaxStagger - 10, SeparationOnLayoutAxis(stack, 0, 1)); |
1200 EXPECT_FLOAT_EQ(kMaxStagger + 60, SeparationOnLayoutAxis(stack, 1, 2)); | 1175 EXPECT_FLOAT_EQ(kMaxStagger + 60, SeparationOnLayoutAxis(stack, 1, 2)); |
1201 } | 1176 } |
1202 } | 1177 } |
1203 | 1178 |
1204 TEST_F(CardStackLayoutManagerTest, MultitouchBoundedByNeighbor) { | 1179 TEST_F(CardStackLayoutManagerTest, MultitouchBoundedByNeighbor) { |
1205 BOOL boolValues[2] = {NO, YES}; | 1180 BOOL boolValues[2] = {NO, YES}; |
1206 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 1181 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
1207 const unsigned int kCardCount = 3; | 1182 const unsigned int kCardCount = 3; |
1208 base::scoped_nsobject<CardStackLayoutManager> stack( | 1183 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
1209 newStackOfNCards(kCardCount, boolValues[i])); | |
1210 | 1184 |
1211 // Make sure that the stack end limit isn't hit in this test. | 1185 // Make sure that the stack end limit isn't hit in this test. |
1212 const float kEndLimit = 2.0 * [stack maximumStackLength]; | 1186 const float kEndLimit = 2.0 * [stack maximumStackLength]; |
1213 [stack setEndLimit:kEndLimit]; | 1187 [stack setEndLimit:kEndLimit]; |
1214 [stack fanOutCardsWithStartIndex:0]; | 1188 [stack fanOutCardsWithStartIndex:0]; |
1215 | 1189 |
1216 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 1190 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
1217 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1)); | 1191 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1)); |
1218 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2)); | 1192 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2)); |
1219 | 1193 |
(...skipping 22 matching lines...) Expand all Loading... |
1242 secondCardIndex:2 | 1216 secondCardIndex:2 |
1243 decayOnOverpinch:YES]; | 1217 decayOnOverpinch:YES]; |
1244 ValidateCardPositioningConstraints(stack, kEndLimit, false); | 1218 ValidateCardPositioningConstraints(stack, kEndLimit, false); |
1245 } | 1219 } |
1246 } | 1220 } |
1247 | 1221 |
1248 TEST_F(CardStackLayoutManagerTest, OverpinchTowardStart) { | 1222 TEST_F(CardStackLayoutManagerTest, OverpinchTowardStart) { |
1249 BOOL boolValues[2] = {NO, YES}; | 1223 BOOL boolValues[2] = {NO, YES}; |
1250 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 1224 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
1251 const unsigned int kCardCount = 2; | 1225 const unsigned int kCardCount = 2; |
1252 base::scoped_nsobject<CardStackLayoutManager> stack( | 1226 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
1253 newStackOfNCards(kCardCount, boolValues[i])); | |
1254 | 1227 |
1255 const float kEndLimit = | 1228 const float kEndLimit = |
1256 kDefaultEndLimitFraction * [stack fannedStackLength]; | 1229 kDefaultEndLimitFraction * [stack fannedStackLength]; |
1257 [stack setEndLimit:kEndLimit]; | 1230 [stack setEndLimit:kEndLimit]; |
1258 [stack fanOutCardsWithStartIndex:0]; | 1231 [stack fanOutCardsWithStartIndex:0]; |
1259 | 1232 |
1260 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 1233 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
1261 StackCard* firstCard = [[stack cards] objectAtIndex:0]; | 1234 StackCard* firstCard = [[stack cards] objectAtIndex:0]; |
1262 LayoutRectPosition firstCardPosition = firstCard.layout.position; | 1235 LayoutRectPosition firstCardPosition = firstCard.layout.position; |
1263 StackCard* secondCard = [[stack cards] objectAtIndex:1]; | 1236 StackCard* secondCard = [[stack cards] objectAtIndex:1]; |
(...skipping 12 matching lines...) Expand all Loading... |
1276 LayoutOffset(stack, firstCard.layout.position)); | 1249 LayoutOffset(stack, firstCard.layout.position)); |
1277 EXPECT_FLOAT_EQ(LayoutOffset(stack, secondCardPosition) + 10, | 1250 EXPECT_FLOAT_EQ(LayoutOffset(stack, secondCardPosition) + 10, |
1278 LayoutOffset(stack, secondCard.layout.position)); | 1251 LayoutOffset(stack, secondCard.layout.position)); |
1279 } | 1252 } |
1280 } | 1253 } |
1281 | 1254 |
1282 TEST_F(CardStackLayoutManagerTest, OverpinchTowardEnd) { | 1255 TEST_F(CardStackLayoutManagerTest, OverpinchTowardEnd) { |
1283 BOOL boolValues[2] = {NO, YES}; | 1256 BOOL boolValues[2] = {NO, YES}; |
1284 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 1257 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
1285 const unsigned int kCardCount = 2; | 1258 const unsigned int kCardCount = 2; |
1286 base::scoped_nsobject<CardStackLayoutManager> stack( | 1259 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
1287 newStackOfNCards(kCardCount, boolValues[i])); | |
1288 | 1260 |
1289 const float kEndLimit = | 1261 const float kEndLimit = |
1290 kDefaultEndLimitFraction * [stack fannedStackLength]; | 1262 kDefaultEndLimitFraction * [stack fannedStackLength]; |
1291 [stack setEndLimit:kEndLimit]; | 1263 [stack setEndLimit:kEndLimit]; |
1292 [stack fanOutCardsWithStartIndex:0]; | 1264 [stack fanOutCardsWithStartIndex:0]; |
1293 | 1265 |
1294 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 1266 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
1295 StackCard* firstCard = [[stack cards] objectAtIndex:0]; | 1267 StackCard* firstCard = [[stack cards] objectAtIndex:0]; |
1296 LayoutRectPosition firstCardPosition = firstCard.layout.position; | 1268 LayoutRectPosition firstCardPosition = firstCard.layout.position; |
1297 StackCard* secondCard = [[stack cards] objectAtIndex:1]; | 1269 StackCard* secondCard = [[stack cards] objectAtIndex:1]; |
(...skipping 10 matching lines...) Expand all Loading... |
1308 LayoutOffset(stack, firstCard.layout.position)); | 1280 LayoutOffset(stack, firstCard.layout.position)); |
1309 EXPECT_FLOAT_EQ(LayoutOffset(stack, secondCardPosition) + 10, | 1281 EXPECT_FLOAT_EQ(LayoutOffset(stack, secondCardPosition) + 10, |
1310 LayoutOffset(stack, secondCard.layout.position)); | 1282 LayoutOffset(stack, secondCard.layout.position)); |
1311 } | 1283 } |
1312 } | 1284 } |
1313 | 1285 |
1314 TEST_F(CardStackLayoutManagerTest, StressMultitouch) { | 1286 TEST_F(CardStackLayoutManagerTest, StressMultitouch) { |
1315 BOOL boolValues[2] = {NO, YES}; | 1287 BOOL boolValues[2] = {NO, YES}; |
1316 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 1288 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
1317 const unsigned int kCardCount = 30; | 1289 const unsigned int kCardCount = 30; |
1318 base::scoped_nsobject<CardStackLayoutManager> stack( | 1290 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
1319 newStackOfNCards(kCardCount, boolValues[i])); | |
1320 | 1291 |
1321 const float kEndLimit = | 1292 const float kEndLimit = |
1322 kDefaultEndLimitFraction * [stack fannedStackLength]; | 1293 kDefaultEndLimitFraction * [stack fannedStackLength]; |
1323 [stack setEndLimit:kEndLimit]; | 1294 [stack setEndLimit:kEndLimit]; |
1324 [stack fanOutCardsWithStartIndex:0]; | 1295 [stack fanOutCardsWithStartIndex:0]; |
1325 | 1296 |
1326 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 1297 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
1327 | 1298 |
1328 [stack handleMultitouchWithFirstDelta:-10 | 1299 [stack handleMultitouchWithFirstDelta:-10 |
1329 secondDelta:50 | 1300 secondDelta:50 |
(...skipping 15 matching lines...) Expand all Loading... |
1345 secondCardIndex:4 | 1316 secondCardIndex:4 |
1346 decayOnOverpinch:YES]; | 1317 decayOnOverpinch:YES]; |
1347 ValidateCardPositioningConstraints(stack, kEndLimit, false); | 1318 ValidateCardPositioningConstraints(stack, kEndLimit, false); |
1348 } | 1319 } |
1349 } | 1320 } |
1350 | 1321 |
1351 TEST_F(CardStackLayoutManagerTest, ScrollAfterMultitouch) { | 1322 TEST_F(CardStackLayoutManagerTest, ScrollAfterMultitouch) { |
1352 BOOL boolValues[2] = {NO, YES}; | 1323 BOOL boolValues[2] = {NO, YES}; |
1353 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 1324 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
1354 const unsigned int kCardCount = 3; | 1325 const unsigned int kCardCount = 3; |
1355 base::scoped_nsobject<CardStackLayoutManager> stack( | 1326 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
1356 newStackOfNCards(kCardCount, boolValues[i])); | |
1357 | 1327 |
1358 const float kEndLimit = | 1328 const float kEndLimit = |
1359 kDefaultEndLimitFraction * [stack fannedStackLength]; | 1329 kDefaultEndLimitFraction * [stack fannedStackLength]; |
1360 const float kPinchDistance = 50; | 1330 const float kPinchDistance = 50; |
1361 [stack setEndLimit:kEndLimit]; | 1331 [stack setEndLimit:kEndLimit]; |
1362 [stack fanOutCardsWithStartIndex:0]; | 1332 [stack fanOutCardsWithStartIndex:0]; |
1363 | 1333 |
1364 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 1334 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
1365 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2)); | 1335 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2)); |
1366 | 1336 |
(...skipping 24 matching lines...) Expand all Loading... |
1391 // Separation between cards should be maintained. | 1361 // Separation between cards should be maintained. |
1392 EXPECT_FLOAT_EQ(kMaxStagger + kPinchDistance, | 1362 EXPECT_FLOAT_EQ(kMaxStagger + kPinchDistance, |
1393 SeparationOnLayoutAxis(stack, 1, 2)); | 1363 SeparationOnLayoutAxis(stack, 1, 2)); |
1394 } | 1364 } |
1395 } | 1365 } |
1396 | 1366 |
1397 TEST_F(CardStackLayoutManagerTest, ScrollEveningOutAfterMultitouch) { | 1367 TEST_F(CardStackLayoutManagerTest, ScrollEveningOutAfterMultitouch) { |
1398 BOOL boolValues[2] = {NO, YES}; | 1368 BOOL boolValues[2] = {NO, YES}; |
1399 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 1369 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
1400 const unsigned int kCardCount = 3; | 1370 const unsigned int kCardCount = 3; |
1401 base::scoped_nsobject<CardStackLayoutManager> stack( | 1371 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
1402 newStackOfNCards(kCardCount, boolValues[i])); | |
1403 | 1372 |
1404 const float kEndLimit = | 1373 const float kEndLimit = |
1405 kDefaultEndLimitFraction * [stack fannedStackLength]; | 1374 kDefaultEndLimitFraction * [stack fannedStackLength]; |
1406 const float kPinchDistance = kMaxStagger / 2.0; | 1375 const float kPinchDistance = kMaxStagger / 2.0; |
1407 [stack setEndLimit:kEndLimit]; | 1376 [stack setEndLimit:kEndLimit]; |
1408 [stack fanOutCardsWithStartIndex:0]; | 1377 [stack fanOutCardsWithStartIndex:0]; |
1409 | 1378 |
1410 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 1379 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
1411 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2)); | 1380 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2)); |
1412 | 1381 |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1451 scrollLeadingCards:YES]; | 1420 scrollLeadingCards:YES]; |
1452 ValidateCardPositioningConstraints(stack, kEndLimit, false); | 1421 ValidateCardPositioningConstraints(stack, kEndLimit, false); |
1453 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2)); | 1422 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2)); |
1454 } | 1423 } |
1455 } | 1424 } |
1456 | 1425 |
1457 TEST_F(CardStackLayoutManagerTest, ScrollAroundStartStackAfterMultitouch) { | 1426 TEST_F(CardStackLayoutManagerTest, ScrollAroundStartStackAfterMultitouch) { |
1458 BOOL boolValues[2] = {NO, YES}; | 1427 BOOL boolValues[2] = {NO, YES}; |
1459 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 1428 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
1460 const unsigned int kCardCount = 3; | 1429 const unsigned int kCardCount = 3; |
1461 base::scoped_nsobject<CardStackLayoutManager> stack( | 1430 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
1462 newStackOfNCards(kCardCount, boolValues[i])); | |
1463 | 1431 |
1464 const float kEndLimit = | 1432 const float kEndLimit = |
1465 kDefaultEndLimitFraction * [stack fannedStackLength]; | 1433 kDefaultEndLimitFraction * [stack fannedStackLength]; |
1466 const float kPinchDistance = 50; | 1434 const float kPinchDistance = 50; |
1467 [stack setEndLimit:kEndLimit]; | 1435 [stack setEndLimit:kEndLimit]; |
1468 [stack fanOutCardsWithStartIndex:0]; | 1436 [stack fanOutCardsWithStartIndex:0]; |
1469 | 1437 |
1470 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1)); | 1438 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1)); |
1471 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 1439 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
1472 | 1440 |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1510 decayOnOverscroll:YES | 1478 decayOnOverscroll:YES |
1511 scrollLeadingCards:YES]; | 1479 scrollLeadingCards:YES]; |
1512 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2)); | 1480 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 1, 2)); |
1513 } | 1481 } |
1514 } | 1482 } |
1515 | 1483 |
1516 TEST_F(CardStackLayoutManagerTest, ScrollAroundEndStackAfterMultitouch) { | 1484 TEST_F(CardStackLayoutManagerTest, ScrollAroundEndStackAfterMultitouch) { |
1517 BOOL boolValues[2] = {NO, YES}; | 1485 BOOL boolValues[2] = {NO, YES}; |
1518 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 1486 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
1519 const unsigned int kCardCount = 7; | 1487 const unsigned int kCardCount = 7; |
1520 base::scoped_nsobject<CardStackLayoutManager> stack( | 1488 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
1521 newStackOfNCards(kCardCount, boolValues[i])); | |
1522 | 1489 |
1523 const float kEndLimit = 0.3 * [stack fannedStackLength]; | 1490 const float kEndLimit = 0.3 * [stack fannedStackLength]; |
1524 const float kPinchDistance = 20; | 1491 const float kPinchDistance = 20; |
1525 [stack setEndLimit:kEndLimit]; | 1492 [stack setEndLimit:kEndLimit]; |
1526 // Start in the middle of the stack to be able to scroll cards into the end | 1493 // Start in the middle of the stack to be able to scroll cards into the end |
1527 // stack. | 1494 // stack. |
1528 [stack fanOutCardsWithStartIndex:4]; | 1495 [stack fanOutCardsWithStartIndex:4]; |
1529 | 1496 |
1530 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 5, 6)); | 1497 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 5, 6)); |
1531 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 1498 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1571 decayOnOverscroll:YES | 1538 decayOnOverscroll:YES |
1572 scrollLeadingCards:YES]; | 1539 scrollLeadingCards:YES]; |
1573 EXPECT_FLOAT_EQ(SeparationOnLayoutAxis(stack, 5, 6), kMaxStagger); | 1540 EXPECT_FLOAT_EQ(SeparationOnLayoutAxis(stack, 5, 6), kMaxStagger); |
1574 } | 1541 } |
1575 } | 1542 } |
1576 | 1543 |
1577 TEST_F(CardStackLayoutManagerTest, ScrollAfterPinchOutOfStartStack) { | 1544 TEST_F(CardStackLayoutManagerTest, ScrollAfterPinchOutOfStartStack) { |
1578 BOOL boolValues[2] = {NO, YES}; | 1545 BOOL boolValues[2] = {NO, YES}; |
1579 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 1546 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
1580 const unsigned int kCardCount = 3; | 1547 const unsigned int kCardCount = 3; |
1581 base::scoped_nsobject<CardStackLayoutManager> stack( | 1548 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
1582 newStackOfNCards(kCardCount, boolValues[i])); | |
1583 | 1549 |
1584 const float kEndLimit = | 1550 const float kEndLimit = |
1585 kDefaultEndLimitFraction * [stack fannedStackLength]; | 1551 kDefaultEndLimitFraction * [stack fannedStackLength]; |
1586 const float kPinchDistance = 50; | 1552 const float kPinchDistance = 50; |
1587 [stack setEndLimit:kEndLimit]; | 1553 [stack setEndLimit:kEndLimit]; |
1588 [stack fanOutCardsWithStartIndex:0]; | 1554 [stack fanOutCardsWithStartIndex:0]; |
1589 | 1555 |
1590 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1)); | 1556 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 0, 1)); |
1591 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 1557 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
1592 | 1558 |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1641 ValidateCardPositioningConstraints(stack, kEndLimit, false); | 1607 ValidateCardPositioningConstraints(stack, kEndLimit, false); |
1642 EXPECT_FLOAT_EQ(inStackSeparation + kMaxStagger, | 1608 EXPECT_FLOAT_EQ(inStackSeparation + kMaxStagger, |
1643 SeparationOnLayoutAxis(stack, 1, 2)); | 1609 SeparationOnLayoutAxis(stack, 1, 2)); |
1644 } | 1610 } |
1645 } | 1611 } |
1646 | 1612 |
1647 TEST_F(CardStackLayoutManagerTest, ScrollAfterPinchOutOfEndStack) { | 1613 TEST_F(CardStackLayoutManagerTest, ScrollAfterPinchOutOfEndStack) { |
1648 BOOL boolValues[2] = {NO, YES}; | 1614 BOOL boolValues[2] = {NO, YES}; |
1649 for (unsigned long i = 0; i < arraysize(boolValues); i++) { | 1615 for (unsigned long i = 0; i < arraysize(boolValues); i++) { |
1650 const unsigned int kCardCount = 7; | 1616 const unsigned int kCardCount = 7; |
1651 base::scoped_nsobject<CardStackLayoutManager> stack( | 1617 CardStackLayoutManager* stack = newStackOfNCards(kCardCount, boolValues[i]); |
1652 newStackOfNCards(kCardCount, boolValues[i])); | |
1653 | 1618 |
1654 const float kEndLimit = 0.3 * [stack fannedStackLength]; | 1619 const float kEndLimit = 0.3 * [stack fannedStackLength]; |
1655 const float kPinchDistance = 20; | 1620 const float kPinchDistance = 20; |
1656 [stack setEndLimit:kEndLimit]; | 1621 [stack setEndLimit:kEndLimit]; |
1657 // Start in the middle of the stack to be able to scroll cards into the end | 1622 // Start in the middle of the stack to be able to scroll cards into the end |
1658 // stack. | 1623 // stack. |
1659 [stack fanOutCardsWithStartIndex:4]; | 1624 [stack fanOutCardsWithStartIndex:4]; |
1660 | 1625 |
1661 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 5, 6)); | 1626 EXPECT_FLOAT_EQ(kMaxStagger, SeparationOnLayoutAxis(stack, 5, 6)); |
1662 ValidateCardPositioningConstraints(stack, kEndLimit, true); | 1627 ValidateCardPositioningConstraints(stack, kEndLimit, true); |
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1716 decayOnOverscroll:YES | 1681 decayOnOverscroll:YES |
1717 scrollLeadingCards:YES]; | 1682 scrollLeadingCards:YES]; |
1718 ValidateCardPositioningConstraints(stack, kEndLimit, false); | 1683 ValidateCardPositioningConstraints(stack, kEndLimit, false); |
1719 EXPECT_EQ(7, [stack firstEndStackCardIndex]); | 1684 EXPECT_EQ(7, [stack firstEndStackCardIndex]); |
1720 EXPECT_FLOAT_EQ(inStackSeparation + 2 * kMaxStagger, | 1685 EXPECT_FLOAT_EQ(inStackSeparation + 2 * kMaxStagger, |
1721 SeparationOnLayoutAxis(stack, 5, 6)); | 1686 SeparationOnLayoutAxis(stack, 5, 6)); |
1722 } | 1687 } |
1723 } | 1688 } |
1724 | 1689 |
1725 } // namespace | 1690 } // namespace |
OLD | NEW |