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