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 androidx.leanback.widget;
18
19import static org.junit.Assert.assertEquals;
20import static org.junit.Assert.assertFalse;
21import static org.junit.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.view.View;
32import android.view.ViewGroup;
33import android.widget.FrameLayout;
34
35import androidx.core.view.ViewCompat;
36import androidx.leanback.R;
37
38import org.junit.Test;
39import org.junit.runner.RunWith;
40
41@RunWith(AndroidJUnit4.class)
42@SmallTest
43public 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