| /* |
| * Copyright (C) 2008 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.widget.cts; |
| |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertNotNull; |
| import static org.junit.Assert.assertNull; |
| import static org.junit.Assert.assertSame; |
| import static org.junit.Assert.assertTrue; |
| import static org.mockito.Mockito.any; |
| import static org.mockito.Mockito.anyInt; |
| import static org.mockito.Mockito.anyLong; |
| import static org.mockito.Mockito.atLeast; |
| import static org.mockito.Mockito.atLeastOnce; |
| import static org.mockito.Mockito.mock; |
| import static org.mockito.Mockito.never; |
| import static org.mockito.Mockito.reset; |
| import static org.mockito.Mockito.spy; |
| import static org.mockito.Mockito.times; |
| import static org.mockito.Mockito.verify; |
| import static org.mockito.Mockito.verifyNoMoreInteractions; |
| |
| import android.app.ActionBar.LayoutParams; |
| import android.app.Activity; |
| import android.app.Instrumentation; |
| import android.content.Context; |
| import android.graphics.Canvas; |
| import android.graphics.Color; |
| import android.graphics.Rect; |
| import android.graphics.drawable.ColorDrawable; |
| import android.graphics.drawable.Drawable; |
| import android.os.Parcelable; |
| import android.support.test.InstrumentationRegistry; |
| import android.support.test.annotation.UiThreadTest; |
| import android.support.test.filters.LargeTest; |
| import android.support.test.filters.MediumTest; |
| import android.support.test.filters.SmallTest; |
| import android.support.test.rule.ActivityTestRule; |
| import android.support.test.runner.AndroidJUnit4; |
| import android.util.AttributeSet; |
| import android.util.Pair; |
| import android.util.SparseArray; |
| import android.util.SparseBooleanArray; |
| import android.util.Xml; |
| import android.view.KeyEvent; |
| import android.view.View; |
| import android.view.ViewGroup; |
| import android.view.animation.LayoutAnimationController; |
| import android.widget.AbsListView; |
| import android.widget.AdapterView; |
| import android.widget.AdapterView.OnItemClickListener; |
| import android.widget.ArrayAdapter; |
| import android.widget.FrameLayout; |
| import android.widget.ListView; |
| import android.widget.TextView; |
| import android.widget.cts.util.TestUtils; |
| |
| import com.android.compatibility.common.util.CtsKeyEventUtil; |
| import com.android.compatibility.common.util.PollingCheck; |
| import com.android.compatibility.common.util.WidgetTestUtils; |
| |
| import junit.framework.Assert; |
| |
| import org.junit.Before; |
| import org.junit.Rule; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| import org.xmlpull.v1.XmlPullParser; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| import java.util.concurrent.CountDownLatch; |
| import java.util.concurrent.TimeUnit; |
| |
| @SmallTest |
| @RunWith(AndroidJUnit4.class) |
| public class ListViewTest { |
| private final String[] mCountryList = new String[] { |
| "Argentina", "Australia", "China", "France", "Germany", "Italy", "Japan", "United States" |
| }; |
| private final String[] mLongCountryList = new String[] { |
| "Argentina", "Australia", "Belize", "Botswana", "Brazil", "Cameroon", "China", "Cyprus", |
| "Denmark", "Djibouti", "Ethiopia", "Fiji", "Finland", "France", "Gabon", "Germany", |
| "Ghana", "Haiti", "Honduras", "Iceland", "India", "Indonesia", "Ireland", "Italy", |
| "Japan", "Kiribati", "Laos", "Lesotho", "Liberia", "Malaysia", "Mongolia", "Myanmar", |
| "Nauru", "Norway", "Oman", "Pakistan", "Philippines", "Portugal", "Romania", "Russia", |
| "Rwanda", "Singapore", "Slovakia", "Slovenia", "Somalia", "Swaziland", "Togo", "Tuvalu", |
| "Uganda", "Ukraine", "United States", "Vanuatu", "Venezuela", "Zimbabwe" |
| }; |
| private final String[] mNameList = new String[] { |
| "Jacky", "David", "Kevin", "Michael", "Andy" |
| }; |
| |
| private Instrumentation mInstrumentation; |
| private Activity mActivity; |
| private ListView mListView; |
| private TextView mTextView; |
| private TextView mSecondTextView; |
| |
| private AttributeSet mAttributeSet; |
| private ArrayAdapter<String> mAdapter_countries; |
| private ArrayAdapter<String> mAdapter_longCountries; |
| private ArrayAdapter<String> mAdapter_names; |
| |
| @Rule |
| public ActivityTestRule<ListViewCtsActivity> mActivityRule = |
| new ActivityTestRule<>(ListViewCtsActivity.class); |
| |
| @Before |
| public void setup() { |
| mInstrumentation = InstrumentationRegistry.getInstrumentation(); |
| mActivity = mActivityRule.getActivity(); |
| XmlPullParser parser = mActivity.getResources().getXml(R.layout.listview_layout); |
| mAttributeSet = Xml.asAttributeSet(parser); |
| |
| mAdapter_countries = new ArrayAdapter<>(mActivity, |
| android.R.layout.simple_list_item_1, mCountryList); |
| mAdapter_longCountries = new ArrayAdapter<>(mActivity, |
| android.R.layout.simple_list_item_1, mLongCountryList); |
| mAdapter_names = new ArrayAdapter<>(mActivity, android.R.layout.simple_list_item_1, |
| mNameList); |
| |
| mListView = (ListView) mActivity.findViewById(R.id.listview_default); |
| } |
| |
| @Test |
| public void testConstructor() { |
| new ListView(mActivity); |
| new ListView(mActivity, mAttributeSet); |
| new ListView(mActivity, mAttributeSet, 0); |
| } |
| |
| @Test(expected=NullPointerException.class) |
| public void testConstructorNullContext1() { |
| new ListView(null); |
| } |
| |
| @Test(expected=NullPointerException.class) |
| public void testConstructorNullContext2() { |
| new ListView(null, null); |
| } |
| |
| @Test(expected=NullPointerException.class) |
| public void testConstructorNullContext3() { |
| new ListView(null, null, -1); |
| } |
| |
| @Test |
| public void testGetMaxScrollAmount() throws Throwable { |
| setAdapter(mAdapter_names); |
| int scrollAmount = mListView.getMaxScrollAmount(); |
| assertTrue(scrollAmount > 0); |
| |
| mActivityRule.runOnUiThread(() -> { |
| mListView.getLayoutParams().height = 0; |
| mListView.requestLayout(); |
| }); |
| PollingCheck.waitFor(() -> mListView.getHeight() == 0); |
| |
| scrollAmount = mListView.getMaxScrollAmount(); |
| assertEquals(0, scrollAmount); |
| } |
| |
| private void setAdapter(final ArrayAdapter<String> adapter) throws Throwable { |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| () -> mListView.setAdapter(adapter)); |
| } |
| |
| @Test |
| public void testAccessDividerHeight() throws Throwable { |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| () -> mListView.setAdapter(mAdapter_countries)); |
| |
| Drawable d = mListView.getDivider(); |
| final Rect r = d.getBounds(); |
| PollingCheck.waitFor(() -> r.bottom - r.top > 0); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| () -> mListView.setDividerHeight(20)); |
| |
| assertEquals(20, mListView.getDividerHeight()); |
| assertEquals(20, r.bottom - r.top); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| () -> mListView.setDividerHeight(10)); |
| |
| assertEquals(10, mListView.getDividerHeight()); |
| assertEquals(10, r.bottom - r.top); |
| } |
| |
| @Test |
| public void testAccessItemsCanFocus() { |
| mListView.setItemsCanFocus(true); |
| assertTrue(mListView.getItemsCanFocus()); |
| |
| mListView.setItemsCanFocus(false); |
| assertFalse(mListView.getItemsCanFocus()); |
| |
| // TODO: how to check? |
| } |
| |
| @Test |
| public void testAccessAdapter() throws Throwable { |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| () -> mListView.setAdapter(mAdapter_countries)); |
| |
| assertSame(mAdapter_countries, mListView.getAdapter()); |
| assertEquals(mCountryList.length, mListView.getCount()); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| () -> mListView.setAdapter(mAdapter_names)); |
| |
| assertSame(mAdapter_names, mListView.getAdapter()); |
| assertEquals(mNameList.length, mListView.getCount()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testAccessItemChecked() { |
| // NONE mode |
| mListView.setChoiceMode(ListView.CHOICE_MODE_NONE); |
| assertEquals(ListView.CHOICE_MODE_NONE, mListView.getChoiceMode()); |
| |
| mListView.setItemChecked(1, true); |
| assertEquals(ListView.INVALID_POSITION, mListView.getCheckedItemPosition()); |
| assertFalse(mListView.isItemChecked(1)); |
| |
| // SINGLE mode |
| mListView.setChoiceMode(ListView.CHOICE_MODE_SINGLE); |
| assertEquals(ListView.CHOICE_MODE_SINGLE, mListView.getChoiceMode()); |
| |
| mListView.setItemChecked(2, true); |
| assertEquals(2, mListView.getCheckedItemPosition()); |
| assertTrue(mListView.isItemChecked(2)); |
| |
| mListView.setItemChecked(3, true); |
| assertEquals(3, mListView.getCheckedItemPosition()); |
| assertTrue(mListView.isItemChecked(3)); |
| assertFalse(mListView.isItemChecked(2)); |
| |
| // test attempt to uncheck a item that wasn't checked to begin with |
| mListView.setItemChecked(4, false); |
| // item three should still be checked |
| assertEquals(3, mListView.getCheckedItemPosition()); |
| assertFalse(mListView.isItemChecked(4)); |
| assertTrue(mListView.isItemChecked(3)); |
| assertFalse(mListView.isItemChecked(2)); |
| |
| mListView.setItemChecked(4, true); |
| assertTrue(mListView.isItemChecked(4)); |
| mListView.clearChoices(); |
| assertEquals(ListView.INVALID_POSITION, mListView.getCheckedItemPosition()); |
| assertFalse(mListView.isItemChecked(4)); |
| |
| // MULTIPLE mode |
| mListView.setChoiceMode(ListView.CHOICE_MODE_MULTIPLE); |
| assertEquals(ListView.CHOICE_MODE_MULTIPLE, mListView.getChoiceMode()); |
| |
| mListView.setItemChecked(1, true); |
| assertEquals(ListView.INVALID_POSITION, mListView.getCheckedItemPosition()); |
| SparseBooleanArray array = mListView.getCheckedItemPositions(); |
| assertTrue(array.get(1)); |
| assertFalse(array.get(2)); |
| assertTrue(mListView.isItemChecked(1)); |
| assertFalse(mListView.isItemChecked(2)); |
| |
| mListView.setItemChecked(2, true); |
| mListView.setItemChecked(3, false); |
| mListView.setItemChecked(4, true); |
| |
| assertTrue(array.get(1)); |
| assertTrue(array.get(2)); |
| assertFalse(array.get(3)); |
| assertTrue(array.get(4)); |
| assertTrue(mListView.isItemChecked(1)); |
| assertTrue(mListView.isItemChecked(2)); |
| assertFalse(mListView.isItemChecked(3)); |
| assertTrue(mListView.isItemChecked(4)); |
| |
| mListView.clearChoices(); |
| assertFalse(array.get(1)); |
| assertFalse(array.get(2)); |
| assertFalse(array.get(3)); |
| assertFalse(array.get(4)); |
| assertFalse(mListView.isItemChecked(1)); |
| assertFalse(mListView.isItemChecked(2)); |
| assertFalse(mListView.isItemChecked(3)); |
| assertFalse(mListView.isItemChecked(4)); |
| } |
| |
| @Test |
| public void testAccessFooterView() throws Throwable { |
| mActivityRule.runOnUiThread(() -> { |
| mTextView = new TextView(mActivity); |
| mTextView.setText("footerview1"); |
| mSecondTextView = new TextView(mActivity); |
| mSecondTextView.setText("footerview2"); |
| }); |
| mInstrumentation.waitForIdleSync(); |
| |
| mActivityRule.runOnUiThread(() -> mListView.setFooterDividersEnabled(true)); |
| assertTrue(mListView.areFooterDividersEnabled()); |
| assertEquals(0, mListView.getFooterViewsCount()); |
| |
| mActivityRule.runOnUiThread(() -> mListView.addFooterView(mTextView, null, true)); |
| assertTrue(mListView.areFooterDividersEnabled()); |
| assertEquals(1, mListView.getFooterViewsCount()); |
| |
| mActivityRule.runOnUiThread(() -> { |
| mListView.setFooterDividersEnabled(false); |
| mListView.addFooterView(mSecondTextView); |
| }); |
| assertFalse(mListView.areFooterDividersEnabled()); |
| assertEquals(2, mListView.getFooterViewsCount()); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| () -> mListView.setAdapter(mAdapter_countries)); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| () -> mListView.removeFooterView(mTextView)); |
| assertFalse(mListView.areFooterDividersEnabled()); |
| assertEquals(1, mListView.getFooterViewsCount()); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| () -> mListView.removeFooterView(mSecondTextView)); |
| assertFalse(mListView.areFooterDividersEnabled()); |
| assertEquals(0, mListView.getFooterViewsCount()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testAccessHeaderView() { |
| final TextView headerView1 = (TextView) mActivity.findViewById(R.id.headerview1); |
| final TextView headerView2 = (TextView) mActivity.findViewById(R.id.headerview2); |
| ((ViewGroup) headerView1.getParent()).removeView(headerView1); |
| ((ViewGroup) headerView2.getParent()).removeView(headerView2); |
| |
| mListView.setHeaderDividersEnabled(true); |
| assertTrue(mListView.areHeaderDividersEnabled()); |
| assertEquals(0, mListView.getHeaderViewsCount()); |
| |
| mListView.addHeaderView(headerView2, null, true); |
| assertTrue(mListView.areHeaderDividersEnabled()); |
| assertEquals(1, mListView.getHeaderViewsCount()); |
| |
| mListView.setHeaderDividersEnabled(false); |
| mListView.addHeaderView(headerView1); |
| assertFalse(mListView.areHeaderDividersEnabled()); |
| assertEquals(2, mListView.getHeaderViewsCount()); |
| |
| mListView.removeHeaderView(headerView2); |
| assertFalse(mListView.areHeaderDividersEnabled()); |
| assertEquals(1, mListView.getHeaderViewsCount()); |
| } |
| |
| @Test |
| public void testHeaderFooterType() throws Throwable { |
| mActivityRule.runOnUiThread(() -> mTextView = new TextView(mActivity)); |
| mInstrumentation.waitForIdleSync(); |
| final List<Pair<View, View>> mismatch = new ArrayList<>(); |
| final ArrayAdapter adapter = new ArrayAdapter<String>(mActivity, |
| android.R.layout.simple_list_item_1, mNameList) { |
| @Override |
| public int getItemViewType(int position) { |
| return position == 0 ? AdapterView.ITEM_VIEW_TYPE_HEADER_OR_FOOTER : |
| super.getItemViewType(position - 1); |
| } |
| |
| @Override |
| public View getView(int position, View convertView, ViewGroup parent) { |
| if (position == 0) { |
| if (convertView != null && convertView != mTextView) { |
| mismatch.add(new Pair<>(mTextView, convertView)); |
| } |
| return mTextView; |
| } else { |
| return super.getView(position - 1, convertView, parent); |
| } |
| } |
| |
| @Override |
| public int getCount() { |
| return super.getCount() + 1; |
| } |
| }; |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| () -> mListView.setAdapter(adapter)); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| adapter::notifyDataSetChanged); |
| |
| assertEquals(0, mismatch.size()); |
| } |
| |
| @Test |
| public void testAccessDivider() throws Throwable { |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| () -> mListView.setAdapter(mAdapter_countries)); |
| |
| Drawable defaultDrawable = mListView.getDivider(); |
| final Rect r = defaultDrawable.getBounds(); |
| PollingCheck.waitFor(() -> r.bottom - r.top > 0); |
| |
| final Drawable d = mActivity.getResources().getDrawable(R.drawable.scenery); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| () -> mListView.setDivider(d)); |
| assertSame(d, mListView.getDivider()); |
| assertEquals(d.getBounds().height(), mListView.getDividerHeight()); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| () -> mListView.setDividerHeight(10)); |
| assertEquals(10, mListView.getDividerHeight()); |
| assertEquals(10, d.getBounds().height()); |
| } |
| |
| @Test |
| public void testSetSelection() throws Throwable { |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| () -> mListView.setAdapter(mAdapter_countries)); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| () -> mListView.setSelection(1)); |
| String item = (String) mListView.getSelectedItem(); |
| assertEquals(mCountryList[1], item); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| () -> mListView.setSelectionFromTop(5, 0)); |
| item = (String) mListView.getSelectedItem(); |
| assertEquals(mCountryList[5], item); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| mListView::setSelectionAfterHeaderView); |
| item = (String) mListView.getSelectedItem(); |
| assertEquals(mCountryList[0], item); |
| } |
| |
| @Test |
| public void testPerformItemClick() throws Throwable { |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| () -> mListView.setAdapter(mAdapter_countries)); |
| |
| mListView.setChoiceMode(ListView.CHOICE_MODE_SINGLE); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| () -> mListView.setSelection(2)); |
| |
| mActivityRule.runOnUiThread(() -> |
| mTextView = (TextView) mAdapter_countries.getView(2, null, mListView)); |
| mInstrumentation.waitForIdleSync(); |
| assertNotNull(mTextView); |
| assertEquals(mCountryList[2], mTextView.getText().toString()); |
| final long itemID = mAdapter_countries.getItemId(2); |
| assertEquals(2, itemID); |
| |
| mActivityRule.runOnUiThread(() -> mListView.performItemClick(mTextView, 2, itemID)); |
| mInstrumentation.waitForIdleSync(); |
| |
| OnItemClickListener onClickListener = mock(OnItemClickListener.class); |
| mListView.setOnItemClickListener(onClickListener); |
| verify(onClickListener, never()).onItemClick(any(AdapterView.class), any(View.class), |
| anyInt(), anyLong()); |
| |
| mActivityRule.runOnUiThread(() -> mListView.performItemClick(mTextView, 2, itemID)); |
| mInstrumentation.waitForIdleSync(); |
| |
| verify(onClickListener, times(1)).onItemClick(mListView, mTextView, 2, 2L); |
| verifyNoMoreInteractions(onClickListener); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testSaveAndRestoreInstanceState_positionIsRestored() { |
| mListView.setAdapter(mAdapter_countries); |
| assertEquals(0, mListView.getSelectedItemPosition()); |
| |
| int positionToTest = mAdapter_countries.getCount() - 1; |
| mListView.setSelection(positionToTest); |
| assertEquals(positionToTest, mListView.getSelectedItemPosition()); |
| Parcelable savedState = mListView.onSaveInstanceState(); |
| |
| mListView.setSelection(positionToTest - 1); |
| assertEquals(positionToTest - 1, mListView.getSelectedItemPosition()); |
| |
| mListView.onRestoreInstanceState(savedState); |
| int measureSpec = View.MeasureSpec.makeMeasureSpec(100, View.MeasureSpec.EXACTLY); |
| mListView.measure(measureSpec,measureSpec); |
| mListView.layout(0, 0, 100, 100); |
| assertEquals(positionToTest, mListView.getSelectedItemPosition()); |
| } |
| |
| @Test |
| public void testDispatchKeyEvent() throws Throwable { |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| () -> { |
| mListView.setAdapter(mAdapter_countries); |
| mListView.requestFocus(); |
| }); |
| assertTrue(mListView.hasFocus()); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| () -> mListView.setSelection(1)); |
| String item = (String) mListView.getSelectedItem(); |
| assertEquals(mCountryList[1], item); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| () -> { |
| KeyEvent keyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_A); |
| mListView.dispatchKeyEvent(keyEvent); |
| }); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| () -> { |
| KeyEvent keyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, |
| KeyEvent.KEYCODE_DPAD_DOWN); |
| mListView.dispatchKeyEvent(keyEvent); |
| mListView.dispatchKeyEvent(keyEvent); |
| mListView.dispatchKeyEvent(keyEvent); |
| }); |
| item = (String)mListView.getSelectedItem(); |
| assertEquals(mCountryList[4], item); |
| } |
| |
| @Test |
| public void testRequestChildRectangleOnScreen() throws Throwable { |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| () -> mListView.setAdapter(mAdapter_countries)); |
| |
| mActivityRule.runOnUiThread(() -> |
| mTextView = (TextView) mAdapter_countries.getView(0, null, mListView)); |
| mInstrumentation.waitForIdleSync(); |
| assertNotNull(mTextView); |
| assertEquals(mCountryList[0], mTextView.getText().toString()); |
| |
| Rect rect = new Rect(0, 0, 10, 10); |
| assertFalse(mListView.requestChildRectangleOnScreen(mTextView, rect, false)); |
| |
| // TODO: how to check? |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testCanAnimate() { |
| MyListView listView = new MyListView(mActivity, mAttributeSet); |
| |
| assertFalse(listView.canAnimate()); |
| listView.setAdapter(mAdapter_countries); |
| assertFalse(listView.canAnimate()); |
| |
| LayoutAnimationController controller = new LayoutAnimationController( |
| mActivity, mAttributeSet); |
| listView.setLayoutAnimation(controller); |
| |
| assertTrue(listView.canAnimate()); |
| } |
| |
| |
| @UiThreadTest |
| @Test |
| public void testFindViewTraversal() { |
| MyListView listView = new MyListView(mActivity, mAttributeSet); |
| TextView headerView = (TextView) mActivity.findViewById(R.id.headerview1); |
| ((ViewGroup) headerView.getParent()).removeView(headerView); |
| |
| assertNull(listView.findViewTraversal(R.id.headerview1)); |
| |
| listView.addHeaderView(headerView); |
| assertNotNull(listView.findViewTraversal(R.id.headerview1)); |
| assertSame(headerView, listView.findViewTraversal(R.id.headerview1)); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testFindViewWithTagTraversal() { |
| MyListView listView = new MyListView(mActivity, mAttributeSet); |
| TextView headerView = (TextView) mActivity.findViewById(R.id.headerview1); |
| ((ViewGroup) headerView.getParent()).removeView(headerView); |
| |
| assertNull(listView.findViewWithTagTraversal("header")); |
| |
| headerView.setTag("header"); |
| listView.addHeaderView(headerView); |
| assertNotNull(listView.findViewWithTagTraversal("header")); |
| assertSame(headerView, listView.findViewWithTagTraversal("header")); |
| } |
| |
| /** |
| * MyListView for test |
| */ |
| private static class MyListView extends ListView { |
| public MyListView(Context context, AttributeSet attrs) { |
| super(context, attrs); |
| } |
| |
| @Override |
| protected boolean canAnimate() { |
| return super.canAnimate(); |
| } |
| |
| @Override |
| protected void dispatchDraw(Canvas canvas) { |
| super.dispatchDraw(canvas); |
| } |
| |
| @Override |
| protected View findViewTraversal(int id) { |
| return super.findViewTraversal(id); |
| } |
| |
| @Override |
| protected View findViewWithTagTraversal(Object tag) { |
| return super.findViewWithTagTraversal(tag); |
| } |
| |
| @Override |
| protected void layoutChildren() { |
| super.layoutChildren(); |
| } |
| } |
| |
| @MediumTest |
| @UiThreadTest |
| @Test |
| public void testRequestLayoutCallsMeasure() { |
| List<String> items = new ArrayList<>(); |
| items.add("hello"); |
| MockAdapter<String> adapter = new MockAdapter<>(mActivity, 0, items); |
| mListView.setAdapter(adapter); |
| |
| int measureSpec = View.MeasureSpec.makeMeasureSpec(100, View.MeasureSpec.EXACTLY); |
| |
| adapter.notifyDataSetChanged(); |
| mListView.measure(measureSpec, measureSpec); |
| mListView.layout(0, 0, 100, 100); |
| |
| MockView childView = (MockView) mListView.getChildAt(0); |
| |
| childView.requestLayout(); |
| childView.onMeasureCalled = false; |
| mListView.measure(measureSpec, measureSpec); |
| mListView.layout(0, 0, 100, 100); |
| Assert.assertTrue(childView.onMeasureCalled); |
| } |
| |
| @MediumTest |
| @UiThreadTest |
| @Test |
| public void testNoSelectableItems() throws Exception { |
| // We use a header as the unselectable item to remain after the selectable one is removed. |
| mListView.addHeaderView(new View(mActivity), null, false); |
| List<String> items = new ArrayList<>(); |
| items.add("hello"); |
| MockAdapter<String> adapter = new MockAdapter<>(mActivity, 0, items); |
| mListView.setAdapter(adapter); |
| |
| mListView.setSelection(1); |
| |
| int measureSpec = View.MeasureSpec.makeMeasureSpec(100, View.MeasureSpec.EXACTLY); |
| |
| adapter.notifyDataSetChanged(); |
| mListView.measure(measureSpec, measureSpec); |
| mListView.layout(0, 0, 100, 100); |
| |
| items.remove(0); |
| |
| adapter.notifyDataSetChanged(); |
| mListView.measure(measureSpec, measureSpec); |
| mListView.layout(0, 0, 100, 100); |
| } |
| |
| @MediumTest |
| @Test |
| public void testFullDetachHeaderViewOnScroll() throws Throwable { |
| final AttachDetachAwareView header = new AttachDetachAwareView(mActivity); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, () -> { |
| mListView.setAdapter(new DummyAdapter(1000)); |
| mListView.addHeaderView(header); |
| }); |
| assertEquals("test sanity", 1, header.mOnAttachCount); |
| assertEquals("test sanity", 0, header.mOnDetachCount); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, () -> { |
| mListView.scrollListBy(mListView.getHeight() * 3); |
| }); |
| assertNull("test sanity, header should be removed", header.getParent()); |
| assertEquals("header view should be detached", 1, header.mOnDetachCount); |
| assertFalse(header.isTemporarilyDetached()); |
| } |
| |
| @MediumTest |
| @Test |
| public void testFullDetachHeaderViewOnRelayout() throws Throwable { |
| final AttachDetachAwareView header = new AttachDetachAwareView(mActivity); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, () -> { |
| mListView.setAdapter(new DummyAdapter(1000)); |
| mListView.addHeaderView(header); |
| }); |
| assertEquals("test sanity", 1, header.mOnAttachCount); |
| assertEquals("test sanity", 0, header.mOnDetachCount); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, () -> { |
| mListView.setSelection(800); |
| }); |
| assertNull("test sanity, header should be removed", header.getParent()); |
| assertEquals("header view should be detached", 1, header.mOnDetachCount); |
| assertFalse(header.isTemporarilyDetached()); |
| } |
| |
| @MediumTest |
| @Test |
| public void testFullDetachHeaderViewOnScrollForFocus() throws Throwable { |
| final AttachDetachAwareView header = new AttachDetachAwareView(mActivity); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, () -> { |
| mListView.setAdapter(new DummyAdapter(1000)); |
| mListView.addHeaderView(header); |
| }); |
| assertEquals("test sanity", 1, header.mOnAttachCount); |
| assertEquals("test sanity", 0, header.mOnDetachCount); |
| while(header.getParent() != null) { |
| assertEquals("header view should NOT be detached", 0, header.mOnDetachCount); |
| CtsKeyEventUtil.sendKeys(mInstrumentation, mListView, KeyEvent.KEYCODE_DPAD_DOWN); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, null); |
| } |
| assertEquals("header view should be detached", 1, header.mOnDetachCount); |
| assertFalse(header.isTemporarilyDetached()); |
| } |
| |
| @MediumTest |
| @Test |
| public void testFullyDetachUnusedViewOnScroll() throws Throwable { |
| final AttachDetachAwareView theView = new AttachDetachAwareView(mActivity); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, () -> { |
| mListView.setAdapter(new DummyAdapter(1000, theView)); |
| }); |
| assertEquals("test sanity", 1, theView.mOnAttachCount); |
| assertEquals("test sanity", 0, theView.mOnDetachCount); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, () -> { |
| mListView.scrollListBy(mListView.getHeight() * 2); |
| }); |
| assertNull("test sanity, unused view should be removed", theView.getParent()); |
| assertEquals("unused view should be detached", 1, theView.mOnDetachCount); |
| assertFalse(theView.isTemporarilyDetached()); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, () -> { |
| mListView.scrollListBy(-mListView.getHeight() * 2); |
| // listview limits scroll to 1 page which is why we call it twice here. |
| mListView.scrollListBy(-mListView.getHeight() * 2); |
| }); |
| assertNotNull("test sanity, view should be re-added", theView.getParent()); |
| assertEquals("view should receive another attach call", 2, theView.mOnAttachCount); |
| assertEquals("view should not receive a detach call", 1, theView.mOnDetachCount); |
| assertFalse(theView.isTemporarilyDetached()); |
| } |
| |
| @MediumTest |
| @Test |
| public void testFullyDetachUnusedViewOnReLayout() throws Throwable { |
| final AttachDetachAwareView theView = new AttachDetachAwareView(mActivity); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, () -> { |
| mListView.setAdapter(new DummyAdapter(1000, theView)); |
| }); |
| assertEquals("test sanity", 1, theView.mOnAttachCount); |
| assertEquals("test sanity", 0, theView.mOnDetachCount); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, () -> { |
| mListView.setSelection(800); |
| }); |
| assertNull("test sanity, unused view should be removed", theView.getParent()); |
| assertEquals("unused view should be detached", 1, theView.mOnDetachCount); |
| assertFalse(theView.isTemporarilyDetached()); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, () -> { |
| mListView.setSelection(0); |
| }); |
| assertNotNull("test sanity, view should be re-added", theView.getParent()); |
| assertEquals("view should receive another attach call", 2, theView.mOnAttachCount); |
| assertEquals("view should not receive a detach call", 1, theView.mOnDetachCount); |
| assertFalse(theView.isTemporarilyDetached()); |
| } |
| |
| @MediumTest |
| @Test |
| public void testFullyDetachUnusedViewOnScrollForFocus() throws Throwable { |
| final AttachDetachAwareView theView = new AttachDetachAwareView(mActivity); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, () -> { |
| mListView.setAdapter(new DummyAdapter(1000, theView)); |
| }); |
| assertEquals("test sanity", 1, theView.mOnAttachCount); |
| assertEquals("test sanity", 0, theView.mOnDetachCount); |
| while(theView.getParent() != null) { |
| assertEquals("the view should NOT be detached", 0, theView.mOnDetachCount); |
| CtsKeyEventUtil.sendKeys(mInstrumentation, mListView, KeyEvent.KEYCODE_DPAD_DOWN); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, null); |
| } |
| assertEquals("the view should be detached", 1, theView.mOnDetachCount); |
| assertFalse(theView.isTemporarilyDetached()); |
| while(theView.getParent() == null) { |
| CtsKeyEventUtil.sendKeys(mInstrumentation, mListView, KeyEvent.KEYCODE_DPAD_UP); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, null); |
| } |
| assertEquals("the view should be re-attached", 2, theView.mOnAttachCount); |
| assertEquals("the view should not recieve another detach", 1, theView.mOnDetachCount); |
| assertFalse(theView.isTemporarilyDetached()); |
| } |
| |
| @MediumTest |
| @Test |
| public void testSetPadding() throws Throwable { |
| View view = new View(mActivity); |
| view.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, |
| ViewGroup.LayoutParams.WRAP_CONTENT)); |
| view.setMinimumHeight(30); |
| final DummyAdapter adapter = new DummyAdapter(2, view); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, () -> { |
| mListView.setLayoutParams(new FrameLayout.LayoutParams(200, 100)); |
| mListView.setAdapter(adapter); |
| }); |
| assertEquals("test sanity", 200, mListView.getWidth()); |
| assertEquals(200, view.getWidth()); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, () -> { |
| mListView.setPadding(10, 0, 5, 0); |
| assertTrue(view.isLayoutRequested()); |
| }); |
| assertEquals(185, view.getWidth()); |
| assertFalse(view.isLayoutRequested()); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, () -> { |
| mListView.setPadding(10, 0, 5, 0); |
| assertFalse(view.isLayoutRequested()); |
| }); |
| } |
| |
| @MediumTest |
| @Test |
| public void testResolveRtlOnReAttach() throws Throwable { |
| View spacer = new View(mActivity); |
| spacer.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, |
| 250)); |
| final DummyAdapter adapter = new DummyAdapter(50, spacer); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, () -> { |
| mListView.setLayoutDirection(View.LAYOUT_DIRECTION_RTL); |
| mListView.setLayoutParams(new FrameLayout.LayoutParams(200, 150)); |
| mListView.setAdapter(adapter); |
| }); |
| assertEquals("test sanity", 1, mListView.getChildCount()); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, () -> { |
| // we scroll in pieces because list view caps scroll by its height |
| mListView.scrollListBy(100); |
| mListView.scrollListBy(100); |
| mListView.scrollListBy(60); |
| }); |
| assertEquals("test sanity", 1, mListView.getChildCount()); |
| assertEquals("test sanity", 1, mListView.getFirstVisiblePosition()); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, () -> { |
| mListView.scrollListBy(-100); |
| mListView.scrollListBy(-100); |
| mListView.scrollListBy(-60); |
| }); |
| assertEquals("test sanity", 1, mListView.getChildCount()); |
| assertEquals("item 0 should be visible", 0, mListView.getFirstVisiblePosition()); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, () -> { |
| mListView.scrollListBy(100); |
| mListView.scrollListBy(100); |
| mListView.scrollListBy(60); |
| }); |
| assertEquals("test sanity", 1, mListView.getChildCount()); |
| assertEquals("test sanity", 1, mListView.getFirstVisiblePosition()); |
| |
| assertEquals("the view's RTL properties must be resolved", |
| mListView.getChildAt(0).getLayoutDirection(), View.LAYOUT_DIRECTION_RTL); |
| } |
| |
| private class MockView extends View { |
| |
| public boolean onMeasureCalled = false; |
| |
| public MockView(Context context) { |
| super(context); |
| } |
| |
| @Override |
| protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { |
| super.onMeasure(widthMeasureSpec, heightMeasureSpec); |
| onMeasureCalled = true; |
| } |
| } |
| |
| private class MockAdapter<T> extends ArrayAdapter<T> { |
| |
| public MockAdapter(Context context, int resource, List<T> objects) { |
| super(context, resource, objects); |
| } |
| |
| @Override |
| public View getView(int position, View convertView, ViewGroup parent) { |
| return new MockView(getContext()); |
| } |
| } |
| |
| @MediumTest |
| @Test |
| public void testRequestLayoutWithTemporaryDetach() throws Throwable { |
| List<String> items = new ArrayList<>(); |
| items.add("0"); |
| items.add("1"); |
| items.add("2"); |
| final TemporarilyDetachableMockViewAdapter<String> adapter = |
| new TemporarilyDetachableMockViewAdapter<>( |
| mActivity, android.R.layout.simple_list_item_1, items); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| () -> mListView.setAdapter(adapter)); |
| |
| assertEquals(items.size(), mListView.getCount()); |
| final TemporarilyDetachableMockView childView0 = |
| (TemporarilyDetachableMockView) mListView.getChildAt(0); |
| final TemporarilyDetachableMockView childView1 = |
| (TemporarilyDetachableMockView) mListView.getChildAt(1); |
| final TemporarilyDetachableMockView childView2 = |
| (TemporarilyDetachableMockView) mListView.getChildAt(2); |
| assertNotNull(childView0); |
| assertNotNull(childView1); |
| assertNotNull(childView2); |
| |
| // Make sure that the childView1 has focus. |
| mActivityRule.runOnUiThread(childView1::requestFocus); |
| PollingCheck.waitFor(1000, childView1::isFocused); |
| |
| // Make sure that ListView#requestLayout() is optimized when nothing is changed. |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, mListView::requestLayout); |
| assertEquals(childView0, mListView.getChildAt(0)); |
| assertEquals(childView1, mListView.getChildAt(1)); |
| assertEquals(childView2, mListView.getChildAt(2)); |
| } |
| |
| @MediumTest |
| @Test |
| public void testJumpDrawables() throws Throwable { |
| FrameLayout layout = new FrameLayout(mActivity); |
| ListView listView = new ListView(mActivity); |
| ArrayAdapterWithMockDrawable adapter = new ArrayAdapterWithMockDrawable(mActivity); |
| for (int i = 0; i < 50; i++) { |
| adapter.add(Integer.toString(i)); |
| } |
| |
| // Initial state should jump exactly once during attach. |
| mActivityRule.runOnUiThread(() -> { |
| listView.setAdapter(adapter); |
| layout.addView(listView, new LayoutParams(LayoutParams.MATCH_PARENT, 200)); |
| mActivity.setContentView(layout); |
| }); |
| mInstrumentation.waitForIdleSync(); |
| assertTrue("List is not showing any children", listView.getChildCount() > 0); |
| Drawable firstBackground = listView.getChildAt(0).getBackground(); |
| verify(firstBackground, times(1)).jumpToCurrentState(); |
| |
| // Lay out views without recycling. This should not jump again. |
| mActivityRule.runOnUiThread(() -> listView.requestLayout()); |
| mInstrumentation.waitForIdleSync(); |
| assertSame(firstBackground, listView.getChildAt(0).getBackground()); |
| verify(firstBackground, times(1)).jumpToCurrentState(); |
| |
| // If we're on a really big display, we might be in a position where |
| // the position we're going to scroll to is already visible, in which |
| // case we won't be able to test jump behavior when recycling. |
| int lastVisiblePosition = listView.getLastVisiblePosition(); |
| int targetPosition = adapter.getCount() - 1; |
| if (targetPosition <= lastVisiblePosition) { |
| return; |
| } |
| |
| // Reset the call counts before continuing, since the backgrounds may |
| // be recycled from either views that were on-screen or in the scrap |
| // heap, and those would have slightly different call counts. |
| adapter.resetMockBackgrounds(); |
| |
| // Scroll so that we have new views on screen. This should jump at |
| // least once when the view is recycled in a new position (but may be |
| // more if it was recycled from a view that was previously on-screen). |
| mActivityRule.runOnUiThread(() -> listView.setSelection(targetPosition)); |
| mInstrumentation.waitForIdleSync(); |
| |
| View lastChild = listView.getChildAt(listView.getChildCount() - 1); |
| verify(lastChild.getBackground(), atLeast(1)).jumpToCurrentState(); |
| |
| // Reset the call counts before continuing. |
| adapter.resetMockBackgrounds(); |
| |
| // Scroll back to the top. This should jump at least once when the view |
| // is recycled in a new position (but may be more if it was recycled |
| // from a view that was previously on-screen). |
| mActivityRule.runOnUiThread(() -> listView.setSelection(0)); |
| mInstrumentation.waitForIdleSync(); |
| |
| View firstChild = listView.getChildAt(0); |
| verify(firstChild.getBackground(), atLeast(1)).jumpToCurrentState(); |
| } |
| |
| private static class ArrayAdapterWithMockDrawable extends ArrayAdapter<String> { |
| private SparseArray<Drawable> mBackgrounds = new SparseArray<>(); |
| |
| public ArrayAdapterWithMockDrawable(Context context) { |
| super(context, android.R.layout.simple_list_item_1); |
| } |
| |
| @Override |
| public View getView(int position, View convertView, ViewGroup parent) { |
| final View view = super.getView(position, convertView, parent); |
| if (view.getBackground() == null) { |
| view.setBackground(spy(new ColorDrawable(Color.BLACK))); |
| } |
| return view; |
| } |
| |
| public void resetMockBackgrounds() { |
| for (int i = 0; i < mBackgrounds.size(); i++) { |
| Drawable background = mBackgrounds.valueAt(i); |
| reset(background); |
| } |
| } |
| } |
| |
| private class TemporarilyDetachableMockView extends View { |
| |
| private boolean mIsDispatchingStartTemporaryDetach = false; |
| private boolean mIsDispatchingFinishTemporaryDetach = false; |
| |
| public TemporarilyDetachableMockView(Context context) { |
| super(context); |
| } |
| |
| @Override |
| public void dispatchStartTemporaryDetach() { |
| mIsDispatchingStartTemporaryDetach = true; |
| super.dispatchStartTemporaryDetach(); |
| mIsDispatchingStartTemporaryDetach = false; |
| } |
| |
| @Override |
| public void dispatchFinishTemporaryDetach() { |
| mIsDispatchingFinishTemporaryDetach = true; |
| super.dispatchFinishTemporaryDetach(); |
| mIsDispatchingFinishTemporaryDetach = false; |
| } |
| |
| @Override |
| public void onStartTemporaryDetach() { |
| super.onStartTemporaryDetach(); |
| if (!mIsDispatchingStartTemporaryDetach) { |
| throw new IllegalStateException("#onStartTemporaryDetach() must be indirectly" |
| + " called via #dispatchStartTemporaryDetach()"); |
| } |
| } |
| |
| @Override |
| public void onFinishTemporaryDetach() { |
| super.onFinishTemporaryDetach(); |
| if (!mIsDispatchingFinishTemporaryDetach) { |
| throw new IllegalStateException("#onStartTemporaryDetach() must be indirectly" |
| + " called via #dispatchFinishTemporaryDetach()"); |
| } |
| } |
| } |
| |
| private class TemporarilyDetachableMockViewAdapter<T> extends ArrayAdapter<T> { |
| ArrayList<TemporarilyDetachableMockView> views = new ArrayList<>(); |
| |
| public TemporarilyDetachableMockViewAdapter(Context context, int textViewResourceId, |
| List<T> objects) { |
| super(context, textViewResourceId, objects); |
| for (int i = 0; i < objects.size(); i++) { |
| views.add(new TemporarilyDetachableMockView(context)); |
| views.get(i).setFocusable(true); |
| } |
| } |
| |
| @Override |
| public int getCount() { |
| return views.size(); |
| } |
| |
| @Override |
| public long getItemId(int position) { |
| return position; |
| } |
| |
| @Override |
| public View getView(int position, View convertView, ViewGroup parent) { |
| View result = views.get(position); |
| ViewGroup.LayoutParams lp = new ViewGroup.LayoutParams( |
| ViewGroup.LayoutParams.MATCH_PARENT, 40); |
| result.setLayoutParams(lp); |
| return result; |
| } |
| } |
| |
| @Test |
| public void testTransientStateUnstableIds() throws Throwable { |
| final ListView listView = mListView; |
| final ArrayList<String> items = new ArrayList<String>(Arrays.asList(mCountryList)); |
| final ArrayAdapter<String> adapter = new ArrayAdapter<String>(mActivity, |
| android.R.layout.simple_list_item_1, items); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, listView, |
| () -> listView.setAdapter(adapter)); |
| |
| final View oldItem = listView.getChildAt(2); |
| final CharSequence oldText = ((TextView) oldItem.findViewById(android.R.id.text1)) |
| .getText(); |
| oldItem.setHasTransientState(true); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, listView, |
| () -> { |
| adapter.remove(adapter.getItem(0)); |
| adapter.notifyDataSetChanged(); |
| }); |
| |
| final View newItem = listView.getChildAt(2); |
| final CharSequence newText = ((TextView) newItem.findViewById(android.R.id.text1)) |
| .getText(); |
| |
| Assert.assertFalse(oldText.equals(newText)); |
| } |
| |
| @Test |
| public void testTransientStateStableIds() throws Throwable { |
| final ArrayList<String> items = new ArrayList<>(Arrays.asList(mCountryList)); |
| final StableArrayAdapter<String> adapter = new StableArrayAdapter<>(mActivity, |
| android.R.layout.simple_list_item_1, items); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| () -> mListView.setAdapter(adapter)); |
| |
| final Object tag = new Object(); |
| final View oldItem = mListView.getChildAt(2); |
| final CharSequence oldText = ((TextView) oldItem.findViewById(android.R.id.text1)) |
| .getText(); |
| oldItem.setHasTransientState(true); |
| oldItem.setTag(tag); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| () -> { |
| adapter.remove(adapter.getItem(0)); |
| adapter.notifyDataSetChanged(); |
| }); |
| |
| final View newItem = mListView.getChildAt(1); |
| final CharSequence newText = ((TextView) newItem.findViewById(android.R.id.text1)) |
| .getText(); |
| |
| Assert.assertTrue(newItem.hasTransientState()); |
| Assert.assertEquals(oldText, newText); |
| Assert.assertEquals(tag, newItem.getTag()); |
| } |
| |
| private static class StableArrayAdapter<T> extends ArrayAdapter<T> { |
| public StableArrayAdapter(Context context, int resource, List<T> objects) { |
| super(context, resource, objects); |
| } |
| |
| @Override |
| public long getItemId(int position) { |
| return getItem(position).hashCode(); |
| } |
| |
| @Override |
| public boolean hasStableIds() { |
| return true; |
| } |
| } |
| |
| @LargeTest |
| @Test |
| public void testSmoothScrollByOffset() throws Throwable { |
| final int itemCount = mLongCountryList.length; |
| |
| mActivityRule.runOnUiThread(() -> mListView.setAdapter(mAdapter_longCountries)); |
| mInstrumentation.waitForIdleSync(); |
| |
| assertEquals(0, mListView.getFirstVisiblePosition()); |
| |
| // If we're on a really big display, we might be in a situation where the position |
| // we're going to scroll to is already visible. In that case the logic in the rest |
| // of this test will never fire off a listener callback and then fail the test. |
| final int positionToScrollTo = itemCount - 10; |
| final int lastVisiblePosition = mListView.getLastVisiblePosition(); |
| if (positionToScrollTo <= lastVisiblePosition) { |
| return; |
| } |
| |
| // Register a scroll listener on our ListView. The listener will notify our latch |
| // when the "target" item comes into view. If that never happens, the latch will |
| // time out and fail the test. |
| final CountDownLatch latch = new CountDownLatch(1); |
| mListView.setOnScrollListener(new AbsListView.OnScrollListener() { |
| @Override |
| public void onScrollStateChanged(AbsListView view, int scrollState) { |
| } |
| |
| @Override |
| public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, |
| int totalItemCount) { |
| if ((positionToScrollTo >= firstVisibleItem) && |
| (positionToScrollTo <= (firstVisibleItem + visibleItemCount))) { |
| latch.countDown(); |
| } |
| } |
| }); |
| int offset = positionToScrollTo - lastVisiblePosition; |
| mActivityRule.runOnUiThread(() -> mListView.smoothScrollByOffset(offset)); |
| |
| boolean result = false; |
| try { |
| result = latch.await(20, TimeUnit.SECONDS); |
| } catch (InterruptedException e) { |
| // ignore |
| } |
| assertTrue("Timed out while waiting for the target view to be scrolled into view", result); |
| } |
| |
| private static class PositionArrayAdapter<T> extends ArrayAdapter<T> { |
| public PositionArrayAdapter(Context context, int resource, List<T> objects) { |
| super(context, resource, objects); |
| } |
| |
| @Override |
| public long getItemId(int position) { |
| return position; |
| } |
| |
| @Override |
| public boolean hasStableIds() { |
| return true; |
| } |
| } |
| |
| @Test |
| public void testGetCheckItemIds() throws Throwable { |
| final ArrayList<String> items = new ArrayList<>(Arrays.asList(mCountryList)); |
| final ArrayAdapter<String> adapter = new PositionArrayAdapter<>(mActivity, |
| android.R.layout.simple_list_item_1, items); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| () -> mListView.setAdapter(adapter)); |
| |
| mActivityRule.runOnUiThread( |
| () -> mListView.setChoiceMode(ListView.CHOICE_MODE_MULTIPLE)); |
| assertTrue(mListView.getCheckItemIds().length == 0); |
| |
| mActivityRule.runOnUiThread(() -> mListView.setItemChecked(2, true)); |
| TestUtils.assertIdentical(new long[] { 2 }, mListView.getCheckItemIds()); |
| |
| mActivityRule.runOnUiThread(() -> mListView.setItemChecked(4, true)); |
| TestUtils.assertIdentical(new long[] { 2, 4 }, mListView.getCheckItemIds()); |
| |
| mActivityRule.runOnUiThread(() -> mListView.setItemChecked(2, false)); |
| TestUtils.assertIdentical(new long[] { 4 }, mListView.getCheckItemIds()); |
| |
| mActivityRule.runOnUiThread(() -> mListView.setItemChecked(4, false)); |
| assertTrue(mListView.getCheckItemIds().length == 0); |
| } |
| |
| @Test |
| public void testAccessOverscrollHeader() throws Throwable { |
| final Drawable overscrollHeaderDrawable = spy(new ColorDrawable(Color.YELLOW)); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, () -> { |
| mListView.setAdapter(mAdapter_longCountries); |
| mListView.setOverscrollHeader(overscrollHeaderDrawable); |
| }); |
| |
| assertEquals(overscrollHeaderDrawable, mListView.getOverscrollHeader()); |
| verify(overscrollHeaderDrawable, never()).draw(any(Canvas.class)); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| () -> mListView.setScrollY(-mListView.getHeight() / 2)); |
| |
| verify(overscrollHeaderDrawable, atLeastOnce()).draw(any(Canvas.class)); |
| } |
| |
| @Test |
| public void testAccessOverscrollFooter() throws Throwable { |
| final Drawable overscrollFooterDrawable = spy(new ColorDrawable(Color.MAGENTA)); |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, () -> { |
| // Configure ListView to automatically scroll to the selected item |
| mListView.setStackFromBottom(true); |
| mListView.setTranscriptMode(AbsListView.TRANSCRIPT_MODE_ALWAYS_SCROLL); |
| |
| mListView.setAdapter(mAdapter_longCountries); |
| mListView.setOverscrollFooter(overscrollFooterDrawable); |
| |
| // Set selection to the last item |
| mListView.setSelection(mAdapter_longCountries.getCount() - 1); |
| }); |
| |
| assertEquals(overscrollFooterDrawable, mListView.getOverscrollFooter()); |
| verify(overscrollFooterDrawable, never()).draw(any(Canvas.class)); |
| |
| WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mListView, |
| () -> mListView.setScrollY(mListView.getHeight() / 2)); |
| |
| verify(overscrollFooterDrawable, atLeastOnce()).draw(any(Canvas.class)); |
| } |
| } |
