xref: /frameworks/support/viewpager/src/androidTest/java/androidx/viewpager/widget/BaseViewPagerTest.java

/*
 * Copyright 2018 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package androidx.viewpager.widget;

import static android.support.test.espresso.Espresso.onView;
import static android.support.test.espresso.action.ViewActions.pressKey;
import static android.support.test.espresso.action.ViewActions.swipeLeft;
import static android.support.test.espresso.action.ViewActions.swipeRight;
import static android.support.test.espresso.assertion.PositionAssertions.isBelow;
import static android.support.test.espresso.assertion.PositionAssertions.isBottomAlignedWith;
import static android.support.test.espresso.assertion.PositionAssertions.isLeftAlignedWith;
import static android.support.test.espresso.assertion.PositionAssertions.isRightAlignedWith;
import static android.support.test.espresso.assertion.PositionAssertions.isTopAlignedWith;
import static android.support.test.espresso.assertion.ViewAssertions.doesNotExist;
import static android.support.test.espresso.assertion.ViewAssertions.matches;
import static android.support.test.espresso.matcher.ViewMatchers.hasDescendant;
import static android.support.test.espresso.matcher.ViewMatchers.isDisplayed;
import static android.support.test.espresso.matcher.ViewMatchers.withId;
import static android.support.test.espresso.matcher.ViewMatchers.withText;
import static android.support.v4.testutils.TestUtilsAssertions.hasDisplayedChildren;
import static android.support.v4.testutils.TestUtilsMatchers.backgroundColor;
import static android.support.v4.testutils.TestUtilsMatchers.centerAlignedInParent;
import static android.support.v4.testutils.TestUtilsMatchers.endAlignedToParent;
import static android.support.v4.testutils.TestUtilsMatchers.isOfClass;
import static android.support.v4.testutils.TestUtilsMatchers.startAlignedToParent;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.allOf;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.core.IsNot.not;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.anyInt;
import static org.mockito.Mockito.atLeastOnce;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;

import android.app.Activity;
import android.graphics.Color;
import android.support.test.espresso.ViewAction;
import android.support.test.espresso.action.EspressoKey;
import android.support.test.filters.FlakyTest;
import android.support.test.filters.LargeTest;
import android.support.test.filters.MediumTest;
import android.support.test.rule.ActivityTestRule;
import android.support.v4.testutils.TestUtilsMatchers;
import android.text.TextUtils;
import android.util.Pair;
import android.view.KeyEvent;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.LinearLayout;
import android.widget.TextView;

import androidx.viewpager.test.R;

import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.mockito.ArgumentCaptor;

import java.util.ArrayList;
import java.util.List;

/**
 * Base class for testing <code>ViewPager</code>. Most of the testing logic should be in this
 * class as it is independent on the specific pager title implementation (interactive or non
 * interactive).
 *
 * Testing logic that does depend on the specific pager title implementation is pushed into the
 * extending classes in <code>assertStripInteraction()</code> method.
 */
public abstract class BaseViewPagerTest<T extends Activity> {
    @Rule
    public final ActivityTestRule<T> mActivityTestRule;

    private static final int DIRECTION_LEFT = -1;
    private static final int DIRECTION_RIGHT = 1;
    protected ViewPager mViewPager;

    protected static class BasePagerAdapter<Q> extends PagerAdapter {
        protected ArrayList<Pair<String, Q>> mEntries = new ArrayList<>();

        public void add(String title, Q content) {
            mEntries.add(new Pair<>(title, content));
        }

        @Override
        public int getCount() {
            return mEntries.size();
        }

        protected void configureInstantiatedItem(View view, int position) {
            switch (position) {
                case 0:
                    view.setId(R.id.page_0);
                    break;
                case 1:
                    view.setId(R.id.page_1);
                    break;
                case 2:
                    view.setId(R.id.page_2);
                    break;
                case 3:
                    view.setId(R.id.page_3);
                    break;
                case 4:
                    view.setId(R.id.page_4);
                    break;
                case 5:
                    view.setId(R.id.page_5);
                    break;
                case 6:
                    view.setId(R.id.page_6);
                    break;
                case 7:
                    view.setId(R.id.page_7);
                    break;
                case 8:
                    view.setId(R.id.page_8);
                    break;
                case 9:
                    view.setId(R.id.page_9);
                    break;
            }
        }

        @Override
        public void destroyItem(ViewGroup container, int position, Object object) {
            // The adapter is also responsible for removing the view.
            container.removeView(((ViewHolder) object).view);
        }

        @Override
        public int getItemPosition(Object object) {
            return ((ViewHolder) object).position;
        }

        @Override
        public boolean isViewFromObject(View view, Object object) {
            return ((ViewHolder) object).view == view;
        }

        @Override
        public CharSequence getPageTitle(int position) {
            return mEntries.get(position).first;
        }

        protected static class ViewHolder {
            final View view;
            final int position;

            public ViewHolder(View view, int position) {
                this.view = view;
                this.position = position;
            }
        }
    }

    protected static class ColorPagerAdapter extends BasePagerAdapter<Integer> {
        @Override
        public Object instantiateItem(ViewGroup container, int position) {
            final View view = new View(container.getContext());
            view.setBackgroundColor(mEntries.get(position).second);
            configureInstantiatedItem(view, position);

            // Unlike ListView adapters, the ViewPager adapter is responsible
            // for adding the view to the container.
            container.addView(view);

            return new ViewHolder(view, position);
        }
    }

    protected static class TextPagerAdapter extends BasePagerAdapter<String> {
        @Override
        public Object instantiateItem(ViewGroup container, int position) {
            final TextView view = new TextView(container.getContext());
            view.setText(mEntries.get(position).second);
            configureInstantiatedItem(view, position);

            // Unlike ListView adapters, the ViewPager adapter is responsible
            // for adding the view to the container.
            container.addView(view);

            return new ViewHolder(view, position);
        }
    }

    protected static class ButtonPagerAdapter extends BasePagerAdapter<Integer> {
        private ArrayList<Button[]> mButtons = new ArrayList<>();

        @Override
        public void add(String title, Integer content) {
            super.add(title, content);
            mButtons.add(new Button[3]);
        }

        @Override
        public Object instantiateItem(ViewGroup container, int position) {
            final LinearLayout view = new LinearLayout(container.getContext());
            view.setBackgroundColor(mEntries.get(position).second);
            view.setOrientation(LinearLayout.HORIZONTAL);
            configureInstantiatedItem(view, position);

            for (int i = 0; i < 3; ++i) {
                Button but = new Button(container.getContext());
                but.setText("" + i);
                but.setFocusableInTouchMode(true);
                view.addView(but, ViewGroup.LayoutParams.WRAP_CONTENT,
                        ViewGroup.LayoutParams.WRAP_CONTENT);
                mButtons.get(position)[i] = but;
            }

            // Unlike ListView adapters, the ViewPager adapter is responsible
            // for adding the view to the container.
            container.addView(view);

            return new ViewHolder(view, position);
        }

        public View getButton(int page, int idx) {
            return mButtons.get(page)[idx];
        }
    }

    public BaseViewPagerTest(Class<T> activityClass) {
        mActivityTestRule = new ActivityTestRule<T>(activityClass);
    }

    @Before
    public void setUp() throws Exception {
        final T activity = mActivityTestRule.getActivity();
        mViewPager = (ViewPager) activity.findViewById(R.id.pager);

        ColorPagerAdapter adapter = new ColorPagerAdapter();
        adapter.add("Red", Color.RED);
        adapter.add("Green", Color.GREEN);
        adapter.add("Blue", Color.BLUE);
        onView(withId(R.id.pager)).perform(
                ViewPagerActions.setAdapter(adapter), ViewPagerActions.scrollToPage(0, false));
    }

    @After
    public void tearDown() throws Exception {
        onView(withId(R.id.pager)).perform(ViewPagerActions.setAdapter(null));
    }

    private void verifyPageSelections(boolean smoothScroll) {
        assertEquals("Initial state", 0, mViewPager.getCurrentItem());

        ViewPager.OnPageChangeListener mockPageChangeListener =
                mock(ViewPager.OnPageChangeListener.class);
        mViewPager.addOnPageChangeListener(mockPageChangeListener);

        onView(withId(R.id.pager)).perform(ViewPagerActions.scrollRight(smoothScroll));
        assertEquals("Scroll right", 1, mViewPager.getCurrentItem());
        verify(mockPageChangeListener, times(1)).onPageSelected(1);

        onView(withId(R.id.pager)).perform(ViewPagerActions.scrollRight(smoothScroll));
        assertEquals("Scroll right", 2, mViewPager.getCurrentItem());
        verify(mockPageChangeListener, times(1)).onPageSelected(2);

        // Try "scrolling" beyond the last page and test that we're still on the last page.
        onView(withId(R.id.pager)).perform(ViewPagerActions.scrollRight(smoothScroll));
        assertEquals("Scroll right beyond last page", 2, mViewPager.getCurrentItem());
        // We're still on this page, so we shouldn't have been called again with index 2
        verify(mockPageChangeListener, times(1)).onPageSelected(2);

        onView(withId(R.id.pager)).perform(ViewPagerActions.scrollLeft(smoothScroll));
        assertEquals("Scroll left", 1, mViewPager.getCurrentItem());
        // Verify that this is the second time we're called on index 1
        verify(mockPageChangeListener, times(2)).onPageSelected(1);

        onView(withId(R.id.pager)).perform(ViewPagerActions.scrollLeft(smoothScroll));
        assertEquals("Scroll left", 0, mViewPager.getCurrentItem());
        // Verify that this is the first time we're called on index 0
        verify(mockPageChangeListener, times(1)).onPageSelected(0);

        // Try "scrolling" beyond the first page and test that we're still on the first page.
        onView(withId(R.id.pager)).perform(ViewPagerActions.scrollLeft(smoothScroll));
        assertEquals("Scroll left beyond first page", 0, mViewPager.getCurrentItem());
        // We're still on this page, so we shouldn't have been called again with index 0
        verify(mockPageChangeListener, times(1)).onPageSelected(0);

        // Unregister our listener
        mViewPager.removeOnPageChangeListener(mockPageChangeListener);

        // Go from index 0 to index 2
        onView(withId(R.id.pager)).perform(ViewPagerActions.scrollToPage(2, smoothScroll));
        assertEquals("Scroll to last page", 2, mViewPager.getCurrentItem());
        // Our listener is not registered anymore, so we shouldn't have been called with index 2
        verify(mockPageChangeListener, times(1)).onPageSelected(2);

        // And back to 0
        onView(withId(R.id.pager)).perform(ViewPagerActions.scrollToPage(0, smoothScroll));
        assertEquals("Scroll to first page", 0, mViewPager.getCurrentItem());
        // Our listener is not registered anymore, so we shouldn't have been called with index 0
        verify(mockPageChangeListener, times(1)).onPageSelected(0);

        // Verify the overall sequence of calls to onPageSelected of our listener
        ArgumentCaptor<Integer> pageSelectedCaptor = ArgumentCaptor.forClass(int.class);
        verify(mockPageChangeListener, times(4)).onPageSelected(pageSelectedCaptor.capture());
        assertThat(pageSelectedCaptor.getAllValues(), TestUtilsMatchers.matches(1, 2, 1, 0));
    }

    @Test
    @MediumTest
    public void testPageSelectionsImmediate() {
        verifyPageSelections(false);
    }

    @Test
    @LargeTest
    public void testPageSelectionsSmooth() {
        verifyPageSelections(true);
    }

    private void verifyPageChangeViewActions(ViewAction next, ViewAction previous) {
        assertEquals("Initial state", 0, mViewPager.getCurrentItem());
        assertFalse(mViewPager.canScrollHorizontally(DIRECTION_LEFT));
        assertTrue(mViewPager.canScrollHorizontally(DIRECTION_RIGHT));

        ViewPager.OnPageChangeListener mockPageChangeListener =
                mock(ViewPager.OnPageChangeListener.class);
        mViewPager.addOnPageChangeListener(mockPageChangeListener);

        onView(withId(R.id.pager)).perform(next);
        assertEquals("Move to next page", 1, mViewPager.getCurrentItem());
        verify(mockPageChangeListener, times(1)).onPageSelected(1);
        assertTrue(mViewPager.canScrollHorizontally(DIRECTION_LEFT));
        assertTrue(mViewPager.canScrollHorizontally(DIRECTION_RIGHT));

        onView(withId(R.id.pager)).perform(next);
        assertEquals("Move to next page", 2, mViewPager.getCurrentItem());
        verify(mockPageChangeListener, times(1)).onPageSelected(2);
        assertTrue(mViewPager.canScrollHorizontally(DIRECTION_LEFT));
        assertFalse(mViewPager.canScrollHorizontally(DIRECTION_RIGHT));

        // Try swiping beyond the last page and test that we're still on the last page.
        onView(withId(R.id.pager)).perform(next);
        assertEquals("Attempt to move to next page beyond last page", 2,
                mViewPager.getCurrentItem());
        // We're still on this page, so we shouldn't have been called again with index 2
        verify(mockPageChangeListener, times(1)).onPageSelected(2);
        assertTrue(mViewPager.canScrollHorizontally(DIRECTION_LEFT));
        assertFalse(mViewPager.canScrollHorizontally(DIRECTION_RIGHT));

        onView(withId(R.id.pager)).perform(previous);
        assertEquals("Move to previous page", 1, mViewPager.getCurrentItem());
        // Verify that this is the second time we're called on index 1
        verify(mockPageChangeListener, times(2)).onPageSelected(1);
        assertTrue(mViewPager.canScrollHorizontally(DIRECTION_LEFT));
        assertTrue(mViewPager.canScrollHorizontally(DIRECTION_RIGHT));

        onView(withId(R.id.pager)).perform(previous);
        assertEquals("Move to previous page", 0, mViewPager.getCurrentItem());
        // Verify that this is the first time we're called on index 0
        verify(mockPageChangeListener, times(1)).onPageSelected(0);
        assertFalse(mViewPager.canScrollHorizontally(DIRECTION_LEFT));
        assertTrue(mViewPager.canScrollHorizontally(DIRECTION_RIGHT));

        // Try swiping beyond the first page and test that we're still on the first page.
        onView(withId(R.id.pager)).perform(previous);
        assertEquals("Attempt to move to previous page beyond first page", 0,
                mViewPager.getCurrentItem());
        // We're still on this page, so we shouldn't have been called again with index 0
        verify(mockPageChangeListener, times(1)).onPageSelected(0);
        assertFalse(mViewPager.canScrollHorizontally(DIRECTION_LEFT));
        assertTrue(mViewPager.canScrollHorizontally(DIRECTION_RIGHT));

        mViewPager.removeOnPageChangeListener(mockPageChangeListener);

        // Verify the overall sequence of calls to onPageSelected of our listener
        ArgumentCaptor<Integer> pageSelectedCaptor = ArgumentCaptor.forClass(int.class);
        verify(mockPageChangeListener, times(4)).onPageSelected(pageSelectedCaptor.capture());
        assertThat(pageSelectedCaptor.getAllValues(), TestUtilsMatchers.matches(1, 2, 1, 0));
    }

    @Test
    @LargeTest
    public void testPageSwipes() {
        verifyPageChangeViewActions(ViewPagerActions.wrap(swipeLeft()), ViewPagerActions.wrap(swipeRight()));
    }

    @Test
    @LargeTest
    public void testArrowPageChanges() {
        verifyPageChangeViewActions(
                ViewPagerActions.arrowScroll(View.FOCUS_RIGHT), ViewPagerActions.arrowScroll(View.FOCUS_LEFT));
    }

    @Test
    @LargeTest
    public void testPageSwipesComposite() {
        assertEquals("Initial state", 0, mViewPager.getCurrentItem());

        onView(withId(R.id.pager)).perform(ViewPagerActions.wrap(swipeLeft()), ViewPagerActions.wrap(swipeLeft()));
        assertEquals("Swipe twice left", 2, mViewPager.getCurrentItem());

        onView(withId(R.id.pager)).perform(ViewPagerActions.wrap(swipeLeft()), ViewPagerActions.wrap(swipeRight()));
        assertEquals("Swipe left beyond last page and then right", 1, mViewPager.getCurrentItem());

        onView(withId(R.id.pager)).perform(
                ViewPagerActions.wrap(swipeRight()), ViewPagerActions.wrap(swipeRight()));
        assertEquals("Swipe right and then right beyond first page", 0,
                mViewPager.getCurrentItem());

        onView(withId(R.id.pager)).perform(
                ViewPagerActions.wrap(swipeRight()), ViewPagerActions.wrap(swipeLeft()));
        assertEquals("Swipe right beyond first page and then left", 1, mViewPager.getCurrentItem());
    }

    private void verifyPageContent(boolean smoothScroll) {
        assertEquals("Initial state", 0, mViewPager.getCurrentItem());

        // Verify the displayed content to match the initial adapter - with 3 pages and each
        // one rendered as a View.

        // Page #0 should be displayed, page #1 should not be displayed and page #2 should not exist
        // yet as it's outside of the offscreen window limit.
        onView(withId(R.id.page_0)).check(matches(allOf(
                isOfClass(View.class),
                isDisplayed(),
                backgroundColor(Color.RED))));
        onView(withId(R.id.page_1)).check(matches(not(isDisplayed())));
        onView(withId(R.id.page_2)).check(doesNotExist());

        // Scroll one page to select page #1
        onView(withId(R.id.pager)).perform(ViewPagerActions.scrollRight(smoothScroll));
        assertEquals("Scroll right", 1, mViewPager.getCurrentItem());
        // Pages #0 / #2 should not be displayed, page #1 should be displayed.
        onView(withId(R.id.page_0)).check(matches(not(isDisplayed())));
        onView(withId(R.id.page_1)).check(matches(allOf(
                isOfClass(View.class),
                isDisplayed(),
                backgroundColor(Color.GREEN))));
        onView(withId(R.id.page_2)).check(matches(not(isDisplayed())));

        // Scroll one more page to select page #2
        onView(withId(R.id.pager)).perform(ViewPagerActions.scrollRight(smoothScroll));
        assertEquals("Scroll right again", 2, mViewPager.getCurrentItem());
        // Page #0 should not exist as it's bumped to the outside of the offscreen window limit,
        // page #1 should not be displayed, page #2 should be displayed.
        onView(withId(R.id.page_0)).check(doesNotExist());
        onView(withId(R.id.page_1)).check(matches(not(isDisplayed())));
        onView(withId(R.id.page_2)).check(matches(allOf(
                isOfClass(View.class),
                isDisplayed(),
                backgroundColor(Color.BLUE))));
    }

    @Test
    @MediumTest
    public void testPageContentImmediate() {
        verifyPageContent(false);
    }

    @Test
    @LargeTest
    public void testPageContentSmooth() {
        verifyPageContent(true);
    }

    private void verifyAdapterChange(boolean smoothScroll) {
        // Verify that we have the expected initial adapter
        PagerAdapter initialAdapter = mViewPager.getAdapter();
        assertEquals("Initial adapter class", ColorPagerAdapter.class, initialAdapter.getClass());
        assertEquals("Initial adapter page count", 3, initialAdapter.getCount());

        // Create a new adapter
        TextPagerAdapter newAdapter = new TextPagerAdapter();
        newAdapter.add("Title 0", "Body 0");
        newAdapter.add("Title 1", "Body 1");
        newAdapter.add("Title 2", "Body 2");
        newAdapter.add("Title 3", "Body 3");
        onView(withId(R.id.pager)).perform(
                ViewPagerActions.setAdapter(newAdapter), ViewPagerActions.scrollToPage(0, smoothScroll));

        // Verify the displayed content to match the newly set adapter - with 4 pages and each
        // one rendered as a TextView.

        // Page #0 should be displayed, page #1 should not be displayed and pages #2 / #3 should not
        // exist yet as they're outside of the offscreen window limit.
        onView(withId(R.id.page_0)).check(matches(allOf(
                isOfClass(TextView.class),
                isDisplayed(),
                withText("Body 0"))));
        onView(withId(R.id.page_1)).check(matches(not(isDisplayed())));
        onView(withId(R.id.page_2)).check(doesNotExist());
        onView(withId(R.id.page_3)).check(doesNotExist());

        // Scroll one page to select page #1
        onView(withId(R.id.pager)).perform(ViewPagerActions.scrollRight(smoothScroll));
        assertEquals("Scroll right", 1, mViewPager.getCurrentItem());
        // Pages #0 / #2 should not be displayed, page #1 should be displayed, page #3 is still
        // outside the offscreen limit.
        onView(withId(R.id.page_0)).check(matches(not(isDisplayed())));
        onView(withId(R.id.page_1)).check(matches(allOf(
                isOfClass(TextView.class),
                isDisplayed(),
                withText("Body 1"))));
        onView(withId(R.id.page_2)).check(matches(not(isDisplayed())));
        onView(withId(R.id.page_3)).check(doesNotExist());

        // Scroll one more page to select page #2
        onView(withId(R.id.pager)).perform(ViewPagerActions.scrollRight(smoothScroll));
        assertEquals("Scroll right again", 2, mViewPager.getCurrentItem());
        // Page #0 should not exist as it's bumped to the outside of the offscreen window limit,
        // pages #1 / #3 should not be displayed, page #2 should be displayed.
        onView(withId(R.id.page_0)).check(doesNotExist());
        onView(withId(R.id.page_1)).check(matches(not(isDisplayed())));
        onView(withId(R.id.page_2)).check(matches(allOf(
                isOfClass(TextView.class),
                isDisplayed(),
                withText("Body 2"))));
        onView(withId(R.id.page_3)).check(matches(not(isDisplayed())));

        // Scroll one more page to select page #2
        onView(withId(R.id.pager)).perform(ViewPagerActions.scrollRight(smoothScroll));
        assertEquals("Scroll right one more time", 3, mViewPager.getCurrentItem());
        // Pages #0 / #1 should not exist as they're bumped to the outside of the offscreen window
        // limit, page #2 should not be displayed, page #3 should be displayed.
        onView(withId(R.id.page_0)).check(doesNotExist());
        onView(withId(R.id.page_1)).check(doesNotExist());
        onView(withId(R.id.page_2)).check(matches(not(isDisplayed())));
        onView(withId(R.id.page_3)).check(matches(allOf(
                isOfClass(TextView.class),
                isDisplayed(),
                withText("Body 3"))));
    }

    @Test
    @MediumTest
    public void testAdapterChangeImmediate() {
        verifyAdapterChange(false);
    }

    @Test
    @LargeTest
    public void testAdapterChangeSmooth() {
        verifyAdapterChange(true);
    }

    private void verifyTitleStripLayout(String expectedStartTitle, String expectedSelectedTitle,
            String expectedEndTitle, int selectedPageId) {
        // Check that the title strip spans the whole width of the pager and is aligned to
        // its top
        onView(withId(R.id.titles)).check(isLeftAlignedWith(withId(R.id.pager)));
        onView(withId(R.id.titles)).check(isRightAlignedWith(withId(R.id.pager)));
        onView(withId(R.id.titles)).check(isTopAlignedWith(withId(R.id.pager)));

        // Check that the currently selected page spans the whole width of the pager and is below
        // the title strip
        onView(withId(selectedPageId)).check(isLeftAlignedWith(withId(R.id.pager)));
        onView(withId(selectedPageId)).check(isRightAlignedWith(withId(R.id.pager)));
        onView(withId(selectedPageId)).check(isBelow(withId(R.id.titles)));
        onView(withId(selectedPageId)).check(isBottomAlignedWith(withId(R.id.pager)));

        boolean hasStartTitle = !TextUtils.isEmpty(expectedStartTitle);
        boolean hasEndTitle = !TextUtils.isEmpty(expectedEndTitle);

        // Check that the title strip shows the expected number of children (tab titles)
        int nonNullTitles = (hasStartTitle ? 1 : 0) + 1 + (hasEndTitle ? 1 : 0);
        onView(withId(R.id.titles)).check(hasDisplayedChildren(nonNullTitles));

        if (hasStartTitle) {
            // Check that the title for the start page is displayed at the start edge of its parent
            // (title strip)
            onView(withId(R.id.titles)).check(matches(hasDescendant(
                    allOf(withText(expectedStartTitle), isDisplayed(), startAlignedToParent()))));
        }
        // Check that the title for the selected page is displayed centered in its parent
        // (title strip)
        onView(withId(R.id.titles)).check(matches(hasDescendant(
                allOf(withText(expectedSelectedTitle), isDisplayed(), centerAlignedInParent()))));
        if (hasEndTitle) {
            // Check that the title for the end page is displayed at the end edge of its parent
            // (title strip)
            onView(withId(R.id.titles)).check(matches(hasDescendant(
                    allOf(withText(expectedEndTitle), isDisplayed(), endAlignedToParent()))));
        }
    }

    private void verifyPagerStrip(boolean smoothScroll) {
        // Set an adapter with 5 pages
        final ColorPagerAdapter adapter = new ColorPagerAdapter();
        adapter.add("Red", Color.RED);
        adapter.add("Green", Color.GREEN);
        adapter.add("Blue", Color.BLUE);
        adapter.add("Yellow", Color.YELLOW);
        adapter.add("Magenta", Color.MAGENTA);
        onView(withId(R.id.pager)).perform(ViewPagerActions.setAdapter(adapter),
                ViewPagerActions.scrollToPage(0, smoothScroll));

        // Check that the pager has a title strip
        onView(withId(R.id.pager)).check(matches(hasDescendant(withId(R.id.titles))));
        // Check that the title strip is displayed and is of the expected class
        onView(withId(R.id.titles)).check(matches(allOf(
                isDisplayed(), isOfClass(getStripClass()))));

        // The following block tests the overall layout of tab strip and main pager content
        // (vertical stacking), the content of the tab strip (showing texts for the selected
        // tab and the ones on its left / right) as well as the alignment of the content in the
        // tab strip (selected in center, others on left and right).

        // Check the content and alignment of title strip for selected page #0
        verifyTitleStripLayout(null, "Red", "Green", R.id.page_0);

        // Scroll one page to select page #1 and check layout / content of title strip
        onView(withId(R.id.pager)).perform(ViewPagerActions.scrollRight(smoothScroll));
        verifyTitleStripLayout("Red", "Green", "Blue", R.id.page_1);

        // Scroll one page to select page #2 and check layout / content of title strip
        onView(withId(R.id.pager)).perform(ViewPagerActions.scrollRight(smoothScroll));
        verifyTitleStripLayout("Green", "Blue", "Yellow", R.id.page_2);

        // Scroll one page to select page #3 and check layout / content of title strip
        onView(withId(R.id.pager)).perform(ViewPagerActions.scrollRight(smoothScroll));
        verifyTitleStripLayout("Blue", "Yellow", "Magenta", R.id.page_3);

        // Scroll one page to select page #4 and check layout / content of title strip
        onView(withId(R.id.pager)).perform(ViewPagerActions.scrollRight(smoothScroll));
        verifyTitleStripLayout("Yellow", "Magenta", null, R.id.page_4);

        // Scroll back to page #0
        onView(withId(R.id.pager)).perform(ViewPagerActions.scrollToPage(0, smoothScroll));

        assertStripInteraction(smoothScroll);
    }

    @Test
    @LargeTest
    public void testPagerStripImmediate() {
        verifyPagerStrip(false);
    }

    @Test
    @LargeTest
    public void testPagerStripSmooth() {
        verifyPagerStrip(true);
    }

    /**
     * Returns the class of the pager strip.
     */
    protected abstract Class getStripClass();

    /**
     * Checks assertions that are specific to the pager strip implementation (interactive or
     * non interactive).
     */
    protected abstract void assertStripInteraction(boolean smoothScroll);

    /**
     * Helper method that performs the specified action on the <code>ViewPager</code> and then
     * checks the sequence of calls to the page change listener based on the specified expected
     * scroll state changes.
     *
     * If that expected list is empty, this method verifies that there were no calls to
     * onPageScrollStateChanged when the action was performed. Otherwise it verifies that the actual
     * sequence of calls to onPageScrollStateChanged matches the expected (specified) one.
     */
    private void verifyScrollStateChange(ViewAction viewAction, int... expectedScrollStateChanges) {
        ViewPager.OnPageChangeListener mockPageChangeListener =
                mock(ViewPager.OnPageChangeListener.class);
        mViewPager.addOnPageChangeListener(mockPageChangeListener);

        // Perform our action
        onView(withId(R.id.pager)).perform(viewAction);

        int expectedScrollStateChangeCount = (expectedScrollStateChanges != null) ?
                expectedScrollStateChanges.length : 0;

        if (expectedScrollStateChangeCount == 0) {
            verify(mockPageChangeListener, never()).onPageScrollStateChanged(anyInt());
        } else {
            ArgumentCaptor<Integer> pageScrollStateCaptor = ArgumentCaptor.forClass(int.class);
            verify(mockPageChangeListener, times(expectedScrollStateChangeCount)).
                    onPageScrollStateChanged(pageScrollStateCaptor.capture());
            assertThat(pageScrollStateCaptor.getAllValues(),
                    TestUtilsMatchers.matches(expectedScrollStateChanges));
        }

        // Remove our mock listener to get back to clean state for the next test
        mViewPager.removeOnPageChangeListener(mockPageChangeListener);
    }

    @Test
    @MediumTest
    public void testPageScrollStateChangedImmediate() {
        // Note that all the actions tested in this method are immediate (no scrolling) and
        // as such we test that we do not get any calls to onPageScrollStateChanged in any of them

        // Select one page to the right
        verifyScrollStateChange(ViewPagerActions.scrollRight(false));
        // Select one more page to the right
        verifyScrollStateChange(ViewPagerActions.scrollRight(false));
        // Select one page to the left
        verifyScrollStateChange(ViewPagerActions.scrollLeft(false));
        // Select one more page to the left
        verifyScrollStateChange(ViewPagerActions.scrollLeft(false));
        // Select last page
        verifyScrollStateChange(ViewPagerActions.scrollToLast(false));
        // Select first page
        verifyScrollStateChange(ViewPagerActions.scrollToFirst(false));
    }

    @Test
    @LargeTest
    public void testPageScrollStateChangedSmooth() {
        // Note that all the actions tested in this method use smooth scrolling and as such we test
        // that we get the matching calls to onPageScrollStateChanged
        final int[] expectedScrollStateChanges = new int[] {
                ViewPager.SCROLL_STATE_SETTLING, ViewPager.SCROLL_STATE_IDLE
        };

        // Select one page to the right
        verifyScrollStateChange(ViewPagerActions.scrollRight(true), expectedScrollStateChanges);
        // Select one more page to the right
        verifyScrollStateChange(ViewPagerActions.scrollRight(true), expectedScrollStateChanges);
        // Select one page to the left
        verifyScrollStateChange(ViewPagerActions.scrollLeft(true), expectedScrollStateChanges);
        // Select one more page to the left
        verifyScrollStateChange(ViewPagerActions.scrollLeft(true), expectedScrollStateChanges);
        // Select last page
        verifyScrollStateChange(ViewPagerActions.scrollToLast(true), expectedScrollStateChanges);
        // Select first page
        verifyScrollStateChange(ViewPagerActions.scrollToFirst(true), expectedScrollStateChanges);
    }

    @Test
    @LargeTest
    public void testPageScrollStateChangedSwipe() {
        // Note that all the actions tested in this method use swiping and as such we test
        // that we get the matching calls to onPageScrollStateChanged
        final int[] expectedScrollStateChanges = new int[] { ViewPager.SCROLL_STATE_DRAGGING,
                ViewPager.SCROLL_STATE_SETTLING, ViewPager.SCROLL_STATE_IDLE };

        // Swipe one page to the left
        verifyScrollStateChange(ViewPagerActions.wrap(swipeLeft()), expectedScrollStateChanges);
        assertEquals("Swipe left", 1, mViewPager.getCurrentItem());

        // Swipe one more page to the left
        verifyScrollStateChange(ViewPagerActions.wrap(swipeLeft()), expectedScrollStateChanges);
        assertEquals("Swipe left", 2, mViewPager.getCurrentItem());

        // Swipe one page to the right
        verifyScrollStateChange(ViewPagerActions.wrap(swipeRight()), expectedScrollStateChanges);
        assertEquals("Swipe right", 1, mViewPager.getCurrentItem());

        // Swipe one more page to the right
        verifyScrollStateChange(ViewPagerActions.wrap(swipeRight()), expectedScrollStateChanges);
        assertEquals("Swipe right", 0, mViewPager.getCurrentItem());
    }

    /**
     * Helper method to verify the internal consistency of values passed to
     * {@link ViewPager.OnPageChangeListener#onPageScrolled} callback when we go from a page with
     * lower index to a page with higher index.
     *
     * @param startPageIndex Index of the starting page.
     * @param endPageIndex Index of the ending page.
     * @param pageWidth Page width in pixels.
     * @param positions List of "position" values passed to all
     *      {@link ViewPager.OnPageChangeListener#onPageScrolled} calls.
     * @param positionOffsets List of "positionOffset" values passed to all
     *      {@link ViewPager.OnPageChangeListener#onPageScrolled} calls.
     * @param positionOffsetPixels List of "positionOffsetPixel" values passed to all
     *      {@link ViewPager.OnPageChangeListener#onPageScrolled} calls.
     */
    private void verifyScrollCallbacksToHigherPage(int startPageIndex, int endPageIndex,
            int pageWidth, List<Integer> positions, List<Float> positionOffsets,
            List<Integer> positionOffsetPixels) {
        int callbackCount = positions.size();

        // The last entry in all three lists must match the index of the end page
        Assert.assertEquals("Position at last index",
                endPageIndex, (int) positions.get(callbackCount - 1));
        Assert.assertEquals("Position offset at last index",
                0.0f, positionOffsets.get(callbackCount - 1), 0.0f);
        Assert.assertEquals("Position offset pixel at last index",
                0, (int) positionOffsetPixels.get(callbackCount - 1));

        // If this was our only callback, return. This can happen on immediate page change
        // or on very slow devices.
        if (callbackCount == 1) {
            return;
        }

        // If we have additional callbacks, verify that the values provided to our callback reflect
        // a valid sequence of events going from startPageIndex to endPageIndex.
        for (int i = 0; i < callbackCount - 1; i++) {
            // Page position must be between start page and end page
            int pagePositionCurr = positions.get(i);
            if ((pagePositionCurr < startPageIndex) || (pagePositionCurr > endPageIndex)) {
                Assert.fail("Position at #" + i + " is " + pagePositionCurr +
                        ", but should be between " + startPageIndex + " and " + endPageIndex);
            }

            // Page position sequence cannot be decreasing
            int pagePositionNext = positions.get(i + 1);
            if (pagePositionCurr > pagePositionNext) {
                Assert.fail("Position at #" + i + " is " + pagePositionCurr +
                        " and then decreases to " + pagePositionNext + " at #" + (i + 1));
            }

            // Position offset must be in [0..1) range (inclusive / exclusive)
            float positionOffsetCurr = positionOffsets.get(i);
            if ((positionOffsetCurr < 0.0f) || (positionOffsetCurr >= 1.0f)) {
                Assert.fail("Position offset at #" + i + " is " + positionOffsetCurr +
                        ", but should be in [0..1) range");
            }

            // Position pixel offset must be in [0..pageWidth) range (inclusive / exclusive)
            int positionOffsetPixelCurr = positionOffsetPixels.get(i);
            if ((positionOffsetPixelCurr < 0.0f) || (positionOffsetPixelCurr >= pageWidth)) {
                Assert.fail("Position pixel offset at #" + i + " is " + positionOffsetCurr +
                        ", but should be in [0.." + pageWidth + ") range");
            }

            // Position pixel offset must match the position offset and page width within
            // a one-pixel tolerance range
            Assert.assertEquals("Position pixel offset at #" + i + " is " +
                    positionOffsetPixelCurr + ", but doesn't match position offset which is" +
                    positionOffsetCurr + " and page width which is " + pageWidth,
                    positionOffsetPixelCurr, positionOffsetCurr * pageWidth, 1.0f);

            // If we stay on the same page between this index and the next one, both position
            // offset and position pixel offset must increase
            if (pagePositionNext == pagePositionCurr) {
                float positionOffsetNext = positionOffsets.get(i + 1);
                // Note that since position offset sequence is float, we are checking for strict
                // increasing
                if (positionOffsetNext <= positionOffsetCurr) {
                    Assert.fail("Position offset at #" + i + " is " + positionOffsetCurr +
                            " and at #" + (i + 1) + " is " + positionOffsetNext +
                            ". Since both are for page " + pagePositionCurr +
                            ", they cannot decrease");
                }

                int positionOffsetPixelNext = positionOffsetPixels.get(i + 1);
                // Note that since position offset pixel sequence is the mapping of position offset
                // into screen pixels, we can get two (or more) callbacks with strictly increasing
                // position offsets that are converted into the same pixel value. This is why here
                // we are checking for non-strict increasing
                if (positionOffsetPixelNext < positionOffsetPixelCurr) {
                    Assert.fail("Position offset pixel at #" + i + " is " +
                            positionOffsetPixelCurr + " and at #" + (i + 1) + " is " +
                            positionOffsetPixelNext + ". Since both are for page " +
                            pagePositionCurr + ", they cannot decrease");
                }
            }
        }
    }

    /**
     * Helper method to verify the internal consistency of values passed to
     * {@link ViewPager.OnPageChangeListener#onPageScrolled} callback when we go from a page with
     * higher index to a page with lower index.
     *
     * @param startPageIndex Index of the starting page.
     * @param endPageIndex Index of the ending page.
     * @param pageWidth Page width in pixels.
     * @param positions List of "position" values passed to all
     *      {@link ViewPager.OnPageChangeListener#onPageScrolled} calls.
     * @param positionOffsets List of "positionOffset" values passed to all
     *      {@link ViewPager.OnPageChangeListener#onPageScrolled} calls.
     * @param positionOffsetPixels List of "positionOffsetPixel" values passed to all
     *      {@link ViewPager.OnPageChangeListener#onPageScrolled} calls.
     */
    private void verifyScrollCallbacksToLowerPage(int startPageIndex, int endPageIndex,
            int pageWidth, List<Integer> positions, List<Float> positionOffsets,
            List<Integer> positionOffsetPixels) {
        int callbackCount = positions.size();

        // The last entry in all three lists must match the index of the end page
        Assert.assertEquals("Position at last index",
                endPageIndex, (int) positions.get(callbackCount - 1));
        Assert.assertEquals("Position offset at last index",
                0.0f, positionOffsets.get(callbackCount - 1), 0.0f);
        Assert.assertEquals("Position offset pixel at last index",
                0, (int) positionOffsetPixels.get(callbackCount - 1));

        // If this was our only callback, return. This can happen on immediate page change
        // or on very slow devices.
        if (callbackCount == 1) {
            return;
        }

        // If we have additional callbacks, verify that the values provided to our callback reflect
        // a valid sequence of events going from startPageIndex to endPageIndex.
        for (int i = 0; i < callbackCount - 1; i++) {
            // Page position must be between start page and end page
            int pagePositionCurr = positions.get(i);
            if ((pagePositionCurr > startPageIndex) || (pagePositionCurr < endPageIndex)) {
                Assert.fail("Position at #" + i + " is " + pagePositionCurr +
                        ", but should be between " + endPageIndex + " and " + startPageIndex);
            }

            // Page position sequence cannot be increasing
            int pagePositionNext = positions.get(i + 1);
            if (pagePositionCurr < pagePositionNext) {
                Assert.fail("Position at #" + i + " is " + pagePositionCurr +
                        " and then increases to " + pagePositionNext + " at #" + (i + 1));
            }

            // Position offset must be in [0..1) range (inclusive / exclusive)
            float positionOffsetCurr = positionOffsets.get(i);
            if ((positionOffsetCurr < 0.0f) || (positionOffsetCurr >= 1.0f)) {
                Assert.fail("Position offset at #" + i + " is " + positionOffsetCurr +
                        ", but should be in [0..1) range");
            }

            // Position pixel offset must be in [0..pageWidth) range (inclusive / exclusive)
            int positionOffsetPixelCurr = positionOffsetPixels.get(i);
            if ((positionOffsetPixelCurr < 0.0f) || (positionOffsetPixelCurr >= pageWidth)) {
                Assert.fail("Position pixel offset at #" + i + " is " + positionOffsetCurr +
                        ", but should be in [0.." + pageWidth + ") range");
            }

            // Position pixel offset must match the position offset and page width within
            // a one-pixel tolerance range
            Assert.assertEquals("Position pixel offset at #" + i + " is " +
                            positionOffsetPixelCurr + ", but doesn't match position offset which is" +
                            positionOffsetCurr + " and page width which is " + pageWidth,
                    positionOffsetPixelCurr, positionOffsetCurr * pageWidth, 1.0f);

            // If we stay on the same page between this index and the next one, both position
            // offset and position pixel offset must decrease
            if (pagePositionNext == pagePositionCurr) {
                float positionOffsetNext = positionOffsets.get(i + 1);
                // Note that since position offset sequence is float, we are checking for strict
                // decreasing
                if (positionOffsetNext >= positionOffsetCurr) {
                    Assert.fail("Position offset at #" + i + " is " + positionOffsetCurr +
                            " and at #" + (i + 1) + " is " + positionOffsetNext +
                            ". Since both are for page " + pagePositionCurr +
                            ", they cannot increase");
                }

                int positionOffsetPixelNext = positionOffsetPixels.get(i + 1);
                // Note that since position offset pixel sequence is the mapping of position offset
                // into screen pixels, we can get two (or more) callbacks with strictly decreasing
                // position offsets that are converted into the same pixel value. This is why here
                // we are checking for non-strict decreasing
                if (positionOffsetPixelNext > positionOffsetPixelCurr) {
                    Assert.fail("Position offset pixel at #" + i + " is " +
                            positionOffsetPixelCurr + " and at #" + (i + 1) + " is " +
                            positionOffsetPixelNext + ". Since both are for page " +
                            pagePositionCurr + ", they cannot increase");
                }
            }
        }
    }

    private void verifyScrollCallbacksToHigherPage(ViewAction viewAction,
            int expectedEndPageIndex) {
        final int startPageIndex = mViewPager.getCurrentItem();

        ViewPager.OnPageChangeListener mockPageChangeListener =
                mock(ViewPager.OnPageChangeListener.class);
        mViewPager.addOnPageChangeListener(mockPageChangeListener);

        // Perform our action
        onView(withId(R.id.pager)).perform(viewAction);

        final int endPageIndex = mViewPager.getCurrentItem();
        Assert.assertEquals("Current item after action", expectedEndPageIndex, endPageIndex);

        ArgumentCaptor<Integer> positionCaptor = ArgumentCaptor.forClass(int.class);
        ArgumentCaptor<Float> positionOffsetCaptor = ArgumentCaptor.forClass(float.class);
        ArgumentCaptor<Integer> positionOffsetPixelsCaptor = ArgumentCaptor.forClass(int.class);
        verify(mockPageChangeListener, atLeastOnce()).onPageScrolled(positionCaptor.capture(),
                positionOffsetCaptor.capture(), positionOffsetPixelsCaptor.capture());

        verifyScrollCallbacksToHigherPage(startPageIndex, endPageIndex, mViewPager.getWidth(),
                positionCaptor.getAllValues(), positionOffsetCaptor.getAllValues(),
                positionOffsetPixelsCaptor.getAllValues());

        // Remove our mock listener to get back to clean state for the next test
        mViewPager.removeOnPageChangeListener(mockPageChangeListener);
    }

    private void verifyScrollCallbacksToLowerPage(ViewAction viewAction,
            int expectedEndPageIndex) {
        final int startPageIndex = mViewPager.getCurrentItem();

        ViewPager.OnPageChangeListener mockPageChangeListener =
                mock(ViewPager.OnPageChangeListener.class);
        mViewPager.addOnPageChangeListener(mockPageChangeListener);

        // Perform our action
        onView(withId(R.id.pager)).perform(viewAction);

        final int endPageIndex = mViewPager.getCurrentItem();
        Assert.assertEquals("Current item after action", expectedEndPageIndex, endPageIndex);

        ArgumentCaptor<Integer> positionCaptor = ArgumentCaptor.forClass(int.class);
        ArgumentCaptor<Float> positionOffsetCaptor = ArgumentCaptor.forClass(float.class);
        ArgumentCaptor<Integer> positionOffsetPixelsCaptor = ArgumentCaptor.forClass(int.class);
        verify(mockPageChangeListener, atLeastOnce()).onPageScrolled(positionCaptor.capture(),
                positionOffsetCaptor.capture(), positionOffsetPixelsCaptor.capture());

        verifyScrollCallbacksToLowerPage(startPageIndex, endPageIndex, mViewPager.getWidth(),
                positionCaptor.getAllValues(), positionOffsetCaptor.getAllValues(),
                positionOffsetPixelsCaptor.getAllValues());

        // Remove our mock listener to get back to clean state for the next test
        mViewPager.removeOnPageChangeListener(mockPageChangeListener);
    }

    @Test
    @MediumTest
    public void testPageScrollPositionChangesImmediate() {
        // Scroll one page to the right
        verifyScrollCallbacksToHigherPage(ViewPagerActions.scrollRight(false), 1);
        // Scroll one more page to the right
        verifyScrollCallbacksToHigherPage(ViewPagerActions.scrollRight(false), 2);
        // Scroll one page to the left
        verifyScrollCallbacksToLowerPage(ViewPagerActions.scrollLeft(false), 1);
        // Scroll one more page to the left
        verifyScrollCallbacksToLowerPage(ViewPagerActions.scrollLeft(false), 0);

        // Scroll to the last page
        verifyScrollCallbacksToHigherPage(ViewPagerActions.scrollToLast(false), 2);
        // Scroll to the first page
        verifyScrollCallbacksToLowerPage(ViewPagerActions.scrollToFirst(false), 0);
    }

    @Test
    @LargeTest
    public void testPageScrollPositionChangesSmooth() {
        // Scroll one page to the right
        verifyScrollCallbacksToHigherPage(ViewPagerActions.scrollRight(true), 1);
        // Scroll one more page to the right
        verifyScrollCallbacksToHigherPage(ViewPagerActions.scrollRight(true), 2);
        // Scroll one page to the left
        verifyScrollCallbacksToLowerPage(ViewPagerActions.scrollLeft(true), 1);
        // Scroll one more page to the left
        verifyScrollCallbacksToLowerPage(ViewPagerActions.scrollLeft(true), 0);

        // Scroll to the last page
        verifyScrollCallbacksToHigherPage(ViewPagerActions.scrollToLast(true), 2);
        // Scroll to the first page
        verifyScrollCallbacksToLowerPage(ViewPagerActions.scrollToFirst(true), 0);
    }

    @Test
    @LargeTest
    public void testPageScrollPositionChangesSwipe() {
        // Swipe one page to the left
        verifyScrollCallbacksToHigherPage(ViewPagerActions.wrap(swipeLeft()), 1);
        // Swipe one more page to the left
        verifyScrollCallbacksToHigherPage(ViewPagerActions.wrap(swipeLeft()), 2);
        // Swipe one page to the right
        verifyScrollCallbacksToLowerPage(ViewPagerActions.wrap(swipeRight()), 1);
        // Swipe one more page to the right
        verifyScrollCallbacksToLowerPage(ViewPagerActions.wrap(swipeRight()), 0);
    }

    @FlakyTest(bugId = 38260187)
    @Test
    @LargeTest
    public void testKeyboardNavigation() {
        ButtonPagerAdapter adapter = new ButtonPagerAdapter();
        adapter.add("Red", Color.RED);
        adapter.add("Green", Color.GREEN);
        adapter.add("Blue", Color.BLUE);
        onView(withId(R.id.pager)).perform(
                ViewPagerActions.setAdapter(adapter), ViewPagerActions.scrollToPage(0, false));
        View firstButton = adapter.getButton(0, 0);
        firstButton.requestFocus();
        assertTrue(firstButton.isFocused());
        assertEquals(0, mViewPager.getCurrentItem());

        // Normal arrows should traverse contents first
        onView(is(firstButton)).perform(pressKey(KeyEvent.KEYCODE_DPAD_RIGHT));
        assertEquals(0, mViewPager.getCurrentItem());
        assertTrue(adapter.getButton(0, 1).isFocused());

        // Alt arrows should change page even if there are more focusables in that direction
        onView(is(adapter.getButton(0, 1))).perform(pressKey(new EspressoKey.Builder()
                .withAltPressed(true).withKeyCode(KeyEvent.KEYCODE_DPAD_RIGHT).build()));
        assertEquals(1, mViewPager.getCurrentItem());
        assertTrue(adapter.getButton(1, 0).isFocused());

        // Normal arrows should change page if there are no more focusables in that direction
        onView(is(adapter.getButton(1, 0))).perform(pressKey(KeyEvent.KEYCODE_DPAD_LEFT));
        assertEquals(0, mViewPager.getCurrentItem());
    }
}