1/* 2 * Copyright (C) 2017 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17package android.support.v17.leanback.widget; 18 19import static junit.framework.Assert.assertEquals; 20import static junit.framework.Assert.assertFalse; 21import static junit.framework.Assert.assertTrue; 22 23import android.content.Context; 24import android.graphics.Color; 25import android.graphics.drawable.ColorDrawable; 26import android.graphics.drawable.Drawable; 27import android.os.Build; 28import android.support.test.InstrumentationRegistry; 29import android.support.test.filters.SmallTest; 30import android.support.test.runner.AndroidJUnit4; 31import android.support.v17.leanback.R; 32import android.support.v4.view.ViewCompat; 33import android.view.View; 34import android.view.ViewGroup; 35import android.widget.FrameLayout; 36 37import org.junit.Test; 38import org.junit.runner.RunWith; 39 40@RunWith(AndroidJUnit4.class) 41@SmallTest 42public class ListRowPresenterTest { 43 44 static final float DELTA = 1f; 45 // default overlay color when setSelectLevel(0.5f) 46 static final int HALF_OVERLAY_COLOR = 0x4C000000; 47 static int sFocusedZ; 48 49 static class DummyPresenter extends Presenter { 50 @Override 51 public ViewHolder onCreateViewHolder(ViewGroup parent) { 52 View view = new View(parent.getContext()); 53 view.setFocusable(true); 54 view.setId(R.id.lb_action_button); 55 view.setLayoutParams(new ViewGroup.LayoutParams(100, 100)); 56 return new Presenter.ViewHolder(view); 57 } 58 59 @Override 60 public void onBindViewHolder(ViewHolder viewHolder, Object item) { 61 } 62 63 @Override 64 public void onUnbindViewHolder(ViewHolder viewHolder) { 65 } 66 } 67 68 Context mContext = InstrumentationRegistry.getInstrumentation().getTargetContext(); 69 ListRowPresenter mListRowPresenter; 70 ListRow mRow; 71 ListRowPresenter.ViewHolder mListVh; 72 73 void setup(ListRowPresenter listRowPresenter, ObjectAdapter adapter) { 74 sFocusedZ = mContext.getResources().getDimensionPixelSize( 75 R.dimen.lb_material_shadow_focused_z); 76 assertTrue(sFocusedZ > 0); 77 mListRowPresenter = listRowPresenter; 78 mRow = new ListRow(adapter); 79 InstrumentationRegistry.getInstrumentation().runOnMainSync(new Runnable() { 80 @Override 81 public void run() { 82 final ViewGroup parent = new FrameLayout(mContext); 83 Presenter.ViewHolder containerVh = mListRowPresenter.onCreateViewHolder(parent); 84 parent.addView(containerVh.view, 1000, 1000); 85 mListVh = (ListRowPresenter.ViewHolder) mListRowPresenter.getRowViewHolder( 86 containerVh); 87 mListRowPresenter.onBindViewHolder(mListVh, mRow); 88 runRecyclerViewLayout(); 89 } 90 }); 91 } 92 93 void runRecyclerViewLayout() { 94 mListVh.view.measure(View.MeasureSpec.makeMeasureSpec(1000, View.MeasureSpec.EXACTLY), 95 View.MeasureSpec.makeMeasureSpec(1000, View.MeasureSpec.EXACTLY)); 96 mListVh.view.layout(0, 0, 1000, 1000); 97 } 98 99 static void assertChildrenHaveAlpha(ViewGroup group, int numChildren, float alpha) { 100 assertEquals(numChildren, group.getChildCount()); 101 for (int i = 0; i < numChildren; i++) { 102 assertEquals(alpha, group.getChildAt(i).getAlpha()); 103 } 104 } 105 106 static Drawable getForeground(View view) { 107 if (Build.VERSION.SDK_INT >= 23) { 108 return view.getForeground(); 109 } 110 return null; 111 } 112 113 static void assertChildrenHaveColorOverlay(ViewGroup group, int numChildren, int overlayColor, 114 boolean keepChildForeground) { 115 assertEquals(numChildren, group.getChildCount()); 116 for (int i = 0; i < numChildren; i++) { 117 View view = group.getChildAt(i); 118 if (keepChildForeground) { 119 assertTrue("When keepChildForeground, always create a" 120 + " ShadowOverlayContainer", view instanceof ShadowOverlayContainer); 121 assertEquals(overlayColor, ((ShadowOverlayContainer) view).mOverlayColor); 122 } else { 123 if (view instanceof ShadowOverlayContainer) { 124 assertEquals(overlayColor, ((ShadowOverlayContainer) view).mOverlayColor); 125 } else { 126 Drawable foreground = getForeground(view); 127 assertEquals(overlayColor, 128 foreground instanceof ColorDrawable 129 ? ((ColorDrawable) foreground).getColor() : Color.TRANSPARENT); 130 } 131 } 132 } 133 } 134 135 public void defaultListRowOverlayColor(ListRowPresenter listRowPresenter) { 136 final ArrayObjectAdapter arrayAdapter = new ArrayObjectAdapter(new DummyPresenter()); 137 arrayAdapter.add("abc"); 138 setup(listRowPresenter, arrayAdapter); 139 InstrumentationRegistry.getInstrumentation().runOnMainSync(new Runnable() { 140 @Override 141 public void run() { 142 mListVh.getGridView().setItemAnimator(null); 143 mListRowPresenter.setSelectLevel(mListVh, 0.5f); 144 } 145 }); 146 boolean keepChildForeground = listRowPresenter.isKeepChildForeground(); 147 assertChildrenHaveColorOverlay(mListVh.getGridView(), 1, HALF_OVERLAY_COLOR, 148 keepChildForeground); 149 InstrumentationRegistry.getInstrumentation().runOnMainSync(new Runnable() { 150 @Override 151 public void run() { 152 arrayAdapter.add("def"); 153 runRecyclerViewLayout(); 154 } 155 }); 156 assertChildrenHaveColorOverlay(mListVh.getGridView(), 2, HALF_OVERLAY_COLOR, 157 keepChildForeground); 158 } 159 160 @Test 161 public void defaultListRowOverlayColor() { 162 defaultListRowOverlayColor(new ListRowPresenter()); 163 } 164 165 @Test 166 public void defaultListRowOverlayColorCombinations() { 167 for (boolean keepChildForeground: new boolean[] {false, true}) { 168 for (boolean isUzingZorder : new boolean[]{false, true}) { 169 for (boolean isUsingDefaultShadow : new boolean[]{false, true}) { 170 for (boolean enableRoundedCorner : new boolean[]{false, true}) { 171 for (boolean shadowEnabled : new boolean[]{false, true}) { 172 final boolean paramIsUsingZorder = isUzingZorder; 173 final boolean paramIsUsingDefaultShadow = isUsingDefaultShadow; 174 ListRowPresenter presenter = new ListRowPresenter() { 175 @Override 176 public boolean isUsingZOrder(Context context) { 177 return paramIsUsingZorder; 178 } 179 180 @Override 181 public boolean isUsingDefaultShadow() { 182 return paramIsUsingDefaultShadow; 183 } 184 }; 185 presenter.setKeepChildForeground(keepChildForeground); 186 presenter.setShadowEnabled(shadowEnabled); 187 presenter.enableChildRoundedCorners(enableRoundedCorner); 188 defaultListRowOverlayColor(presenter); 189 } 190 } 191 } 192 } 193 } 194 } 195 196 static class CustomSelectEffectRowPresenter extends ListRowPresenter { 197 @Override 198 public boolean isUsingDefaultListSelectEffect() { 199 return false; 200 } 201 202 @Override 203 protected void applySelectLevelToChild(ViewHolder rowViewHolder, View childView) { 204 childView.setAlpha(rowViewHolder.getSelectLevel()); 205 } 206 }; 207 208 public void customListRowSelectEffect(ListRowPresenter presenter) { 209 final ArrayObjectAdapter arrayAdapter = new ArrayObjectAdapter(new DummyPresenter()); 210 arrayAdapter.add("abc"); 211 setup(presenter, arrayAdapter); 212 InstrumentationRegistry.getInstrumentation().runOnMainSync(new Runnable() { 213 @Override 214 public void run() { 215 mListVh.getGridView().setItemAnimator(null); 216 mListRowPresenter.setSelectLevel(mListVh, 0.5f); 217 } 218 }); 219 assertChildrenHaveAlpha(mListVh.getGridView(), 1, 0.5f); 220 InstrumentationRegistry.getInstrumentation().runOnMainSync(new Runnable() { 221 @Override 222 public void run() { 223 arrayAdapter.add("def"); 224 runRecyclerViewLayout(); 225 } 226 }); 227 assertChildrenHaveAlpha(mListVh.getGridView(), 2, 0.5f); 228 } 229 230 @Test 231 public void customListRowSelectEffect() { 232 customListRowSelectEffect(new CustomSelectEffectRowPresenter()); 233 } 234 235 @Test 236 public void customListRowSelectEffectCombinations() { 237 for (boolean keepChildForeground: new boolean[] {false, true}) { 238 for (boolean isUzingZorder: new boolean[] {false, true}) { 239 for (boolean isUsingDefaultShadow: new boolean[] {false, true}) { 240 for (boolean enableRoundedCorner : new boolean[]{false, true}) { 241 for (boolean shadowEnabled : new boolean[]{false, true}) { 242 final boolean paramIsUsingZorder = isUzingZorder; 243 final boolean paramIsUsingDefaultShadow = isUsingDefaultShadow; 244 ListRowPresenter presenter = new CustomSelectEffectRowPresenter() { 245 @Override 246 public boolean isUsingZOrder(Context context) { 247 return paramIsUsingZorder; 248 } 249 250 @Override 251 public boolean isUsingDefaultShadow() { 252 return paramIsUsingDefaultShadow; 253 } 254 }; 255 presenter.setKeepChildForeground(keepChildForeground); 256 presenter.setShadowEnabled(shadowEnabled); 257 presenter.enableChildRoundedCorners(enableRoundedCorner); 258 customListRowSelectEffect(presenter); 259 } 260 } 261 } 262 } 263 } 264 } 265 266 static class ShadowOverlayResult { 267 boolean mShadowOverlayContainer; 268 int mShadowOverlayContainerOverlayColor; 269 float mShadowOverlayContainerOverlayZ; 270 boolean mShadowOverlayContainerOpticalBounds; 271 int mViewOverlayColor; 272 float mViewZ; 273 boolean mViewOpticalBounds; 274 void expect(boolean shadowOverlayContainer, int shadowOverlayContainerOverlayColor, 275 float shadowOverlayContainerOverlayZ, boolean shadowOverlayContainerOpticalBounds, 276 int viewOverlayColor, float viewZ, boolean viewOpticalBounds) { 277 assertEquals(this.mShadowOverlayContainer, shadowOverlayContainer); 278 assertEquals(this.mShadowOverlayContainerOverlayColor, 279 shadowOverlayContainerOverlayColor); 280 assertEquals(this.mShadowOverlayContainerOverlayZ, shadowOverlayContainerOverlayZ, 281 DELTA); 282 assertEquals(this.mShadowOverlayContainerOpticalBounds, 283 shadowOverlayContainerOpticalBounds); 284 assertEquals(this.mViewOverlayColor, viewOverlayColor); 285 assertEquals(this.mViewZ, viewZ, DELTA); 286 assertEquals(this.mViewOpticalBounds, viewOpticalBounds); 287 } 288 } 289 290 ShadowOverlayResult setupDefaultPresenterWithSingleElement(final boolean isUsingZorder, 291 final boolean isUsingDefaultShadow, 292 final boolean enableRoundedCorner, 293 final boolean shadowEnabled, 294 final boolean keepChildForeground) { 295 ArrayObjectAdapter adapter = new ArrayObjectAdapter(new DummyPresenter()); 296 adapter.add("abc"); 297 ListRowPresenter listRowPresenter = new ListRowPresenter() { 298 @Override 299 public boolean isUsingZOrder(Context context) { 300 return isUsingZorder; 301 } 302 303 @Override 304 public boolean isUsingDefaultShadow() { 305 return isUsingDefaultShadow; 306 } 307 }; 308 listRowPresenter.setShadowEnabled(shadowEnabled); 309 listRowPresenter.enableChildRoundedCorners(enableRoundedCorner); 310 listRowPresenter.setKeepChildForeground(keepChildForeground); 311 setup(listRowPresenter, adapter); 312 InstrumentationRegistry.getInstrumentation().runOnMainSync(new Runnable() { 313 @Override 314 public void run() { 315 mListVh.getGridView().setItemAnimator(null); 316 mListRowPresenter.setSelectLevel(mListVh, 0.5f); 317 View child = mListVh.getGridView().getChildAt(0); 318 FocusHighlightHelper.FocusAnimator animator = (FocusHighlightHelper.FocusAnimator) 319 child.getTag(R.id.lb_focus_animator); 320 animator.animateFocus(true, true); 321 } 322 }); 323 return collectResult(); 324 } 325 326 ShadowOverlayResult collectResult() { 327 ShadowOverlayResult result = new ShadowOverlayResult(); 328 View view = mListVh.getGridView().getChildAt(0); 329 if (view instanceof ShadowOverlayContainer) { 330 result.mShadowOverlayContainer = true; 331 result.mShadowOverlayContainerOverlayColor = ((ShadowOverlayContainer) view) 332 .mOverlayColor; 333 result.mShadowOverlayContainerOverlayZ = ViewCompat.getZ(view); 334 result.mShadowOverlayContainerOpticalBounds = view.getWidth() > 100; 335 } else { 336 result.mShadowOverlayContainer = false; 337 } 338 view = view.findViewById(R.id.lb_action_button); 339 Drawable d = getForeground(view); 340 result.mViewOverlayColor = d instanceof ColorDrawable ? ((ColorDrawable) d).getColor() 341 : Color.TRANSPARENT; 342 result.mViewZ = ViewCompat.getZ(view); 343 result.mViewOpticalBounds = view.getWidth() > 100; 344 return result; 345 } 346 347 @Test 348 public void shadowOverlayContainerTest01() { 349 final boolean isUsingZorder = false; 350 final boolean isUsingDefaultShadow = false; 351 final boolean enableRoundedCorner = false; 352 final boolean shadowEnabled = false; 353 final boolean keepChildForeground = false; 354 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 355 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 356 final int version = Build.VERSION.SDK_INT; 357 if (version < 21) { 358 // nothing supported 359 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 360 0, 0, false); 361 } else if (version < 23) { 362 // supports static/dynamic shadow, supports rounded corner 363 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 364 0, 0, false); 365 } else { 366 // supports foreground 367 result.expect(false, 0, 0, false, 368 HALF_OVERLAY_COLOR, 0, false); 369 } 370 } 371 372 @Test 373 public void shadowOverlayContainerTest02() { 374 final boolean isUsingZorder = false; 375 final boolean isUsingDefaultShadow = false; 376 final boolean enableRoundedCorner = false; 377 final boolean shadowEnabled = false; 378 final boolean keepChildForeground = true; 379 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 380 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 381 final int version = Build.VERSION.SDK_INT; 382 if (version < 21) { 383 // nothing supported 384 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 385 0, 0, false); 386 } else if (version < 23) { 387 // supports static/dynamic shadow, supports rounded corner 388 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 389 0, 0, false); 390 } else { 391 // supports foreground 392 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 393 0, 0, false); 394 } 395 } 396 397 @Test 398 public void shadowOverlayContainerTest03() { 399 final boolean isUsingZorder = false; 400 final boolean isUsingDefaultShadow = false; 401 final boolean enableRoundedCorner = false; 402 final boolean shadowEnabled = true; 403 final boolean keepChildForeground = false; 404 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 405 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 406 final int version = Build.VERSION.SDK_INT; 407 if (version < 21) { 408 // nothing supported 409 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 410 0, 0, false); 411 } else if (version < 23) { 412 // supports static/dynamic shadow, supports rounded corner 413 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 414 0, 0, false); 415 } else { 416 // supports foreground 417 result.expect(false, 0, 0, false, 418 HALF_OVERLAY_COLOR, 0, false); 419 } 420 } 421 422 @Test 423 public void shadowOverlayContainerTest04() { 424 final boolean isUsingZorder = false; 425 final boolean isUsingDefaultShadow = false; 426 final boolean enableRoundedCorner = false; 427 final boolean shadowEnabled = true; 428 final boolean keepChildForeground = true; 429 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 430 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 431 final int version = Build.VERSION.SDK_INT; 432 if (version < 21) { 433 // nothing supported 434 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 435 0, 0, false); 436 } else if (version < 23) { 437 // supports static/dynamic shadow, supports rounded corner 438 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 439 0, 0, false); 440 } else { 441 // supports foreground 442 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 443 0, 0, false); 444 } 445 } 446 447 @Test 448 public void shadowOverlayContainerTest05() { 449 final boolean isUsingZorder = false; 450 final boolean isUsingDefaultShadow = false; 451 final boolean enableRoundedCorner = true; 452 final boolean shadowEnabled = false; 453 final boolean keepChildForeground = false; 454 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 455 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 456 final int version = Build.VERSION.SDK_INT; 457 if (version < 21) { 458 // nothing supported 459 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 460 0, 0, false); 461 } else if (version < 23) { 462 // supports static/dynamic shadow, supports rounded corner 463 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 464 0, 0, false); 465 } else { 466 // supports foreground 467 result.expect(false, 0, 0, false, 468 HALF_OVERLAY_COLOR, 0, false); 469 } 470 } 471 472 @Test 473 public void shadowOverlayContainerTest06() { 474 final boolean isUsingZorder = false; 475 final boolean isUsingDefaultShadow = false; 476 final boolean enableRoundedCorner = true; 477 final boolean shadowEnabled = false; 478 final boolean keepChildForeground = true; 479 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 480 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 481 final int version = Build.VERSION.SDK_INT; 482 if (version < 21) { 483 // nothing supported 484 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 485 0, 0, false); 486 } else if (version < 23) { 487 // supports static/dynamic shadow, supports rounded corner 488 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 489 0, 0, false); 490 } else { 491 // supports foreground 492 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 493 0, 0, false); 494 } 495 } 496 497 @Test 498 public void shadowOverlayContainerTest07() { 499 final boolean isUsingZorder = false; 500 final boolean isUsingDefaultShadow = false; 501 final boolean enableRoundedCorner = true; 502 final boolean shadowEnabled = true; 503 final boolean keepChildForeground = false; 504 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 505 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 506 final int version = Build.VERSION.SDK_INT; 507 if (version < 21) { 508 // nothing supported 509 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 510 0, 0, false); 511 } else if (version < 23) { 512 // supports static/dynamic shadow, supports rounded corner 513 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 514 0, 0, false); 515 } else { 516 // supports foreground 517 result.expect(false, 0, 0, false, 518 HALF_OVERLAY_COLOR, 0, false); 519 } 520 } 521 522 @Test 523 public void shadowOverlayContainerTest08() { 524 final boolean isUsingZorder = false; 525 final boolean isUsingDefaultShadow = false; 526 final boolean enableRoundedCorner = true; 527 final boolean shadowEnabled = true; 528 final boolean keepChildForeground = true; 529 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 530 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 531 final int version = Build.VERSION.SDK_INT; 532 if (version < 21) { 533 // nothing supported 534 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 535 0, 0, false); 536 } else if (version < 23) { 537 // supports static/dynamic shadow, supports rounded corner 538 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 539 0, 0, false); 540 } else { 541 // supports foreground 542 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 543 0, 0, false); 544 } 545 } 546 547 @Test 548 public void shadowOverlayContainerTest09() { 549 final boolean isUsingZorder = false; 550 final boolean isUsingDefaultShadow = true; 551 final boolean enableRoundedCorner = false; 552 final boolean shadowEnabled = false; 553 final boolean keepChildForeground = false; 554 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 555 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 556 final int version = Build.VERSION.SDK_INT; 557 if (version < 21) { 558 // nothing supported 559 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 560 0, 0, false); 561 } else if (version < 23) { 562 // supports static/dynamic shadow, supports rounded corner 563 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 564 0, 0, false); 565 } else { 566 // supports foreground 567 result.expect(false, 0, 0, false, 568 HALF_OVERLAY_COLOR, 0, false); 569 } 570 } 571 572 @Test 573 public void shadowOverlayContainerTest10() { 574 final boolean isUsingZorder = false; 575 final boolean isUsingDefaultShadow = true; 576 final boolean enableRoundedCorner = false; 577 final boolean shadowEnabled = false; 578 final boolean keepChildForeground = true; 579 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 580 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 581 final int version = Build.VERSION.SDK_INT; 582 if (version < 21) { 583 // nothing supported 584 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 585 0, 0, false); 586 } else if (version < 23) { 587 // supports static/dynamic shadow, supports rounded corner 588 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 589 0, 0, false); 590 } else { 591 // supports foreground 592 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 593 0, 0, false); 594 } 595 } 596 597 @Test 598 public void shadowOverlayContainerTest11() { 599 final boolean isUsingZorder = false; 600 final boolean isUsingDefaultShadow = true; 601 final boolean enableRoundedCorner = false; 602 final boolean shadowEnabled = true; 603 final boolean keepChildForeground = false; 604 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 605 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 606 final int version = Build.VERSION.SDK_INT; 607 if (version < 21) { 608 // nothing supported 609 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 610 0, 0, false); 611 } else if (version < 23) { 612 // supports static/dynamic shadow, supports rounded corner 613 result.expect(true, HALF_OVERLAY_COLOR, 0, true, 614 0, 0, false); 615 } else { 616 // supports foreground 617 result.expect(true, HALF_OVERLAY_COLOR, 0, true, 618 0, 0, false); 619 } 620 } 621 622 @Test 623 public void shadowOverlayContainerTest12() { 624 final boolean isUsingZorder = false; 625 final boolean isUsingDefaultShadow = true; 626 final boolean enableRoundedCorner = false; 627 final boolean shadowEnabled = true; 628 final boolean keepChildForeground = true; 629 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 630 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 631 final int version = Build.VERSION.SDK_INT; 632 if (version < 21) { 633 // nothing supported 634 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 635 0, 0, false); 636 } else if (version < 23) { 637 // supports static/dynamic shadow, supports rounded corner 638 result.expect(true, HALF_OVERLAY_COLOR, 0, true, 639 0, 0, false); 640 } else { 641 // supports foreground 642 result.expect(true, HALF_OVERLAY_COLOR, 0, true, 643 0, 0, false); 644 } 645 } 646 647 @Test 648 public void shadowOverlayContainerTest13() { 649 final boolean isUsingZorder = false; 650 final boolean isUsingDefaultShadow = true; 651 final boolean enableRoundedCorner = true; 652 final boolean shadowEnabled = false; 653 final boolean keepChildForeground = false; 654 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 655 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 656 final int version = Build.VERSION.SDK_INT; 657 if (version < 21) { 658 // nothing supported 659 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 660 0, 0, false); 661 } else if (version < 23) { 662 // supports static/dynamic shadow, supports rounded corner 663 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 664 0, 0, false); 665 } else { 666 // supports foreground 667 result.expect(false, 0, 0, false, 668 HALF_OVERLAY_COLOR, 0, false); 669 } 670 } 671 672 @Test 673 public void shadowOverlayContainerTest14() { 674 final boolean isUsingZorder = false; 675 final boolean isUsingDefaultShadow = true; 676 final boolean enableRoundedCorner = true; 677 final boolean shadowEnabled = false; 678 final boolean keepChildForeground = true; 679 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 680 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 681 final int version = Build.VERSION.SDK_INT; 682 if (version < 21) { 683 // nothing supported 684 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 685 0, 0, false); 686 } else if (version < 23) { 687 // supports static/dynamic shadow, supports rounded corner 688 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 689 0, 0, false); 690 } else { 691 // supports foreground 692 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 693 0, 0, false); 694 } 695 } 696 697 @Test 698 public void shadowOverlayContainerTest15() { 699 final boolean isUsingZorder = false; 700 final boolean isUsingDefaultShadow = true; 701 final boolean enableRoundedCorner = true; 702 final boolean shadowEnabled = true; 703 final boolean keepChildForeground = false; 704 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 705 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 706 final int version = Build.VERSION.SDK_INT; 707 if (version < 21) { 708 // nothing supported 709 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 710 0, 0, false); 711 } else if (version < 23) { 712 // supports static/dynamic shadow, supports rounded corner 713 result.expect(true, HALF_OVERLAY_COLOR, 0, true, 714 0, 0, false); 715 } else { 716 // supports foreground 717 result.expect(true, HALF_OVERLAY_COLOR, 0, true, 718 0, 0, false); 719 } 720 } 721 722 @Test 723 public void shadowOverlayContainerTest16() { 724 final boolean isUsingZorder = false; 725 final boolean isUsingDefaultShadow = true; 726 final boolean enableRoundedCorner = true; 727 final boolean shadowEnabled = true; 728 final boolean keepChildForeground = true; 729 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 730 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 731 final int version = Build.VERSION.SDK_INT; 732 if (version < 21) { 733 // nothing supported 734 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 735 0, 0, false); 736 } else if (version < 23) { 737 // supports static/dynamic shadow, supports rounded corner 738 result.expect(true, HALF_OVERLAY_COLOR, 0, true, 739 0, 0, false); 740 } else { 741 // supports foreground 742 result.expect(true, HALF_OVERLAY_COLOR, 0, true, 743 0, 0, false); 744 } 745 } 746 747 @Test 748 public void shadowOverlayContainerTest17() { 749 final boolean isUsingZorder = true; 750 final boolean isUsingDefaultShadow = false; 751 final boolean enableRoundedCorner = false; 752 final boolean shadowEnabled = false; 753 final boolean keepChildForeground = false; 754 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 755 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 756 final int version = Build.VERSION.SDK_INT; 757 if (version < 21) { 758 // nothing supported 759 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 760 0, 0, false); 761 } else if (version < 23) { 762 // supports static/dynamic shadow, supports rounded corner 763 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 764 0, 0, false); 765 } else { 766 // supports foreground 767 result.expect(false, 0, 0, false, 768 HALF_OVERLAY_COLOR, 0, false); 769 } 770 } 771 772 @Test 773 public void shadowOverlayContainerTest18() { 774 final boolean isUsingZorder = true; 775 final boolean isUsingDefaultShadow = false; 776 final boolean enableRoundedCorner = false; 777 final boolean shadowEnabled = false; 778 final boolean keepChildForeground = true; 779 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 780 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 781 final int version = Build.VERSION.SDK_INT; 782 if (version < 21) { 783 // nothing supported 784 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 785 0, 0, false); 786 } else if (version < 23) { 787 // supports static/dynamic shadow, supports rounded corner 788 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 789 0, 0, false); 790 } else { 791 // supports foreground 792 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 793 0, 0, false); 794 } 795 } 796 797 @Test 798 public void shadowOverlayContainerTest19() { 799 final boolean isUsingZorder = true; 800 final boolean isUsingDefaultShadow = false; 801 final boolean enableRoundedCorner = false; 802 final boolean shadowEnabled = true; 803 final boolean keepChildForeground = false; 804 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 805 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 806 final int version = Build.VERSION.SDK_INT; 807 if (version < 21) { 808 // nothing supported 809 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 810 0, 0, false); 811 } else if (version < 23) { 812 // supports static/dynamic shadow, supports rounded corner 813 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 814 0, 0, false); 815 } else { 816 // supports foreground 817 result.expect(false, 0, 0, false, 818 HALF_OVERLAY_COLOR, 0, false); 819 } 820 } 821 822 @Test 823 public void shadowOverlayContainerTest20() { 824 final boolean isUsingZorder = true; 825 final boolean isUsingDefaultShadow = false; 826 final boolean enableRoundedCorner = false; 827 final boolean shadowEnabled = true; 828 final boolean keepChildForeground = true; 829 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 830 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 831 final int version = Build.VERSION.SDK_INT; 832 if (version < 21) { 833 // nothing supported 834 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 835 0, 0, false); 836 } else if (version < 23) { 837 // supports static/dynamic shadow, supports rounded corner 838 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 839 0, 0, false); 840 } else { 841 // supports foreground 842 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 843 0, 0, false); 844 } 845 } 846 847 @Test 848 public void shadowOverlayContainerTest21() { 849 final boolean isUsingZorder = true; 850 final boolean isUsingDefaultShadow = false; 851 final boolean enableRoundedCorner = true; 852 final boolean shadowEnabled = false; 853 final boolean keepChildForeground = false; 854 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 855 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 856 final int version = Build.VERSION.SDK_INT; 857 if (version < 21) { 858 // nothing supported 859 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 860 0, 0, false); 861 } else if (version < 23) { 862 // supports static/dynamic shadow, supports rounded corner 863 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 864 0, 0, false); 865 } else { 866 // supports foreground 867 result.expect(false, 0, 0, false, 868 HALF_OVERLAY_COLOR, 0, false); 869 } 870 } 871 872 @Test 873 public void shadowOverlayContainerTest22() { 874 final boolean isUsingZorder = true; 875 final boolean isUsingDefaultShadow = false; 876 final boolean enableRoundedCorner = true; 877 final boolean shadowEnabled = false; 878 final boolean keepChildForeground = true; 879 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 880 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 881 final int version = Build.VERSION.SDK_INT; 882 if (version < 21) { 883 // nothing supported 884 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 885 0, 0, false); 886 } else if (version < 23) { 887 // supports static/dynamic shadow, supports rounded corner 888 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 889 0, 0, false); 890 } else { 891 // supports foreground 892 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 893 0, 0, false); 894 } 895 } 896 897 @Test 898 public void shadowOverlayContainerTest23() { 899 final boolean isUsingZorder = true; 900 final boolean isUsingDefaultShadow = false; 901 final boolean enableRoundedCorner = true; 902 final boolean shadowEnabled = true; 903 final boolean keepChildForeground = false; 904 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 905 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 906 final int version = Build.VERSION.SDK_INT; 907 if (version < 21) { 908 // nothing supported 909 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 910 0, 0, false); 911 } else if (version < 23) { 912 // supports static/dynamic shadow, supports rounded corner 913 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 914 0, 0, false); 915 } else { 916 // supports foreground 917 result.expect(false, 0, 0, false, 918 HALF_OVERLAY_COLOR, 0, false); 919 } 920 } 921 922 @Test 923 public void shadowOverlayContainerTest24() { 924 final boolean isUsingZorder = true; 925 final boolean isUsingDefaultShadow = false; 926 final boolean enableRoundedCorner = true; 927 final boolean shadowEnabled = true; 928 final boolean keepChildForeground = true; 929 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 930 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 931 final int version = Build.VERSION.SDK_INT; 932 if (version < 21) { 933 // nothing supported 934 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 935 0, 0, false); 936 } else if (version < 23) { 937 // supports static/dynamic shadow, supports rounded corner 938 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 939 0, 0, false); 940 } else { 941 // supports foreground 942 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 943 0, 0, false); 944 } 945 } 946 947 @Test 948 public void shadowOverlayContainerTest25() { 949 final boolean isUsingZorder = true; 950 final boolean isUsingDefaultShadow = true; 951 final boolean enableRoundedCorner = false; 952 final boolean shadowEnabled = false; 953 final boolean keepChildForeground = false; 954 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 955 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 956 final int version = Build.VERSION.SDK_INT; 957 if (version < 21) { 958 // nothing supported 959 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 960 0, 0, false); 961 } else if (version < 23) { 962 // supports static/dynamic shadow, supports rounded corner 963 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 964 0, 0, false); 965 } else { 966 // supports foreground 967 result.expect(false, 0, 0, false, 968 HALF_OVERLAY_COLOR, 0, false); 969 } 970 } 971 972 @Test 973 public void shadowOverlayContainerTest26() { 974 final boolean isUsingZorder = true; 975 final boolean isUsingDefaultShadow = true; 976 final boolean enableRoundedCorner = false; 977 final boolean shadowEnabled = false; 978 final boolean keepChildForeground = true; 979 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 980 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 981 final int version = Build.VERSION.SDK_INT; 982 if (version < 21) { 983 // nothing supported 984 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 985 0, 0, false); 986 } else if (version < 23) { 987 // supports static/dynamic shadow, supports rounded corner 988 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 989 0, 0, false); 990 } else { 991 // supports foreground 992 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 993 0, 0, false); 994 } 995 } 996 997 @Test 998 public void shadowOverlayContainerTest27() { 999 final boolean isUsingZorder = true; 1000 final boolean isUsingDefaultShadow = true; 1001 final boolean enableRoundedCorner = false; 1002 final boolean shadowEnabled = true; 1003 final boolean keepChildForeground = false; 1004 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 1005 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 1006 final int version = Build.VERSION.SDK_INT; 1007 if (version < 21) { 1008 // nothing supported 1009 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 1010 0, 0, false); 1011 } else if (version < 23) { 1012 // supports static/dynamic shadow, supports rounded corner 1013 result.expect(true, HALF_OVERLAY_COLOR, sFocusedZ, false, 1014 0, 0, false); 1015 } else { 1016 // supports foreground 1017 result.expect(false, 0, 0, false, 1018 HALF_OVERLAY_COLOR, sFocusedZ, false); 1019 } 1020 } 1021 1022 @Test 1023 public void shadowOverlayContainerTest28() { 1024 final boolean isUsingZorder = true; 1025 final boolean isUsingDefaultShadow = true; 1026 final boolean enableRoundedCorner = false; 1027 final boolean shadowEnabled = true; 1028 final boolean keepChildForeground = true; 1029 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 1030 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 1031 final int version = Build.VERSION.SDK_INT; 1032 if (version < 21) { 1033 // nothing supported 1034 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 1035 0, 0, false); 1036 } else if (version < 23) { 1037 // supports static/dynamic shadow, supports rounded corner 1038 result.expect(true, HALF_OVERLAY_COLOR, sFocusedZ, false, 1039 0, 0, false); 1040 } else { 1041 // supports foreground 1042 result.expect(true, HALF_OVERLAY_COLOR, sFocusedZ, false, 1043 0, 0, false); 1044 } 1045 } 1046 1047 @Test 1048 public void shadowOverlayContainerTest29() { 1049 final boolean isUsingZorder = true; 1050 final boolean isUsingDefaultShadow = true; 1051 final boolean enableRoundedCorner = true; 1052 final boolean shadowEnabled = false; 1053 final boolean keepChildForeground = false; 1054 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 1055 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 1056 final int version = Build.VERSION.SDK_INT; 1057 if (version < 21) { 1058 // nothing supported 1059 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 1060 0, 0, false); 1061 } else if (version < 23) { 1062 // supports static/dynamic shadow, supports rounded corner 1063 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 1064 0, 0, false); 1065 } else { 1066 // supports foreground 1067 result.expect(false, 0, 0, false, 1068 HALF_OVERLAY_COLOR, 0, false); 1069 } 1070 } 1071 1072 @Test 1073 public void shadowOverlayContainerTest30() { 1074 final boolean isUsingZorder = true; 1075 final boolean isUsingDefaultShadow = true; 1076 final boolean enableRoundedCorner = true; 1077 final boolean shadowEnabled = false; 1078 final boolean keepChildForeground = true; 1079 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 1080 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 1081 final int version = Build.VERSION.SDK_INT; 1082 if (version < 21) { 1083 // nothing supported 1084 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 1085 0, 0, false); 1086 } else if (version < 23) { 1087 // supports static/dynamic shadow, supports rounded corner 1088 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 1089 0, 0, false); 1090 } else { 1091 // supports foreground 1092 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 1093 0, 0, false); 1094 } 1095 } 1096 1097 @Test 1098 public void shadowOverlayContainerTest31() { 1099 final boolean isUsingZorder = true; 1100 final boolean isUsingDefaultShadow = true; 1101 final boolean enableRoundedCorner = true; 1102 final boolean shadowEnabled = true; 1103 final boolean keepChildForeground = false; 1104 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 1105 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 1106 final int version = Build.VERSION.SDK_INT; 1107 if (version < 21) { 1108 // nothing supported 1109 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 1110 0, 0, false); 1111 } else if (version < 23) { 1112 // supports static/dynamic shadow, supports rounded corner 1113 result.expect(true, HALF_OVERLAY_COLOR, sFocusedZ, false, 1114 0, 0, false); 1115 } else { 1116 // supports foreground 1117 result.expect(false, 0, 0, false, 1118 HALF_OVERLAY_COLOR, sFocusedZ, false); 1119 } 1120 } 1121 1122 @Test 1123 public void shadowOverlayContainerTest32() { 1124 final boolean isUsingZorder = true; 1125 final boolean isUsingDefaultShadow = true; 1126 final boolean enableRoundedCorner = true; 1127 final boolean shadowEnabled = true; 1128 final boolean keepChildForeground = true; 1129 ShadowOverlayResult result = setupDefaultPresenterWithSingleElement(isUsingZorder, 1130 isUsingDefaultShadow, enableRoundedCorner, shadowEnabled, keepChildForeground); 1131 final int version = Build.VERSION.SDK_INT; 1132 if (version < 21) { 1133 // nothing supported 1134 result.expect(true, HALF_OVERLAY_COLOR, 0, false, 1135 0, 0, false); 1136 } else if (version < 23) { 1137 // supports static/dynamic shadow, supports rounded corner 1138 result.expect(true, HALF_OVERLAY_COLOR, sFocusedZ, false, 1139 0, 0, false); 1140 } else { 1141 // supports foreground 1142 result.expect(true, HALF_OVERLAY_COLOR, sFocusedZ, false, 1143 0, 0, false); 1144 } 1145 } 1146 1147 @Test 1148 public void shadowOverlayContainerTestDefaultSettings() { 1149 ListRowPresenter presenter = new ListRowPresenter(); 1150 final int version = Build.VERSION.SDK_INT; 1151 if (version < 21) { 1152 assertFalse(presenter.isUsingZOrder(mContext)); 1153 assertFalse(presenter.isUsingDefaultShadow()); 1154 } else { 1155 assertTrue(presenter.isUsingZOrder(mContext)); 1156 assertTrue(presenter.isUsingDefaultShadow()); 1157 } 1158 assertTrue(presenter.areChildRoundedCornersEnabled()); 1159 assertTrue(presenter.getShadowEnabled()); 1160 assertTrue(presenter.isKeepChildForeground()); 1161 } 1162} 1163