/*
 * 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.Matchers.any;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;

import android.app.Activity;
import android.app.Instrumentation;
import android.content.Context;
import android.database.DataSetObservable;
import android.database.DataSetObserver;
import android.graphics.Rect;
import android.test.ViewAsserts;
import android.util.AttributeSet;
import android.util.Xml;
import android.view.Gravity;
import android.view.KeyEvent;
import android.view.View;
import android.view.ViewGroup;
import android.view.animation.GridLayoutAnimationController.AnimationParameters;
import android.widget.AbsListView;
import android.widget.AdapterView;
import android.widget.Filter;
import android.widget.Filterable;
import android.widget.GridView;
import android.widget.ImageView;
import android.widget.ListAdapter;

import androidx.test.InstrumentationRegistry;
import androidx.test.annotation.UiThreadTest;
import androidx.test.filters.LargeTest;
import androidx.test.filters.MediumTest;
import androidx.test.filters.SmallTest;
import androidx.test.rule.ActivityTestRule;
import androidx.test.runner.AndroidJUnit4;

import com.android.compatibility.common.util.CtsKeyEventUtil;
import com.android.compatibility.common.util.PollingCheck;
import com.android.compatibility.common.util.WidgetTestUtils;

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.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

/**
 * Test {@link GridView}.
 */
@SmallTest
@RunWith(AndroidJUnit4.class)
public class GridViewTest {
    private Instrumentation mInstrumentation;
    private Activity mActivity;
    private GridView mGridView;

    @Rule
    public ActivityTestRule<GridViewCtsActivity> mActivityRule =
            new ActivityTestRule<>(GridViewCtsActivity.class);

    @Before
    public void setup() {
        mInstrumentation = InstrumentationRegistry.getInstrumentation();
        mActivity = mActivityRule.getActivity();
        mGridView = (GridView) mActivity.findViewById(R.id.gridview);

        PollingCheck.waitFor(mActivity::hasWindowFocus);
    }

    @Test
    public void testConstructor() {
        new GridView(mActivity);

        new GridView(mActivity, null);

        new GridView(mActivity, null, android.R.attr.gridViewStyle);

        new GridView(mActivity, null, 0, android.R.style.Widget_DeviceDefault_GridView);

        new GridView(mActivity, null, 0, android.R.style.Widget_DeviceDefault_Light_GridView);

        new GridView(mActivity, null, 0, android.R.style.Widget_Material_GridView);

        new GridView(mActivity, null, 0, android.R.style.Widget_Material_Light_GridView);

        XmlPullParser parser = mActivity.getResources().getXml(R.layout.gridview_layout);
        AttributeSet attrs = Xml.asAttributeSet(parser);
        new GridView(mActivity, attrs);
        new GridView(mActivity, attrs, 0);
    }

    @Test(expected=NullPointerException.class)
    public void testConstructorNullContext1() {
        new GridView(null);
    }

    @Test(expected=NullPointerException.class)
    public void testConstructorNullContext2() {
        new GridView(null, null);
    }

    @Test(expected=NullPointerException.class)
    public void testConstructorNullContext3() {
        new GridView(null, null, 0);
    }

    @UiThreadTest
    @Test
    public void testAccessAdapter() {
        // set Adapter
        ImageAdapter adapter = new ImageAdapter(mActivity);
        mGridView.setAdapter(adapter);
        assertSame(adapter, mGridView.getAdapter());

        mGridView.setAdapter(null);
        assertNull(mGridView.getAdapter());
    }

    @UiThreadTest
    @Test
    public void testSetSelection() {
        mGridView.setSelection(0);
        assertEquals(0, mGridView.getSelectedItemPosition());

        mGridView.setSelection(-1);
        assertEquals(-1, mGridView.getSelectedItemPosition());

        mGridView.setSelection(mGridView.getCount());
        assertEquals(mGridView.getCount(), mGridView.getSelectedItemPosition());
    }

    @Test
    public void testPressKey() throws Throwable {
        final int NUM_COLUMNS = 3;

        GridView.OnItemClickListener mockItemClickListener =
                mock(GridView.OnItemClickListener.class);
        mGridView.setOnItemClickListener(mockItemClickListener);

        // this test case can not be ran in UI thread.
        mActivityRule.runOnUiThread(() -> {
            mGridView.setAdapter(new ImageAdapter(mActivity));
            mGridView.setNumColumns(NUM_COLUMNS);
            mGridView.invalidate();
            mGridView.requestLayout();
            mGridView.requestFocus();
        });
        mInstrumentation.waitForIdleSync();

        assertEquals(0, mGridView.getSelectedItemPosition());
        KeyEvent event = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DPAD_RIGHT);
        mInstrumentation.sendKeySync(event);
        assertEquals(1, mGridView.getSelectedItemPosition());

        event = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DPAD_LEFT);
        mInstrumentation.sendKeySync(event);
        assertEquals(0, mGridView.getSelectedItemPosition());

        assertEquals(0, mGridView.getSelectedItemPosition());
        mInstrumentation.sendKeyDownUpSync(KeyEvent.KEYCODE_DPAD_RIGHT);
        assertEquals(1, mGridView.getSelectedItemPosition());

        mInstrumentation.sendKeyDownUpSync(KeyEvent.KEYCODE_DPAD_LEFT);
        assertEquals(0, mGridView.getSelectedItemPosition());

        mInstrumentation.sendKeyDownUpSync(KeyEvent.KEYCODE_TAB);
        assertEquals(1, mGridView.getSelectedItemPosition());

        event = new KeyEvent(0, 0, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_TAB, 0,
                KeyEvent.META_SHIFT_LEFT_ON);
        mInstrumentation.sendKeySync(event);
        event = new KeyEvent(0, 0, KeyEvent.ACTION_UP, KeyEvent.KEYCODE_TAB, 0,
                KeyEvent.META_SHIFT_LEFT_ON);
        mInstrumentation.sendKeySync(event);
        assertEquals(0, mGridView.getSelectedItemPosition());

        mInstrumentation.sendKeyDownUpSync(KeyEvent.KEYCODE_DPAD_DOWN);
        assertEquals(NUM_COLUMNS, mGridView.getSelectedItemPosition());

        verify(mockItemClickListener, never()).onItemClick(any(AdapterView.class), any(View.class),
                anyInt(), anyLong());
        mInstrumentation.sendKeyDownUpSync(KeyEvent.KEYCODE_DPAD_CENTER);
        verify(mockItemClickListener, times(1)).onItemClick(eq(mGridView), any(View.class),
                eq(NUM_COLUMNS), eq((long) NUM_COLUMNS));

        reset(mockItemClickListener);
        mInstrumentation.sendKeyDownUpSync(KeyEvent.KEYCODE_ENTER);
        verify(mockItemClickListener, times(1)).onItemClick(eq(mGridView), any(View.class),
                eq(NUM_COLUMNS), eq((long) NUM_COLUMNS));
    }

    @Test
    public void testSetGravity() throws Throwable {
        final int NUM_COLUMNS = 1;
        // this test case can not be ran in UI thread.
        mActivityRule.runOnUiThread(() -> {
            mGridView.setAdapter(new ImageAdapter(mActivity));
            mGridView.setNumColumns(NUM_COLUMNS);
            mGridView.setHorizontalSpacing(0);
            mGridView.setVerticalSpacing(0);
        });
        mInstrumentation.waitForIdleSync();

        mActivityRule.runOnUiThread(() -> {
            mGridView.setGravity(Gravity.CENTER_HORIZONTAL);
            mGridView.invalidate();
            mGridView.requestLayout();
        });
        mInstrumentation.waitForIdleSync();

        assertEquals(Gravity.CENTER_HORIZONTAL, mGridView.getGravity());
        ViewAsserts.assertHorizontalCenterAligned(mGridView, mGridView.getChildAt(0));

        mActivityRule.runOnUiThread(() -> {
            mGridView.setGravity(Gravity.LEFT);
            mGridView.invalidate();
            mGridView.requestLayout();
        });
        mInstrumentation.waitForIdleSync();

        assertEquals(Gravity.LEFT, mGridView.getGravity());
        ViewAsserts.assertLeftAligned(mGridView, mGridView.getChildAt(0),
                mGridView.getListPaddingLeft());

        mActivityRule.runOnUiThread(() -> {
            mGridView.setGravity(Gravity.RIGHT);
            mGridView.invalidate();
            mGridView.requestLayout();
        });
        mInstrumentation.waitForIdleSync();

        assertEquals(Gravity.RIGHT, mGridView.getGravity());
        ViewAsserts.assertRightAligned(mGridView, mGridView.getChildAt(0),
                mGridView.getListPaddingRight());
    }

    @Test
    public void testAccessHorizontalSpacing() throws Throwable {
        verifyAccessHorizontalSpacing(View.LAYOUT_DIRECTION_LTR);
    }

    @Test
    public void testAccessHorizontalSpacingRTL() throws Throwable {
        verifyAccessHorizontalSpacing(View.LAYOUT_DIRECTION_RTL);
    }

    private void verifyAccessHorizontalSpacing(final int layoutDir) throws Throwable {
        mActivityRule.runOnUiThread(() -> mGridView.setLayoutDirection(layoutDir));
        mGridView.setStretchMode(GridView.NO_STRETCH);
        // Number of columns should be big enough, otherwise the
        // horizontal spacing cannot be correctly verified.
        mGridView.setNumColumns(28);

        mActivityRule.runOnUiThread(() ->  {
            mGridView.setAdapter(new MockGridViewAdapter(3));
            mGridView.setHorizontalSpacing(0);
        });
        mInstrumentation.waitForIdleSync();

        assertEquals(0, mGridView.getRequestedHorizontalSpacing());
        assertEquals(0, mGridView.getHorizontalSpacing());
        View child0 = mGridView.getChildAt(0);
        View child1 = mGridView.getChildAt(1);
        if (layoutDir == View.LAYOUT_DIRECTION_LTR) {
            assertEquals(0, child1.getLeft() - child0.getRight());
        } else {
            assertEquals(0, child0.getLeft() - child1.getRight());
        }

        mActivityRule.runOnUiThread(() -> mGridView.setHorizontalSpacing(5));
        mInstrumentation.waitForIdleSync();

        assertEquals(5, mGridView.getRequestedHorizontalSpacing());
        assertEquals(5, mGridView.getHorizontalSpacing());
        child0 = mGridView.getChildAt(0);
        child1 = mGridView.getChildAt(1);
        if (layoutDir == View.LAYOUT_DIRECTION_LTR) {
            assertEquals(5, child1.getLeft() - child0.getRight());
        } else {
            assertEquals(5, child0.getLeft() - child1.getRight());
        }
    }

    @Test
    public void testAccessVerticalSpacing() throws Throwable {
        mActivityRule.runOnUiThread(() -> {
            mGridView.setAdapter(new MockGridViewAdapter(3));
            mGridView.setVerticalSpacing(0);
        });
        mInstrumentation.waitForIdleSync();

        assertEquals(0, mGridView.getVerticalSpacing());
        View child0 = mGridView.getChildAt(0);
        View child1 = mGridView.getChildAt(1);
        assertEquals(0, child1.getTop() - child0.getBottom());

        mActivityRule.runOnUiThread(() -> mGridView.setVerticalSpacing(5));
        mInstrumentation.waitForIdleSync();

        assertEquals(5, mGridView.getVerticalSpacing());
        child0 = mGridView.getChildAt(0);
        child1 = mGridView.getChildAt(1);
        assertEquals(5, child1.getTop() - child0.getBottom());
    }

    @Test
    public void testAccessStretchMode() throws Throwable {
        View child;

        final int NUM_COLUMNS = 8;
        // this test case can not be ran in UI thread.
        mActivityRule.runOnUiThread(() -> {
            mGridView.setAdapter(new ImageAdapter(mActivity));
            mGridView.setColumnWidth(10);
            mGridView.setNumColumns(NUM_COLUMNS);
            mGridView.setHorizontalSpacing(0);
            mGridView.setVerticalSpacing(0);
            mGridView.invalidate();
            mGridView.requestLayout();
        });
        mInstrumentation.waitForIdleSync();

        int[][] childRight = new int[3][3];
        int STRETCH_SPACING = 0;
        int STRETCH_COLUMN_WIDTH = 1;
        int STRETCH_SPACING_UNIFORM = 2;
        int INDEX_RIGHTMOST = 0;
        int INDEX_0 = 1;
        int INDEX_1 = 2;

        mActivityRule.runOnUiThread(() -> {
            mGridView.setColumnWidth(15);
            mGridView.setStretchMode(GridView.STRETCH_SPACING);
            mGridView.invalidate();
            mGridView.requestLayout();
        });
        mInstrumentation.waitForIdleSync();
        assertEquals(GridView.STRETCH_SPACING, mGridView.getStretchMode());
        child = mGridView.getChildAt(NUM_COLUMNS - 1); // get the rightmost view at the first line.
        childRight[STRETCH_SPACING][INDEX_RIGHTMOST] = child.getRight();

        child = mGridView.getChildAt(0);
        childRight[STRETCH_SPACING][INDEX_0] = child.getRight();

        child = mGridView.getChildAt(1);
        childRight[STRETCH_SPACING][INDEX_1] = child.getRight();

        mActivityRule.runOnUiThread(() -> {
            mGridView.setColumnWidth(15);
            mGridView.setStretchMode(GridView.STRETCH_COLUMN_WIDTH);
            mGridView.invalidate();
            mGridView.requestLayout();
        });
        mInstrumentation.waitForIdleSync();
        assertEquals(GridView.STRETCH_COLUMN_WIDTH, mGridView.getStretchMode());
        child = mGridView.getChildAt(NUM_COLUMNS - 1); // get the rightmost view at the first line.
        childRight[STRETCH_COLUMN_WIDTH][INDEX_RIGHTMOST] = child.getRight();

        child = mGridView.getChildAt(0);
        childRight[STRETCH_COLUMN_WIDTH][INDEX_0] = child.getRight();

        child = mGridView.getChildAt(1);
        childRight[STRETCH_COLUMN_WIDTH][INDEX_1] = child.getRight();

        mActivityRule.runOnUiThread(() -> {
            mGridView.setColumnWidth(15);
            mGridView.setStretchMode(GridView.STRETCH_SPACING_UNIFORM);
            mGridView.invalidate();
            mGridView.requestLayout();
        });
        mInstrumentation.waitForIdleSync();
        assertEquals(GridView.STRETCH_SPACING_UNIFORM, mGridView.getStretchMode());
        child = mGridView.getChildAt(NUM_COLUMNS - 1); // get the rightmost view at the first line.
        childRight[STRETCH_SPACING_UNIFORM][INDEX_RIGHTMOST] = child.getRight();

        child = mGridView.getChildAt(0);
        childRight[STRETCH_SPACING_UNIFORM][INDEX_0] = child.getRight();

        child = mGridView.getChildAt(1);
        childRight[STRETCH_SPACING_UNIFORM][INDEX_1] = child.getRight();

        assertTrue(childRight[STRETCH_SPACING][INDEX_RIGHTMOST]
                > childRight[STRETCH_COLUMN_WIDTH][INDEX_RIGHTMOST]);
        assertTrue(childRight[STRETCH_SPACING][INDEX_RIGHTMOST]
                > childRight[STRETCH_SPACING_UNIFORM][INDEX_RIGHTMOST]);
        assertTrue(childRight[STRETCH_SPACING][INDEX_0]
                == childRight[STRETCH_COLUMN_WIDTH][INDEX_0]);
        assertTrue(childRight[STRETCH_SPACING][INDEX_0]
                < childRight[STRETCH_SPACING_UNIFORM][INDEX_0]);
        assertTrue(childRight[STRETCH_SPACING][INDEX_1]
                > childRight[STRETCH_COLUMN_WIDTH][INDEX_1]);
        assertTrue(childRight[STRETCH_SPACING][INDEX_1]
                < childRight[STRETCH_SPACING_UNIFORM][INDEX_1]);
    }

    @Test
    public void testSetNumColumns() throws Throwable {
        // this test case can not be ran in UI thread.
        mActivityRule.runOnUiThread(() -> {
            mGridView.setAdapter(new MockGridViewAdapter(10));
            mGridView.setHorizontalSpacing(0);
            mGridView.setVerticalSpacing(0);
            mGridView.setNumColumns(10);
        });
        mInstrumentation.waitForIdleSync();

        View child0 = mGridView.getChildAt(0);
        View child9 = mGridView.getChildAt(9);
        assertEquals(child0.getBottom(), child9.getBottom());

        mActivityRule.runOnUiThread(() -> mGridView.setNumColumns(9));
        mInstrumentation.waitForIdleSync();

        child0 = mGridView.getChildAt(0);
        child9 = mGridView.getChildAt(9);
        assertEquals(child0.getBottom(), child9.getTop());
        assertEquals(child0.getLeft(), child9.getLeft());

        mActivityRule.runOnUiThread(() -> mGridView.setNumColumns(1));
        mInstrumentation.waitForIdleSync();

        for (int i = 0; i < mGridView.getChildCount(); i++) {
            View child = mGridView.getChildAt(i);
            assertEquals(0, child.getLeft() - mGridView.getListPaddingLeft());
        }
    }

    @Test
    public void testDefaultNumColumns() {
        final GridView gridView = new GridView(mActivity);
        assertEquals(gridView.getNumColumns(), GridView.AUTO_FIT);
    }

    @Test
    public void testGetNumColumns() throws Throwable {
        mActivityRule.runOnUiThread(() -> {
            mGridView.setAdapter(new MockGridViewAdapter(10));
            mGridView.setNumColumns(10);
        });
        mInstrumentation.waitForIdleSync();

        assertEquals(mGridView.getNumColumns(), 10);

        mActivityRule.runOnUiThread(() -> mGridView.setNumColumns(1));
        mInstrumentation.waitForIdleSync();

        assertEquals(mGridView.getNumColumns(), 1);

        mActivityRule.runOnUiThread(() -> mGridView.setNumColumns(0));
        mInstrumentation.waitForIdleSync();

        //although setNumColumns(0) was called, the number of columns should be 1
        assertEquals(mGridView.getNumColumns(), 1);
    }

    @Test
    public void testAttachLayoutAnimationParameters() {
        MockGridView mockGridView = new MockGridView(mActivity);
        ViewGroup.LayoutParams p = new ViewGroup.LayoutParams(320, 480);
        mockGridView.attachLayoutAnimationParameters(null, p, 1, 2);
        AnimationParameters animationParams = (AnimationParameters) p.layoutAnimationParameters;
        assertEquals(1, animationParams.index);
        assertEquals(2, animationParams.count);
    }

    @Test
    public void testLayoutChildren() {
        MockGridView mockGridView = new MockGridView(mActivity);
        mockGridView.layoutChildren();
    }

    @UiThreadTest
    @Test
    public void testOnFocusChanged() {
        final MockGridView mockGridView = new MockGridView(mActivity);

        assertFalse(mockGridView.hasCalledOnFocusChanged());
        mockGridView.setAdapter(new MockGridViewAdapter(10));
        mockGridView.setFocusable(true);
        mockGridView.requestFocus();

        assertTrue(mockGridView.hasCalledOnFocusChanged());
        mockGridView.reset();
        assertFalse(mockGridView.hasCalledOnFocusChanged());

        mockGridView.clearFocus();

        assertTrue(mockGridView.hasCalledOnFocusChanged());
    }

    @Test
    public void testAccessColumnWidth() throws Throwable {
        mActivityRule.runOnUiThread(() -> {
            mGridView.setAdapter(new MockGridViewAdapter(10));
            mGridView.setNumColumns(GridView.AUTO_FIT);
            mGridView.setHorizontalSpacing(0);
            mGridView.setVerticalSpacing(0);
            mGridView.setColumnWidth(0);
        });
        mInstrumentation.waitForIdleSync();

        // Verify whether column number equals 2.
        assertEquals(0, mGridView.getRequestedColumnWidth());
        assertEquals(mGridView.getWidth() / 2, mGridView.getColumnWidth());
        View child0 = mGridView.getChildAt(0);
        View child1 = mGridView.getChildAt(1);
        View child2 = mGridView.getChildAt(2);
        assertEquals(child0.getBottom(), child1.getBottom());
        assertEquals(child0.getLeft(), child2.getLeft());

        mActivityRule.runOnUiThread(() -> {
            mGridView.setNumColumns(GridView.AUTO_FIT);
            mGridView.setColumnWidth(Integer.MAX_VALUE);
        });
        mInstrumentation.waitForIdleSync();

        assertEquals(Integer.MAX_VALUE, mGridView.getRequestedColumnWidth());
        assertEquals(mGridView.getWidth(), mGridView.getColumnWidth());
        child0 = mGridView.getChildAt(0);
        child1 = mGridView.getChildAt(1);
        assertEquals(child0.getBottom(), child1.getTop());
        assertEquals(child0.getLeft(), child1.getLeft());
    }

    @MediumTest
    @Test
    public void testFullyDetachUnusedViewOnScroll() throws Throwable {
        final AttachDetachAwareView theView = new AttachDetachAwareView(mActivity);
        WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mGridView, () -> {
            mGridView.setAdapter(new DummyAdapter(1000, theView));
        });
        assertEquals("test sanity", 1, theView.mOnAttachCount);
        assertEquals("test sanity", 0, theView.mOnDetachCount);
        WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mGridView, () -> {
            mGridView.scrollListBy(mGridView.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, mGridView, () -> {
            mGridView.scrollListBy(-mGridView.getHeight() * 2);
            // listview limits scroll to 1 page which is why we call it twice here.
            mGridView.scrollListBy(-mGridView.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, mGridView, () -> {
            mGridView.setAdapter(new DummyAdapter(1000, theView));
        });
        assertEquals("test sanity", 1, theView.mOnAttachCount);
        assertEquals("test sanity", 0, theView.mOnDetachCount);
        WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mGridView, () -> {
            mGridView.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, mGridView, () -> {
            mGridView.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, mGridView, () -> {
            mGridView.setAdapter(new DummyAdapter(1000, theView));
            mGridView.requestFocus();
        });
        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, mGridView, KeyEvent.KEYCODE_DPAD_DOWN);
            WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mGridView, null);
        }
        assertEquals("the view should be detached", 1, theView.mOnDetachCount);
        assertFalse(theView.isTemporarilyDetached());
        while(theView.getParent() == null) {
            CtsKeyEventUtil.sendKeys(mInstrumentation, mGridView, KeyEvent.KEYCODE_DPAD_UP);
            WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, mGridView, null);
        }
        assertEquals("the view should be re-attached", 2, theView.mOnAttachCount);
        assertEquals("the view should not receive another detach", 1, theView.mOnDetachCount);
        assertFalse(theView.isTemporarilyDetached());
    }

    @LargeTest
    @Test
    public void testSmoothScrollByOffset() throws Throwable {
        final int itemCount = 300;
        mActivityRule.runOnUiThread(() -> {
            mGridView.setAdapter(new MockGridViewAdapter(itemCount));
            mGridView.setNumColumns(GridView.AUTO_FIT);
            mGridView.setHorizontalSpacing(0);
            mGridView.setVerticalSpacing(0);
            mGridView.setColumnWidth(Integer.MAX_VALUE);
        });
        mInstrumentation.waitForIdleSync();

        assertEquals(0, mGridView.getFirstVisiblePosition());

        // Register a scroll listener on our GridView. 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);
        final int positionToScrollTo = itemCount - 10;
        mGridView.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 - mGridView.getLastVisiblePosition();
        mActivityRule.runOnUiThread(() -> mGridView.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 MockGridView extends GridView {
        private boolean mCalledOnFocusChanged = false;

        public boolean hasCalledOnFocusChanged() {
            return mCalledOnFocusChanged;
        }

        public void reset() {
            mCalledOnFocusChanged = false;
        }

        public MockGridView(Context context) {
            super(context);
        }

        public MockGridView(Context context, AttributeSet attrs) {
            super(context, attrs);
        }

        public MockGridView(Context context, AttributeSet attrs, int defStyle) {
            super(context, attrs, defStyle);
        }

        @Override
        public void attachLayoutAnimationParameters(View child,
                ViewGroup.LayoutParams params, int index, int count) {
            super.attachLayoutAnimationParameters(child, params, index, count);
        }

        @Override
        protected void layoutChildren() {
            super.layoutChildren();
        }

        @Override
        protected void onFocusChanged(boolean gainFocus, int direction,
                Rect previouslyFocusedRect) {
            mCalledOnFocusChanged = true;
            super.onFocusChanged(gainFocus, direction, previouslyFocusedRect);
        }
    }

    private class MockGridViewAdapter implements ListAdapter, Filterable {
        private final int mCount;

        MockGridViewAdapter(int count) {
            mCount = count;
        }

        public boolean areAllItemsEnabled() {
            return true;
        }

        public boolean isEnabled(int position) {
            return true;
        }

        public void registerDataSetObserver(DataSetObserver observer) {
        }

        public void unregisterDataSetObserver(DataSetObserver observer) {
        }

        public int getCount() {
            return mCount;
        }

        public Object getItem(int position) {
            return position;
        }

        public long getItemId(int position) {
            return position;
        }

        public boolean hasStableIds() {
            return false;
        }

        public View getView(int position, View convertView, ViewGroup parent) {
            if ((convertView != null) && (convertView instanceof ImageView)) {
                ((ImageView) convertView).setImageResource(R.drawable.size_48x48);
                return convertView;
            }

            ImageView newView = new ImageView(mActivity);
            AbsListView.LayoutParams params = new AbsListView.LayoutParams(
                                                  AbsListView.LayoutParams.WRAP_CONTENT,
                                                  AbsListView.LayoutParams.WRAP_CONTENT);
            newView.setLayoutParams(params);
            newView.setImageResource(R.drawable.size_48x48);
            return newView;
        }

        public int getItemViewType(int position) {
            return 0;
        }

        public int getViewTypeCount() {
            return 1;
        }

        public boolean isEmpty() {
            return false;
        }

        public Filter getFilter() {
            return new FilterTest();
        }
    }

    private static class FilterTest extends Filter {
        @Override
        protected Filter.FilterResults performFiltering(CharSequence constraint) {
            return null;
        }

        @Override
        protected void publishResults(CharSequence constraint, Filter.FilterResults results) {
        }
    }

    private class ImageAdapter implements ListAdapter {
        public ImageAdapter(Context c) {
            mContext = c;
        }

        public int getCount() {
            return mThumbIds.length;
        }

        public Object getItem(int position) {
            return position;
        }

        public long getItemId(int position) {
            return position;
        }

        public View getView(int position, View convertView, ViewGroup parent) {
            ImageView imageView;
            if (convertView == null) {
                imageView = new ImageView(mContext);
                int layoutSize = (int)(50 * mContext.getResources().getDisplayMetrics().density);
                imageView.setLayoutParams(new GridView.LayoutParams(layoutSize, layoutSize));
                imageView.setAdjustViewBounds(false);
                imageView.setScaleType(ImageView.ScaleType.CENTER);
                imageView.setPadding(0, 0, 0, 0);
            } else {
                imageView = (ImageView) convertView;
            }

            imageView.setImageResource(mThumbIds[position]);

            return imageView;
        }

        private Context mContext;

        private Integer[] mThumbIds = {
                R.drawable.failed, R.drawable.pass,
                R.drawable.animated, R.drawable.black,
                R.drawable.blue, R.drawable.red,
                R.drawable.animated, R.drawable.black,
                R.drawable.blue, R.drawable.failed,
                R.drawable.pass, R.drawable.red,
        };

        private final DataSetObservable mDataSetObservable = new DataSetObservable();

        public boolean hasStableIds() {
            return false;
        }

        public void registerDataSetObserver(DataSetObserver observer) {
            mDataSetObservable.registerObserver(observer);
        }

        public void unregisterDataSetObserver(DataSetObserver observer) {
            mDataSetObservable.unregisterObserver(observer);
        }

        public boolean areAllItemsEnabled() {
            return true;
        }

        public boolean isEnabled(int position) {
            return true;
        }

        public int getItemViewType(int position) {
            return 0;
        }

        public int getViewTypeCount() {
            return 1;
        }

        public boolean isEmpty() {
            return getCount() == 0;
        }
    }
}