design/tests/src/android/support/design/widget/TabLayoutWithViewPagerTest.java - platform/frameworks/support - Git at Google

 /*
  * Copyright (C) 2015 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 android.support.design.widget;

 import android.content.res.Resources;
 import android.graphics.Color;
 import android.support.annotation.DimenRes;
 import android.support.annotation.LayoutRes;
 import android.support.design.test.R;
 import android.support.design.testutils.TabLayoutActions;
 import android.support.design.testutils.TestUtilsActions;
 import android.support.design.testutils.TestUtilsMatchers;
 import android.support.design.testutils.ViewPagerActions;
 import android.support.v4.view.PagerAdapter;
 import android.support.v4.view.ViewPager;
 import android.test.suitebuilder.annotation.MediumTest;
 import android.test.suitebuilder.annotation.SmallTest;
 import android.util.Pair;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.HorizontalScrollView;
 import android.widget.TextView;
 import org.hamcrest.Matcher;
 import org.junit.Before;
 import org.junit.Test;

 import java.util.ArrayList;

 import static android.support.design.testutils.TabLayoutActions.setupWithViewPager;
 import static android.support.design.testutils.ViewPagerActions.notifyAdapterContentChange;
 import static android.support.test.espresso.Espresso.onView;
 import static android.support.test.espresso.assertion.ViewAssertions.matches;
 import static android.support.test.espresso.matcher.ViewMatchers.*;
 import static org.hamcrest.Matchers.allOf;
 import static org.hamcrest.Matchers.not;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotEquals;

 public class TabLayoutWithViewPagerTest
         extends BaseInstrumentationTestCase<TabLayoutWithViewPagerActivity> {
     private TabLayout mTabLayout;

     private ViewPager mViewPager;

     private ColorPagerAdapter mDefaultPagerAdapter;

     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);
         }
     }

     public TabLayoutWithViewPagerTest() {
         super(TabLayoutWithViewPagerActivity.class);
     }

     @Before
     public void setUp() throws Exception {
         final TabLayoutWithViewPagerActivity activity = mActivityTestRule.getActivity();
         mTabLayout = (TabLayout) activity.findViewById(R.id.tabs);
         mViewPager = (ViewPager) activity.findViewById(R.id.tabs_viewpager);

         mDefaultPagerAdapter = new ColorPagerAdapter();
         mDefaultPagerAdapter.add("Red", Color.RED);
         mDefaultPagerAdapter.add("Green", Color.GREEN);
         mDefaultPagerAdapter.add("Blue", Color.BLUE);

         // Configure view pager
         onView(withId(R.id.tabs_viewpager)).perform(
                 ViewPagerActions.setAdapter(mDefaultPagerAdapter),
                 ViewPagerActions.scrollToPage(0));
     }

     private void setupTabLayoutWithViewPager() {
         // And wire the tab layout to it
         onView(withId(R.id.tabs)).perform(setupWithViewPager(mViewPager));
     }

     /**
      * Verifies that selecting pages in <code>ViewPager</code> also updates the tab selection
      * in the wired <code>TabLayout</code>
      */
     private void verifyViewPagerSelection() {
         int itemCount = mViewPager.getAdapter().getCount();

         onView(withId(R.id.tabs_viewpager)).perform(ViewPagerActions.scrollToPage(0));
         assertEquals("Selected page", 0, mViewPager.getCurrentItem());
         assertEquals("Selected tab", 0, mTabLayout.getSelectedTabPosition());

         // Scroll tabs to the right
         for (int i = 0; i < (itemCount - 1); i++) {
             // Scroll one tab to the right
             onView(withId(R.id.tabs_viewpager)).perform(ViewPagerActions.scrollRight());
             final int expectedCurrentTabIndex = i + 1;
             assertEquals("Scroll right #" + i, expectedCurrentTabIndex,
                     mViewPager.getCurrentItem());
             assertEquals("Selected tab after scrolling right #" + i, expectedCurrentTabIndex,
                     mTabLayout.getSelectedTabPosition());
         }

         // Scroll tabs to the left
         for (int i = 0; i < (itemCount - 1); i++) {
             // Scroll one tab to the left
             onView(withId(R.id.tabs_viewpager)).perform(ViewPagerActions.scrollLeft());
             final int expectedCurrentTabIndex = itemCount - i - 2;
             assertEquals("Scroll left #" + i, expectedCurrentTabIndex, mViewPager.getCurrentItem());
             assertEquals("Selected tab after scrolling left #" + i, expectedCurrentTabIndex,
                     mTabLayout.getSelectedTabPosition());
         }
     }

     /**
      * Verifies that selecting pages in <code>ViewPager</code> also updates the tab selection
      * in the wired <code>TabLayout</code>
      */
     private void verifyTabLayoutSelection() {
         int itemCount = mTabLayout.getTabCount();

         onView(withId(R.id.tabs_viewpager)).perform(ViewPagerActions.scrollToPage(0));
         assertEquals("Selected tab", 0, mTabLayout.getSelectedTabPosition());
         assertEquals("Selected page", 0, mViewPager.getCurrentItem());

         // Select tabs "going" to the right. Note that the first loop iteration tests the
         // scenario of "selecting" the first tab when it's already selected.
         for (int i = 0; i < itemCount; i++) {
             onView(withId(R.id.tabs)).perform(TabLayoutActions.selectTab(i));
             assertEquals("Selected tab after selecting #" + i, i,
                     mTabLayout.getSelectedTabPosition());
             assertEquals("Select tab #" + i, i, mViewPager.getCurrentItem());
         }

         // Select tabs "going" to the left. Note that the first loop iteration tests the
         // scenario of "selecting" the last tab when it's already selected.
         for (int i = itemCount - 1; i >= 0; i--) {
             onView(withId(R.id.tabs)).perform(TabLayoutActions.selectTab(i));
             assertEquals("Scroll left #" + i, i, mViewPager.getCurrentItem());
             assertEquals("Selected tab after scrolling left #" + i, i,
                     mTabLayout.getSelectedTabPosition());
         }
     }

     @Test
     @SmallTest
     public void testBasics() {
         setupTabLayoutWithViewPager();

         final int itemCount = mViewPager.getAdapter().getCount();

         assertEquals("Matching item count", itemCount, mTabLayout.getTabCount());

         for (int i = 0; i < itemCount; i++) {
             assertEquals("Tab #" +i, mViewPager.getAdapter().getPageTitle(i),
                     mTabLayout.getTabAt(i).getText());
         }

         assertEquals("Selected tab", mViewPager.getCurrentItem(),
                 mTabLayout.getSelectedTabPosition());

         verifyViewPagerSelection();
     }

     @Test
     @SmallTest
     public void testInteraction() {
         setupTabLayoutWithViewPager();

         assertEquals("Default selected page", 0, mViewPager.getCurrentItem());
         assertEquals("Default selected tab", 0, mTabLayout.getSelectedTabPosition());

         verifyTabLayoutSelection();
     }

     @Test
     @SmallTest
     public void testAdapterContentChange() {
         setupTabLayoutWithViewPager();

         // 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());

         // Add two more entries to our adapter
         mDefaultPagerAdapter.add("Yellow", Color.YELLOW);
         mDefaultPagerAdapter.add("Magenta", Color.MAGENTA);
         final int newItemCount = mDefaultPagerAdapter.getCount();
         onView(withId(R.id.tabs_viewpager)).perform(notifyAdapterContentChange());

         // We have more comprehensive test coverage for changing the ViewPager adapter in v4/tests.
         // Here we are focused on testing the continuous integration of TabLayout with the new
         // content of ViewPager

         assertEquals("Matching item count", newItemCount, mTabLayout.getTabCount());

         for (int i = 0; i < newItemCount; i++) {
             assertEquals("Tab #" +i, mViewPager.getAdapter().getPageTitle(i),
                     mTabLayout.getTabAt(i).getText());
         }

         verifyViewPagerSelection();
         verifyTabLayoutSelection();
     }

     @Test
     @SmallTest
     public void testAdapterContentChangeWithAutoRefreshDisabled() {
         onView(withId(R.id.tabs)).perform(setupWithViewPager(mViewPager, false));

         // 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());

         // Add two more entries to our adapter
         mDefaultPagerAdapter.add("Yellow", Color.YELLOW);
         mDefaultPagerAdapter.add("Magenta", Color.MAGENTA);
         final int newItemCount = mDefaultPagerAdapter.getCount();

         // Notify the adapter that it has changed
         onView(withId(R.id.tabs_viewpager)).perform(notifyAdapterContentChange());

         // Assert that the TabLayout did not update and add the new items
         assertNotEquals("Matching item count", newItemCount, mTabLayout.getTabCount());
     }

     @Test
     @SmallTest
     public void testBasicAutoRefreshDisabled() {
         onView(withId(R.id.tabs)).perform(setupWithViewPager(mViewPager, false));

         // Check that the TabLayout has the same number of items are the adapter
         PagerAdapter initialAdapter = mViewPager.getAdapter();
         assertEquals("Initial adapter page count", initialAdapter.getCount(),
                 mTabLayout.getTabCount());

         // Add two more entries to our adapter
         mDefaultPagerAdapter.add("Yellow", Color.YELLOW);
         mDefaultPagerAdapter.add("Magenta", Color.MAGENTA);
         final int newItemCount = mDefaultPagerAdapter.getCount();

         // Assert that the TabLayout did not update and add the new items
         assertNotEquals("Matching item count", newItemCount, mTabLayout.getTabCount());

         // Now setup again to update the tabs
         onView(withId(R.id.tabs)).perform(setupWithViewPager(mViewPager, false));

         // Assert that the TabLayout updated and added the new items
         assertEquals("Matching item count", newItemCount, mTabLayout.getTabCount());
     }

     @Test
     @SmallTest
     public void testAdapterChange() {
         setupTabLayoutWithViewPager();

         // 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();
         final int newItemCount = 6;
         for (int i = 0; i < newItemCount; i++) {
             newAdapter.add("Title " + i, "Body " + i);
         }
         // And set it on the ViewPager
         onView(withId(R.id.tabs_viewpager)).perform(ViewPagerActions.setAdapter(newAdapter),
                 ViewPagerActions.scrollToPage(0));

         // As TabLayout doesn't track adapter changes, we need to re-wire the new adapter
         onView(withId(R.id.tabs)).perform(setupWithViewPager(mViewPager));

         // We have more comprehensive test coverage for changing the ViewPager adapter in v4/tests.
         // Here we are focused on testing the integration of TabLayout with the new
         // content of ViewPager

         assertEquals("Matching item count", newItemCount, mTabLayout.getTabCount());

         for (int i = 0; i < newItemCount; i++) {
             assertEquals("Tab #" +i, mViewPager.getAdapter().getPageTitle(i),
                     mTabLayout.getTabAt(i).getText());
         }

         verifyViewPagerSelection();
         verifyTabLayoutSelection();
     }

     @Test
     @MediumTest
     public void testFixedTabMode() {
         // Create a new adapter (with no content)
         final TextPagerAdapter newAdapter = new TextPagerAdapter();
         // And set it on the ViewPager
         onView(withId(R.id.tabs_viewpager)).perform(ViewPagerActions.setAdapter(newAdapter));
         // As TabLayout doesn't track adapter changes, we need to re-wire the new adapter
         onView(withId(R.id.tabs)).perform(setupWithViewPager(mViewPager));

         // Set fixed mode on the TabLayout
         onView(withId(R.id.tabs)).perform(TabLayoutActions.setTabMode(TabLayout.MODE_FIXED));
         assertEquals("Fixed tab mode", TabLayout.MODE_FIXED, mTabLayout.getTabMode());

         // Add a bunch of tabs and verify that all of them are visible on the screen
         for (int i = 0; i < 8; i++) {
             newAdapter.add("Title " + i, "Body " + i);
             onView(withId(R.id.tabs_viewpager)).perform(
                     notifyAdapterContentChange());

             int expectedTabCount = i + 1;
             assertEquals("Tab count after adding #" + i, expectedTabCount,
                     mTabLayout.getTabCount());
             assertEquals("Page count after adding #" + i, expectedTabCount,
                     mViewPager.getAdapter().getCount());

             verifyViewPagerSelection();
             verifyTabLayoutSelection();

             // Check that all tabs are fully visible (the content may or may not be elided)
             for (int j = 0; j < expectedTabCount; j++) {
                 onView(allOf(isDescendantOfA(withId(R.id.tabs)), withText("Title " + j))).
                         check(matches(isCompletelyDisplayed()));
             }
         }
     }

     /**
      * Helper method to verify support for min and max tab width on TabLayout in scrollable mode.
      * It replaces the TabLayout based on the passed layout resource ID and then adds a bunch of
      * tab titles to the wired ViewPager with progressively longer texts. After each tab is added
      * this method then checks that all tab views respect the minimum and maximum tab width set
      * on TabLayout.
      *
      * @param tabLayoutResId Layout resource for the TabLayout to be wired to the ViewPager.
      * @param tabMinWidthResId If non zero, points to the dimension resource to use for tab min
      * width check.
      * @param tabMaxWidthResId If non zero, points to the dimension resource to use for tab max
      * width check.
      */
     private void verifyMinMaxTabWidth(@LayoutRes int tabLayoutResId, @DimenRes int tabMinWidthResId,
             @DimenRes int tabMaxWidthResId) {
         setupTabLayoutWithViewPager();

         assertEquals("Scrollable tab mode", TabLayout.MODE_SCROLLABLE, mTabLayout.getTabMode());

         final Resources res = mActivityTestRule.getActivity().getResources();
         final int minTabWidth = (tabMinWidthResId == 0) ? -1 :
                 res.getDimensionPixelSize(tabMinWidthResId);
         final int maxTabWidth = (tabMaxWidthResId == 0) ? -1 :
                 res.getDimensionPixelSize(tabMaxWidthResId);

         // Create a new adapter (with no content)
         final TextPagerAdapter newAdapter = new TextPagerAdapter();
         // And set it on the ViewPager
         onView(withId(R.id.tabs_viewpager)).perform(ViewPagerActions.setAdapter(newAdapter));

         // Replace the default TabLayout with the passed one
         onView(withId(R.id.container)).perform(TestUtilsActions.replaceTabLayout(tabLayoutResId));

         // Now that we have a new TabLayout, wire it to the new content of our ViewPager
         onView(withId(R.id.tabs)).perform(setupWithViewPager(mViewPager));

         // Since TabLayout doesn't expose a getter for fetching the configured max tab width,
         // start adding a variety of tabs with progressively longer tab titles and test that
         // no tab is wider than the configured max width. Before we start that test,
         // verify that we're in the scrollable mode so that each tab title gets as much width
         // as needed to display its text.
         assertEquals("Scrollable tab mode", TabLayout.MODE_SCROLLABLE, mTabLayout.getTabMode());

         final StringBuilder tabTitleBuilder = new StringBuilder();
         for (int i = 0; i < 40; i++) {
             final char titleComponent = (char) ('A' + i);
             for (int j = 0; j <= (i + 1); j++) {
                 tabTitleBuilder.append(titleComponent);
             }
             final String tabTitle = tabTitleBuilder.toString();
             newAdapter.add(tabTitle, "Body " + i);
             onView(withId(R.id.tabs_viewpager)).perform(
                     notifyAdapterContentChange());

             int expectedTabCount = i + 1;
             // Check that all tabs are at least as wide as min width *and* at most as wide as max
             // width specified in the XML for the newly loaded TabLayout
             for (int j = 0; j < expectedTabCount; j++) {
                 // Find the view that is our tab title. It should be:
                 // 1. Descendant of our TabLayout
                 // 2. But not a direct child of the horizontal scroller
                 // 3. With just-added title text
                 // These conditions make sure that we're selecting the "top-level" tab view
                 // instead of the inner (and narrower) TextView
                 Matcher<View> tabMatcher = allOf(
                         isDescendantOfA(withId(R.id.tabs)),
                         not(withParent(isAssignableFrom(HorizontalScrollView.class))),
                         hasDescendant(withText(tabTitle)));
                 if (minTabWidth >= 0) {
                     onView(tabMatcher).check(matches(
                             TestUtilsMatchers.isNotNarrowerThan(minTabWidth)));
                 }
                 if (maxTabWidth >= 0) {
                     onView(tabMatcher).check(matches(
                             TestUtilsMatchers.isNotWiderThan(maxTabWidth)));
                 }
             }

             // Reset the title builder for the next tab
             tabTitleBuilder.setLength(0);
             tabTitleBuilder.trimToSize();
         }

     }

     @Test
     @MediumTest
     public void testMinTabWidth() {
         verifyMinMaxTabWidth(R.layout.tab_layout_bound_min, R.dimen.tab_width_limit_medium, 0);
     }

     @Test
     @MediumTest
     public void testMaxTabWidth() {
         verifyMinMaxTabWidth(R.layout.tab_layout_bound_max, 0, R.dimen.tab_width_limit_medium);
     }

     @Test
     @MediumTest
     public void testMinMaxTabWidth() {
         verifyMinMaxTabWidth(R.layout.tab_layout_bound_minmax, R.dimen.tab_width_limit_small,
                 R.dimen.tab_width_limit_large);
     }

     @Test
     @SmallTest
     public void testSetupAfterViewPagerScrolled() {
         // Scroll to the last item
         final int selected = mViewPager.getAdapter().getCount() - 1;
         onView(withId(R.id.tabs_viewpager)).perform(ViewPagerActions.scrollToPage(selected));

         // Now setup the TabLayout with the ViewPager
         setupTabLayoutWithViewPager();

         assertEquals("Selected page", selected, mViewPager.getCurrentItem());
         assertEquals("Selected tab", selected, mTabLayout.getSelectedTabPosition());
     }
 }
	/*
	* Copyright (C) 2015 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 android.support.design.widget;

	import android.content.res.Resources;
	import android.graphics.Color;
	import android.support.annotation.DimenRes;
	import android.support.annotation.LayoutRes;
	import android.support.design.test.R;
	import android.support.design.testutils.TabLayoutActions;
	import android.support.design.testutils.TestUtilsActions;
	import android.support.design.testutils.TestUtilsMatchers;
	import android.support.design.testutils.ViewPagerActions;
	import android.support.v4.view.PagerAdapter;
	import android.support.v4.view.ViewPager;
	import android.test.suitebuilder.annotation.MediumTest;
	import android.test.suitebuilder.annotation.SmallTest;
	import android.util.Pair;
	import android.view.View;
	import android.view.ViewGroup;
	import android.widget.HorizontalScrollView;
	import android.widget.TextView;
	import org.hamcrest.Matcher;
	import org.junit.Before;
	import org.junit.Test;

	import java.util.ArrayList;

	import static android.support.design.testutils.TabLayoutActions.setupWithViewPager;
	import static android.support.design.testutils.ViewPagerActions.notifyAdapterContentChange;
	import static android.support.test.espresso.Espresso.onView;
	import static android.support.test.espresso.assertion.ViewAssertions.matches;
	import static android.support.test.espresso.matcher.ViewMatchers.*;
	import static org.hamcrest.Matchers.allOf;
	import static org.hamcrest.Matchers.not;
	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertNotEquals;

	public class TabLayoutWithViewPagerTest
	extends BaseInstrumentationTestCase<TabLayoutWithViewPagerActivity> {
	private TabLayout mTabLayout;

	private ViewPager mViewPager;

	private ColorPagerAdapter mDefaultPagerAdapter;

	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);
	}
	}

	public TabLayoutWithViewPagerTest() {
	super(TabLayoutWithViewPagerActivity.class);
	}

	@Before
	public void setUp() throws Exception {
	final TabLayoutWithViewPagerActivity activity = mActivityTestRule.getActivity();
	mTabLayout = (TabLayout) activity.findViewById(R.id.tabs);
	mViewPager = (ViewPager) activity.findViewById(R.id.tabs_viewpager);

	mDefaultPagerAdapter = new ColorPagerAdapter();
	mDefaultPagerAdapter.add("Red", Color.RED);
	mDefaultPagerAdapter.add("Green", Color.GREEN);
	mDefaultPagerAdapter.add("Blue", Color.BLUE);

	// Configure view pager
	onView(withId(R.id.tabs_viewpager)).perform(
	ViewPagerActions.setAdapter(mDefaultPagerAdapter),
	ViewPagerActions.scrollToPage(0));
	}

	private void setupTabLayoutWithViewPager() {
	// And wire the tab layout to it
	onView(withId(R.id.tabs)).perform(setupWithViewPager(mViewPager));
	}

	/**
	* Verifies that selecting pages in <code>ViewPager</code> also updates the tab selection
	* in the wired <code>TabLayout</code>
	*/
	private void verifyViewPagerSelection() {
	int itemCount = mViewPager.getAdapter().getCount();

	onView(withId(R.id.tabs_viewpager)).perform(ViewPagerActions.scrollToPage(0));
	assertEquals("Selected page", 0, mViewPager.getCurrentItem());
	assertEquals("Selected tab", 0, mTabLayout.getSelectedTabPosition());

	// Scroll tabs to the right
	for (int i = 0; i < (itemCount - 1); i++) {
	// Scroll one tab to the right
	onView(withId(R.id.tabs_viewpager)).perform(ViewPagerActions.scrollRight());
	final int expectedCurrentTabIndex = i + 1;
	assertEquals("Scroll right #" + i, expectedCurrentTabIndex,
	mViewPager.getCurrentItem());
	assertEquals("Selected tab after scrolling right #" + i, expectedCurrentTabIndex,
	mTabLayout.getSelectedTabPosition());
	}

	// Scroll tabs to the left
	for (int i = 0; i < (itemCount - 1); i++) {
	// Scroll one tab to the left
	onView(withId(R.id.tabs_viewpager)).perform(ViewPagerActions.scrollLeft());
	final int expectedCurrentTabIndex = itemCount - i - 2;
	assertEquals("Scroll left #" + i, expectedCurrentTabIndex, mViewPager.getCurrentItem());
	assertEquals("Selected tab after scrolling left #" + i, expectedCurrentTabIndex,
	mTabLayout.getSelectedTabPosition());
	}
	}

	/**
	* Verifies that selecting pages in <code>ViewPager</code> also updates the tab selection
	* in the wired <code>TabLayout</code>
	*/
	private void verifyTabLayoutSelection() {
	int itemCount = mTabLayout.getTabCount();

	onView(withId(R.id.tabs_viewpager)).perform(ViewPagerActions.scrollToPage(0));
	assertEquals("Selected tab", 0, mTabLayout.getSelectedTabPosition());
	assertEquals("Selected page", 0, mViewPager.getCurrentItem());

	// Select tabs "going" to the right. Note that the first loop iteration tests the
	// scenario of "selecting" the first tab when it's already selected.
	for (int i = 0; i < itemCount; i++) {
	onView(withId(R.id.tabs)).perform(TabLayoutActions.selectTab(i));
	assertEquals("Selected tab after selecting #" + i, i,
	mTabLayout.getSelectedTabPosition());
	assertEquals("Select tab #" + i, i, mViewPager.getCurrentItem());
	}

	// Select tabs "going" to the left. Note that the first loop iteration tests the
	// scenario of "selecting" the last tab when it's already selected.
	for (int i = itemCount - 1; i >= 0; i--) {
	onView(withId(R.id.tabs)).perform(TabLayoutActions.selectTab(i));
	assertEquals("Scroll left #" + i, i, mViewPager.getCurrentItem());
	assertEquals("Selected tab after scrolling left #" + i, i,
	mTabLayout.getSelectedTabPosition());
	}
	}

	@Test
	@SmallTest
	public void testBasics() {
	setupTabLayoutWithViewPager();

	final int itemCount = mViewPager.getAdapter().getCount();

	assertEquals("Matching item count", itemCount, mTabLayout.getTabCount());

	for (int i = 0; i < itemCount; i++) {
	assertEquals("Tab #" +i, mViewPager.getAdapter().getPageTitle(i),
	mTabLayout.getTabAt(i).getText());
	}

	assertEquals("Selected tab", mViewPager.getCurrentItem(),
	mTabLayout.getSelectedTabPosition());

	verifyViewPagerSelection();
	}

	@Test
	@SmallTest
	public void testInteraction() {
	setupTabLayoutWithViewPager();

	assertEquals("Default selected page", 0, mViewPager.getCurrentItem());
	assertEquals("Default selected tab", 0, mTabLayout.getSelectedTabPosition());

	verifyTabLayoutSelection();
	}

	@Test
	@SmallTest
	public void testAdapterContentChange() {
	setupTabLayoutWithViewPager();

	// 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());

	// Add two more entries to our adapter
	mDefaultPagerAdapter.add("Yellow", Color.YELLOW);
	mDefaultPagerAdapter.add("Magenta", Color.MAGENTA);
	final int newItemCount = mDefaultPagerAdapter.getCount();
	onView(withId(R.id.tabs_viewpager)).perform(notifyAdapterContentChange());

	// We have more comprehensive test coverage for changing the ViewPager adapter in v4/tests.
	// Here we are focused on testing the continuous integration of TabLayout with the new
	// content of ViewPager

	assertEquals("Matching item count", newItemCount, mTabLayout.getTabCount());

	for (int i = 0; i < newItemCount; i++) {
	assertEquals("Tab #" +i, mViewPager.getAdapter().getPageTitle(i),
	mTabLayout.getTabAt(i).getText());
	}

	verifyViewPagerSelection();
	verifyTabLayoutSelection();
	}

	@Test
	@SmallTest
	public void testAdapterContentChangeWithAutoRefreshDisabled() {
	onView(withId(R.id.tabs)).perform(setupWithViewPager(mViewPager, false));

	// 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());

	// Add two more entries to our adapter
	mDefaultPagerAdapter.add("Yellow", Color.YELLOW);
	mDefaultPagerAdapter.add("Magenta", Color.MAGENTA);
	final int newItemCount = mDefaultPagerAdapter.getCount();

	// Notify the adapter that it has changed
	onView(withId(R.id.tabs_viewpager)).perform(notifyAdapterContentChange());

	// Assert that the TabLayout did not update and add the new items
	assertNotEquals("Matching item count", newItemCount, mTabLayout.getTabCount());
	}

	@Test
	@SmallTest
	public void testBasicAutoRefreshDisabled() {
	onView(withId(R.id.tabs)).perform(setupWithViewPager(mViewPager, false));

	// Check that the TabLayout has the same number of items are the adapter
	PagerAdapter initialAdapter = mViewPager.getAdapter();
	assertEquals("Initial adapter page count", initialAdapter.getCount(),
	mTabLayout.getTabCount());

	// Add two more entries to our adapter
	mDefaultPagerAdapter.add("Yellow", Color.YELLOW);
	mDefaultPagerAdapter.add("Magenta", Color.MAGENTA);
	final int newItemCount = mDefaultPagerAdapter.getCount();

	// Assert that the TabLayout did not update and add the new items
	assertNotEquals("Matching item count", newItemCount, mTabLayout.getTabCount());

	// Now setup again to update the tabs
	onView(withId(R.id.tabs)).perform(setupWithViewPager(mViewPager, false));

	// Assert that the TabLayout updated and added the new items
	assertEquals("Matching item count", newItemCount, mTabLayout.getTabCount());
	}

	@Test
	@SmallTest
	public void testAdapterChange() {
	setupTabLayoutWithViewPager();

	// 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();
	final int newItemCount = 6;
	for (int i = 0; i < newItemCount; i++) {
	newAdapter.add("Title " + i, "Body " + i);
	}
	// And set it on the ViewPager
	onView(withId(R.id.tabs_viewpager)).perform(ViewPagerActions.setAdapter(newAdapter),
	ViewPagerActions.scrollToPage(0));

	// As TabLayout doesn't track adapter changes, we need to re-wire the new adapter
	onView(withId(R.id.tabs)).perform(setupWithViewPager(mViewPager));

	// We have more comprehensive test coverage for changing the ViewPager adapter in v4/tests.
	// Here we are focused on testing the integration of TabLayout with the new
	// content of ViewPager

	assertEquals("Matching item count", newItemCount, mTabLayout.getTabCount());

	for (int i = 0; i < newItemCount; i++) {
	assertEquals("Tab #" +i, mViewPager.getAdapter().getPageTitle(i),
	mTabLayout.getTabAt(i).getText());
	}

	verifyViewPagerSelection();
	verifyTabLayoutSelection();
	}

	@Test
	@MediumTest
	public void testFixedTabMode() {
	// Create a new adapter (with no content)
	final TextPagerAdapter newAdapter = new TextPagerAdapter();
	// And set it on the ViewPager
	onView(withId(R.id.tabs_viewpager)).perform(ViewPagerActions.setAdapter(newAdapter));
	// As TabLayout doesn't track adapter changes, we need to re-wire the new adapter
	onView(withId(R.id.tabs)).perform(setupWithViewPager(mViewPager));

	// Set fixed mode on the TabLayout
	onView(withId(R.id.tabs)).perform(TabLayoutActions.setTabMode(TabLayout.MODE_FIXED));
	assertEquals("Fixed tab mode", TabLayout.MODE_FIXED, mTabLayout.getTabMode());

	// Add a bunch of tabs and verify that all of them are visible on the screen
	for (int i = 0; i < 8; i++) {
	newAdapter.add("Title " + i, "Body " + i);
	onView(withId(R.id.tabs_viewpager)).perform(
	notifyAdapterContentChange());

	int expectedTabCount = i + 1;
	assertEquals("Tab count after adding #" + i, expectedTabCount,
	mTabLayout.getTabCount());
	assertEquals("Page count after adding #" + i, expectedTabCount,
	mViewPager.getAdapter().getCount());

	verifyViewPagerSelection();
	verifyTabLayoutSelection();

	// Check that all tabs are fully visible (the content may or may not be elided)
	for (int j = 0; j < expectedTabCount; j++) {
	onView(allOf(isDescendantOfA(withId(R.id.tabs)), withText("Title " + j))).
	check(matches(isCompletelyDisplayed()));
	}
	}
	}

	/**
	* Helper method to verify support for min and max tab width on TabLayout in scrollable mode.
	* It replaces the TabLayout based on the passed layout resource ID and then adds a bunch of
	* tab titles to the wired ViewPager with progressively longer texts. After each tab is added
	* this method then checks that all tab views respect the minimum and maximum tab width set
	* on TabLayout.
	*
	* @param tabLayoutResId Layout resource for the TabLayout to be wired to the ViewPager.
	* @param tabMinWidthResId If non zero, points to the dimension resource to use for tab min
	* width check.
	* @param tabMaxWidthResId If non zero, points to the dimension resource to use for tab max
	* width check.
	*/
	private void verifyMinMaxTabWidth(@LayoutRes int tabLayoutResId, @DimenRes int tabMinWidthResId,
	@DimenRes int tabMaxWidthResId) {
	setupTabLayoutWithViewPager();

	assertEquals("Scrollable tab mode", TabLayout.MODE_SCROLLABLE, mTabLayout.getTabMode());

	final Resources res = mActivityTestRule.getActivity().getResources();
	final int minTabWidth = (tabMinWidthResId == 0) ? -1 :
	res.getDimensionPixelSize(tabMinWidthResId);
	final int maxTabWidth = (tabMaxWidthResId == 0) ? -1 :
	res.getDimensionPixelSize(tabMaxWidthResId);

	// Create a new adapter (with no content)
	final TextPagerAdapter newAdapter = new TextPagerAdapter();
	// And set it on the ViewPager
	onView(withId(R.id.tabs_viewpager)).perform(ViewPagerActions.setAdapter(newAdapter));

	// Replace the default TabLayout with the passed one
	onView(withId(R.id.container)).perform(TestUtilsActions.replaceTabLayout(tabLayoutResId));

	// Now that we have a new TabLayout, wire it to the new content of our ViewPager
	onView(withId(R.id.tabs)).perform(setupWithViewPager(mViewPager));

	// Since TabLayout doesn't expose a getter for fetching the configured max tab width,
	// start adding a variety of tabs with progressively longer tab titles and test that
	// no tab is wider than the configured max width. Before we start that test,
	// verify that we're in the scrollable mode so that each tab title gets as much width
	// as needed to display its text.
	assertEquals("Scrollable tab mode", TabLayout.MODE_SCROLLABLE, mTabLayout.getTabMode());

	final StringBuilder tabTitleBuilder = new StringBuilder();
	for (int i = 0; i < 40; i++) {
	final char titleComponent = (char) ('A' + i);
	for (int j = 0; j <= (i + 1); j++) {
	tabTitleBuilder.append(titleComponent);
	}
	final String tabTitle = tabTitleBuilder.toString();
	newAdapter.add(tabTitle, "Body " + i);
	onView(withId(R.id.tabs_viewpager)).perform(
	notifyAdapterContentChange());

	int expectedTabCount = i + 1;
	// Check that all tabs are at least as wide as min width and at most as wide as max
	// width specified in the XML for the newly loaded TabLayout
	for (int j = 0; j < expectedTabCount; j++) {
	// Find the view that is our tab title. It should be:
	// 1. Descendant of our TabLayout
	// 2. But not a direct child of the horizontal scroller
	// 3. With just-added title text
	// These conditions make sure that we're selecting the "top-level" tab view
	// instead of the inner (and narrower) TextView
	Matcher<View> tabMatcher = allOf(
	isDescendantOfA(withId(R.id.tabs)),
	not(withParent(isAssignableFrom(HorizontalScrollView.class))),
	hasDescendant(withText(tabTitle)));
	if (minTabWidth >= 0) {
	onView(tabMatcher).check(matches(
	TestUtilsMatchers.isNotNarrowerThan(minTabWidth)));
	}
	if (maxTabWidth >= 0) {
	onView(tabMatcher).check(matches(
	TestUtilsMatchers.isNotWiderThan(maxTabWidth)));
	}
	}

	// Reset the title builder for the next tab
	tabTitleBuilder.setLength(0);
	tabTitleBuilder.trimToSize();
	}

	}

	@Test
	@MediumTest
	public void testMinTabWidth() {
	verifyMinMaxTabWidth(R.layout.tab_layout_bound_min, R.dimen.tab_width_limit_medium, 0);
	}

	@Test
	@MediumTest
	public void testMaxTabWidth() {
	verifyMinMaxTabWidth(R.layout.tab_layout_bound_max, 0, R.dimen.tab_width_limit_medium);
	}

	@Test
	@MediumTest
	public void testMinMaxTabWidth() {
	verifyMinMaxTabWidth(R.layout.tab_layout_bound_minmax, R.dimen.tab_width_limit_small,
	R.dimen.tab_width_limit_large);
	}

	@Test
	@SmallTest
	public void testSetupAfterViewPagerScrolled() {
	// Scroll to the last item
	final int selected = mViewPager.getAdapter().getCount() - 1;
	onView(withId(R.id.tabs_viewpager)).perform(ViewPagerActions.scrollToPage(selected));

	// Now setup the TabLayout with the ViewPager
	setupTabLayoutWithViewPager();

	assertEquals("Selected page", selected, mViewPager.getCurrentItem());
	assertEquals("Selected tab", selected, mTabLayout.getSelectedTabPosition());
	}
	}