xref: /frameworks/support/v7/recyclerview/src/androidTest/java/androidx/recyclerview/widget/RecyclerViewCacheTest.java

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

package androidx.recyclerview.widget;

import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNotNull;
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.argThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import android.content.Context;
import android.os.Build;
import android.os.Parcelable;
import android.os.SystemClock;
import android.support.test.InstrumentationRegistry;
import android.support.test.filters.SdkSuppress;
import android.support.test.filters.SmallTest;
import android.support.test.runner.AndroidJUnit4;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.widget.FrameLayout;

import androidx.annotation.NonNull;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentMatcher;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

@SmallTest
@SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
@RunWith(AndroidJUnit4.class)
public class RecyclerViewCacheTest {
    TimeMockingRecyclerView mRecyclerView;
    RecyclerView.Recycler mRecycler;

    private class TimeMockingRecyclerView extends RecyclerView {
        private long mMockNanoTime = 0;

        TimeMockingRecyclerView(Context context) {
            super(context);
        }

        public void registerTimePassingMs(long ms) {
            mMockNanoTime += TimeUnit.MILLISECONDS.toNanos(ms);
        }

        @Override
        long getNanoTime() {
            return mMockNanoTime;
        }

        @Override
        public int getWindowVisibility() {
            // Pretend to be visible to avoid being filtered out
            return View.VISIBLE;
        }
    }

    @Before
    public void setup() throws Exception {
        mRecyclerView = new TimeMockingRecyclerView(getContext());
        mRecyclerView.onAttachedToWindow();
        mRecycler = mRecyclerView.mRecycler;
    }

    @After
    public void teardown() throws Exception {
        if (mRecyclerView.isAttachedToWindow()) {
            mRecyclerView.onDetachedFromWindow();
        }
        GapWorker gapWorker = GapWorker.sGapWorker.get();
        if (gapWorker != null) {
            assertTrue(gapWorker.mRecyclerViews.isEmpty());
        }
    }

    private Context getContext() {
        return InstrumentationRegistry.getContext();
    }

    private void layout(int width, int height) {
        mRecyclerView.measure(
                View.MeasureSpec.makeMeasureSpec(width, View.MeasureSpec.EXACTLY),
                View.MeasureSpec.makeMeasureSpec(height, View.MeasureSpec.EXACTLY));
        mRecyclerView.layout(0, 0, width, height);
    }

    @Test
    public void prefetchReusesCacheItems() {
        RecyclerView.LayoutManager prefetchingLayoutManager = new RecyclerView.LayoutManager() {
            @Override
            public RecyclerView.LayoutParams generateDefaultLayoutParams() {
                return new RecyclerView.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT,
                        ViewGroup.LayoutParams.WRAP_CONTENT);
            }

            @Override
            public void collectAdjacentPrefetchPositions(int dx, int dy, RecyclerView.State state,
                    LayoutPrefetchRegistry prefetchManager) {
                prefetchManager.addPosition(0, 0);
                prefetchManager.addPosition(1, 0);
                prefetchManager.addPosition(2, 0);
            }

            @Override
            public void onLayoutChildren(RecyclerView.Recycler recycler, RecyclerView.State state) {
            }
        };
        mRecyclerView.setLayoutManager(prefetchingLayoutManager);

        RecyclerView.Adapter mockAdapter = mock(RecyclerView.Adapter.class);
        when(mockAdapter.onCreateViewHolder(any(ViewGroup.class), anyInt()))
                .thenAnswer(new Answer<RecyclerView.ViewHolder>() {
                    @Override
                    public RecyclerView.ViewHolder answer(InvocationOnMock invocation)
                            throws Throwable {
                        return new RecyclerView.ViewHolder(new View(getContext())) {};
                    }
                });
        when(mockAdapter.getItemCount()).thenReturn(10);
        mRecyclerView.setAdapter(mockAdapter);

        layout(320, 320);

        verify(mockAdapter, never()).onCreateViewHolder(any(ViewGroup.class), anyInt());
        verify(mockAdapter, never()).onBindViewHolder(
                any(RecyclerView.ViewHolder.class), anyInt(), any(List.class));
        assertTrue(mRecycler.mCachedViews.isEmpty());

        // Prefetch multiple times...
        for (int i = 0; i < 4; i++) {
            mRecyclerView.mGapWorker.prefetch(RecyclerView.FOREVER_NS);

            // ...but should only see the same three items fetched/bound once each
            verify(mockAdapter, times(3)).onCreateViewHolder(any(ViewGroup.class), anyInt());
            verify(mockAdapter, times(3)).onBindViewHolder(
                    any(RecyclerView.ViewHolder.class), anyInt(), any(List.class));

            assertTrue(mRecycler.mCachedViews.size() == 3);
            CacheUtils.verifyCacheContainsPrefetchedPositions(mRecyclerView, 0, 1, 2);
        }
    }

    @Test
    public void prefetchItemsNotEvictedWithInserts() {
        mRecyclerView.setLayoutManager(new GridLayoutManager(getContext(), 3));

        RecyclerView.Adapter mockAdapter = mock(RecyclerView.Adapter.class);
        when(mockAdapter.onCreateViewHolder(any(ViewGroup.class), anyInt()))
                .thenAnswer(new Answer<RecyclerView.ViewHolder>() {
                    @Override
                    public RecyclerView.ViewHolder answer(InvocationOnMock invocation)
                            throws Throwable {
                        View view = new View(getContext());
                        view.setMinimumWidth(100);
                        view.setMinimumHeight(100);
                        return new RecyclerView.ViewHolder(view) {};
                    }
                });
        when(mockAdapter.getItemCount()).thenReturn(100);
        mRecyclerView.setAdapter(mockAdapter);

        layout(300, 100);

        assertEquals(2, mRecyclerView.mRecycler.mViewCacheMax);
        mRecyclerView.mPrefetchRegistry.setPrefetchVector(0, 1);
        mRecyclerView.mGapWorker.prefetch(RecyclerView.FOREVER_NS);
        assertEquals(5, mRecyclerView.mRecycler.mViewCacheMax);

        CacheUtils.verifyCacheContainsPrefetchedPositions(mRecyclerView, 3, 4, 5);

        // further views recycled, as though from scrolling, shouldn't evict prefetched views:
        mRecycler.recycleView(mRecycler.getViewForPosition(10));
        CacheUtils.verifyCacheContainsPositions(mRecyclerView, 3, 4, 5, 10);

        mRecycler.recycleView(mRecycler.getViewForPosition(20));
        CacheUtils.verifyCacheContainsPositions(mRecyclerView, 3, 4, 5, 10, 20);

        mRecycler.recycleView(mRecycler.getViewForPosition(30));
        CacheUtils.verifyCacheContainsPositions(mRecyclerView, 3, 4, 5, 20, 30);

        mRecycler.recycleView(mRecycler.getViewForPosition(40));
        CacheUtils.verifyCacheContainsPositions(mRecyclerView, 3, 4, 5, 30, 40);

        // After clearing the cache, the prefetch priorities should be cleared as well:
        mRecyclerView.mRecycler.recycleAndClearCachedViews();
        for (int i : new int[] {3, 4, 5, 50, 60, 70, 80, 90}) {
            mRecycler.recycleView(mRecycler.getViewForPosition(i));
        }

        // cache only contains most recent positions, no priority for previous prefetches:
        CacheUtils.verifyCacheContainsPositions(mRecyclerView, 50, 60, 70, 80, 90);
    }

    @Test
    public void prefetchItemsNotEvictedOnScroll() {
        mRecyclerView.setLayoutManager(new GridLayoutManager(getContext(), 3));

        // 100x100 pixel views
        RecyclerView.Adapter mockAdapter = mock(RecyclerView.Adapter.class);
        when(mockAdapter.onCreateViewHolder(any(ViewGroup.class), anyInt()))
                .thenAnswer(new Answer<RecyclerView.ViewHolder>() {
                    @Override
                    public RecyclerView.ViewHolder answer(InvocationOnMock invocation)
                            throws Throwable {
                        View view = new View(getContext());
                        view.setMinimumWidth(100);
                        view.setMinimumHeight(100);
                        return new RecyclerView.ViewHolder(view) {};
                    }
                });
        when(mockAdapter.getItemCount()).thenReturn(100);
        mRecyclerView.setAdapter(mockAdapter);

        // NOTE: requested cache size must be smaller than span count so two rows cannot fit
        mRecyclerView.setItemViewCacheSize(2);

        layout(300, 150);
        mRecyclerView.scrollBy(0, 75);
        assertTrue(mRecycler.mCachedViews.isEmpty());

        // rows 0, 1, and 2 are all attached and visible. Prefetch row 3:
        mRecyclerView.mPrefetchRegistry.setPrefetchVector(0, 1);
        mRecyclerView.mGapWorker.prefetch(RecyclerView.FOREVER_NS);

        // row 3 is cached:
        CacheUtils.verifyCacheContainsPositions(mRecyclerView, 9, 10, 11);
        assertTrue(mRecycler.mCachedViews.size() == 3);

        // Scroll so 1 falls off (though 3 is still not on screen)
        mRecyclerView.scrollBy(0, 50);

        // row 3 is still cached, with a couple other recycled views:
        CacheUtils.verifyCacheContainsPositions(mRecyclerView, 9, 10, 11);
        assertTrue(mRecycler.mCachedViews.size() == 5);
    }

    @Test
    public void prefetchIsComputingLayout() {
        mRecyclerView.setLayoutManager(new LinearLayoutManager(getContext()));

        // 100x100 pixel views
        RecyclerView.Adapter mockAdapter = mock(RecyclerView.Adapter.class);
        when(mockAdapter.onCreateViewHolder(any(ViewGroup.class), anyInt()))
                .thenAnswer(new Answer<RecyclerView.ViewHolder>() {
                    @Override
                    public RecyclerView.ViewHolder answer(InvocationOnMock invocation)
                            throws Throwable {
                        View view = new View(getContext());
                        view.setMinimumWidth(100);
                        view.setMinimumHeight(100);
                        assertTrue(mRecyclerView.isComputingLayout());
                        return new RecyclerView.ViewHolder(view) {};
                    }
                });
        when(mockAdapter.getItemCount()).thenReturn(100);
        mRecyclerView.setAdapter(mockAdapter);

        layout(100, 100);

        verify(mockAdapter, times(1)).onCreateViewHolder(mRecyclerView, 0);

        // prefetch an item, should still observe isComputingLayout in that create
        mRecyclerView.mPrefetchRegistry.setPrefetchVector(0, 1);
        mRecyclerView.mGapWorker.prefetch(RecyclerView.FOREVER_NS);

        verify(mockAdapter, times(2)).onCreateViewHolder(mRecyclerView, 0);
    }

    @Test
    public void prefetchAfterOrientationChange() {
        LinearLayoutManager layout = new LinearLayoutManager(getContext(),
                LinearLayoutManager.VERTICAL, false);
        mRecyclerView.setLayoutManager(layout);

        // 100x100 pixel views
        mRecyclerView.setAdapter(new RecyclerView.Adapter() {
            @NonNull
            @Override
            public RecyclerView.ViewHolder onCreateViewHolder(
                    @NonNull ViewGroup parent, int viewType) {
                View view = new View(getContext());
                view.setMinimumWidth(100);
                view.setMinimumHeight(100);
                assertTrue(mRecyclerView.isComputingLayout());
                return new RecyclerView.ViewHolder(view) {};
            }

            @Override
            public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {}

            @Override
            public int getItemCount() {
                return 100;
            }
        });

        layout(100, 100);

        layout.setOrientation(LinearLayoutManager.HORIZONTAL);

        // Prefetch an item after changing orientation, before layout - shouldn't crash
        mRecyclerView.mPrefetchRegistry.setPrefetchVector(1, 1);
        mRecyclerView.mGapWorker.prefetch(RecyclerView.FOREVER_NS);
    }

    @Test
    public void prefetchDrag() {
        // event dispatch requires a parent
        ViewGroup parent = new FrameLayout(getContext());
        parent.addView(mRecyclerView);


        mRecyclerView.setLayoutManager(
                new LinearLayoutManager(getContext(), LinearLayoutManager.VERTICAL, false));

        // 1000x1000 pixel views
        RecyclerView.Adapter adapter = new RecyclerView.Adapter() {
            @Override
            public RecyclerView.ViewHolder onCreateViewHolder(
                    @NonNull ViewGroup parent, int viewType) {
                mRecyclerView.registerTimePassingMs(5);
                View view = new View(getContext());
                view.setMinimumWidth(1000);
                view.setMinimumHeight(1000);
                return new RecyclerView.ViewHolder(view) {};
            }

            @Override
            public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
                mRecyclerView.registerTimePassingMs(5);
            }

            @Override
            public int getItemCount() {
                return 100;
            }
        };
        mRecyclerView.setAdapter(adapter);

        layout(1000, 1000);

        long time = SystemClock.uptimeMillis();
        mRecyclerView.onTouchEvent(
                MotionEvent.obtain(time, time, MotionEvent.ACTION_DOWN, 500, 1000, 0));

        assertEquals(0, mRecyclerView.mPrefetchRegistry.mPrefetchDx);
        assertEquals(0, mRecyclerView.mPrefetchRegistry.mPrefetchDy);

        // Consume slop
        mRecyclerView.onTouchEvent(
                MotionEvent.obtain(time, time, MotionEvent.ACTION_MOVE, 50, 500, 0));

        // move by 0,30
        mRecyclerView.onTouchEvent(
                MotionEvent.obtain(time, time, MotionEvent.ACTION_MOVE, 50, 470, 0));
        assertEquals(0, mRecyclerView.mPrefetchRegistry.mPrefetchDx);
        assertEquals(30, mRecyclerView.mPrefetchRegistry.mPrefetchDy);

        // move by 10,15
        mRecyclerView.onTouchEvent(
                MotionEvent.obtain(time, time, MotionEvent.ACTION_MOVE, 40, 455, 0));
        assertEquals(10, mRecyclerView.mPrefetchRegistry.mPrefetchDx);
        assertEquals(15, mRecyclerView.mPrefetchRegistry.mPrefetchDy);

        // move by 0,0 - IGNORED
        mRecyclerView.onTouchEvent(
                MotionEvent.obtain(time, time, MotionEvent.ACTION_MOVE, 40, 455, 0));
        assertEquals(10, mRecyclerView.mPrefetchRegistry.mPrefetchDx); // same as prev
        assertEquals(15, mRecyclerView.mPrefetchRegistry.mPrefetchDy); // same as prev
    }

    @Test
    public void prefetchItemsRespectDeadline() {
        mRecyclerView.setLayoutManager(new GridLayoutManager(getContext(), 3));

        // 100x100 pixel views
        RecyclerView.Adapter adapter = new RecyclerView.Adapter() {
            @Override
            public RecyclerView.ViewHolder onCreateViewHolder(
                    @NonNull ViewGroup parent, int viewType) {
                mRecyclerView.registerTimePassingMs(5);
                View view = new View(getContext());
                view.setMinimumWidth(100);
                view.setMinimumHeight(100);
                return new RecyclerView.ViewHolder(view) {};
            }

            @Override
            public void onBindViewHolder(
                    @NonNull RecyclerView.ViewHolder holder, int position) {
                mRecyclerView.registerTimePassingMs(5);
            }

            @Override
            public int getItemCount() {
                return 100;
            }
        };
        mRecyclerView.setAdapter(adapter);

        layout(300, 300);

        // offset scroll so that no prefetch-able views are directly adjacent to viewport
        mRecyclerView.scrollBy(0, 50);

        assertTrue(mRecycler.mCachedViews.size() == 0);
        assertTrue(mRecyclerView.getRecycledViewPool().getRecycledViewCount(0) == 0);

        // Should take 15 ms to inflate, bind, inflate, so give 19 to be safe
        final long deadlineNs = mRecyclerView.getNanoTime() + TimeUnit.MILLISECONDS.toNanos(19);

        // Timed prefetch
        mRecyclerView.mPrefetchRegistry.setPrefetchVector(0, 1);
        mRecyclerView.mGapWorker.prefetch(deadlineNs);

        // will have enough time to inflate/bind one view, and inflate another
        assertTrue(mRecycler.mCachedViews.size() == 1);
        assertTrue(mRecyclerView.getRecycledViewPool().getRecycledViewCount(0) == 1);
        // Note: order/view below is an implementation detail
        CacheUtils.verifyCacheContainsPositions(mRecyclerView, 12);


        // Unbounded prefetch this time
        mRecyclerView.mGapWorker.prefetch(RecyclerView.FOREVER_NS);

        // Should finish all work
        assertTrue(mRecycler.mCachedViews.size() == 3);
        assertTrue(mRecyclerView.getRecycledViewPool().getRecycledViewCount(0) == 0);
        CacheUtils.verifyCacheContainsPositions(mRecyclerView, 12, 13, 14);
    }

    @Test
    public void partialPrefetchAvoidsViewRecycledCallback() {
        mRecyclerView.setLayoutManager(new LinearLayoutManager(getContext()));

        // 100x100 pixel views
        RecyclerView.Adapter adapter = new RecyclerView.Adapter() {
            @Override
            public RecyclerView.ViewHolder onCreateViewHolder(
                    @NonNull ViewGroup parent, int viewType) {
                mRecyclerView.registerTimePassingMs(5);
                View view = new View(getContext());
                view.setMinimumWidth(100);
                view.setMinimumHeight(100);
                return new RecyclerView.ViewHolder(view) {};
            }

            @Override
            public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
                mRecyclerView.registerTimePassingMs(5);
            }

            @Override
            public int getItemCount() {
                return 100;
            }

            @Override
            public void onViewRecycled(@NonNull RecyclerView.ViewHolder holder) {
                // verify unbound view doesn't get
                assertNotEquals(RecyclerView.NO_POSITION, holder.getAdapterPosition());
            }
        };
        mRecyclerView.setAdapter(adapter);

        layout(100, 300);

        // offset scroll so that no prefetch-able views are directly adjacent to viewport
        mRecyclerView.scrollBy(0, 50);

        assertTrue(mRecycler.mCachedViews.size() == 0);
        assertTrue(mRecyclerView.getRecycledViewPool().getRecycledViewCount(0) == 0);

        // Should take 10 ms to inflate + bind, so just give it 9 so it doesn't have time to bind
        final long deadlineNs = mRecyclerView.getNanoTime() + TimeUnit.MILLISECONDS.toNanos(9);

        // Timed prefetch
        mRecyclerView.mPrefetchRegistry.setPrefetchVector(0, 1);
        mRecyclerView.mGapWorker.prefetch(deadlineNs);

        // will have enough time to inflate but not bind one view
        assertTrue(mRecycler.mCachedViews.size() == 0);
        assertTrue(mRecyclerView.getRecycledViewPool().getRecycledViewCount(0) == 1);
        RecyclerView.ViewHolder pooledHolder = mRecyclerView.getRecycledViewPool()
                .mScrap.get(0).mScrapHeap.get(0);
        assertEquals(RecyclerView.NO_POSITION, pooledHolder.getAdapterPosition());
    }

    @Test
    public void prefetchStaggeredItemsPriority() {
        StaggeredGridLayoutManager sglm =
                new StaggeredGridLayoutManager(2, StaggeredGridLayoutManager.VERTICAL);
        mRecyclerView.setLayoutManager(sglm);

        // first view 50x100 pixels, rest are 100x100 so second column is offset
        mRecyclerView.setAdapter(new RecyclerView.Adapter() {
            @NonNull
            @Override
            public RecyclerView.ViewHolder onCreateViewHolder(
                    @NonNull ViewGroup parent, int viewType) {
                return new RecyclerView.ViewHolder(new View(getContext())) {};
            }

            @Override
            public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
                holder.itemView.setMinimumWidth(100);
                holder.itemView.setMinimumHeight(position == 0 ? 50 : 100);
            }

            @Override
            public int getItemCount() {
                return 100;
            }
        });

        layout(200, 200);

        /* Each row is 50 pixels:
         * ------------- *
         *   0   |   1   *
         *   2   |   1   *
         *   2   |   3   *
         *___4___|___3___*
         *   4   |   5   *
         *   6   |   5   *
         *      ...      *
         */
        assertEquals(5, mRecyclerView.getChildCount());
        assertEquals(0, sglm.getFirstChildPosition());
        assertEquals(4, sglm.getLastChildPosition());

        // prefetching down shows 5 at 0 pixels away, 6 at 50 pixels away
        CacheUtils.verifyPositionsPrefetched(mRecyclerView, 0, 10,
                new Integer[] {5, 0}, new Integer[] {6, 50});

        // Prefetch upward shows nothing
        CacheUtils.verifyPositionsPrefetched(mRecyclerView, 0, -10);

        mRecyclerView.scrollBy(0, 100);

        /* Each row is 50 pixels:
         * ------------- *
         *   0   |   1   *
         *___2___|___1___*
         *   2   |   3   *
         *   4   |   3   *
         *   4   |   5   *
         *___6___|___5___*
         *   6   |   7   *
         *   8   |   7   *
         *      ...      *
         */

        assertEquals(5, mRecyclerView.getChildCount());
        assertEquals(2, sglm.getFirstChildPosition());
        assertEquals(6, sglm.getLastChildPosition());

        // prefetching down shows 7 at 0 pixels away, 8 at 50 pixels away
        CacheUtils.verifyPositionsPrefetched(mRecyclerView, 0, 10,
                new Integer[] {7, 0}, new Integer[] {8, 50});

        // prefetching up shows 1 is 0 pixels away, 0 at 50 pixels away
        CacheUtils.verifyPositionsPrefetched(mRecyclerView, 0, -10,
                new Integer[] {1, 0}, new Integer[] {0, 50});
    }

    @Test
    public void prefetchStaggeredPastBoundary() {
        StaggeredGridLayoutManager sglm =
                new StaggeredGridLayoutManager(2, StaggeredGridLayoutManager.VERTICAL);
        mRecyclerView.setLayoutManager(sglm);
        mRecyclerView.setAdapter(new RecyclerView.Adapter() {
            @NonNull
            @Override
            public RecyclerView.ViewHolder onCreateViewHolder(
                    @NonNull ViewGroup parent, int viewType) {
                return new RecyclerView.ViewHolder(new View(getContext())) {};
            }

            @Override
            public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
                holder.itemView.setMinimumWidth(100);
                holder.itemView.setMinimumHeight(position == 0 ? 100 : 200);
            }

            @Override
            public int getItemCount() {
                return 2;
            }
        });

        layout(200, 100);
        mRecyclerView.scrollBy(0, 50);

        /* Each row is 50 pixels:
         * ------------- *
         *___0___|___1___*
         *   0   |   1   *
         *_______|___1___*
         *       |   1   *
         */
        assertEquals(2, mRecyclerView.getChildCount());
        assertEquals(0, sglm.getFirstChildPosition());
        assertEquals(1, sglm.getLastChildPosition());

        // prefetch upward gets nothing
        CacheUtils.verifyPositionsPrefetched(mRecyclerView, 0, -10);

        // prefetch downward gets nothing (and doesn't crash...)
        CacheUtils.verifyPositionsPrefetched(mRecyclerView, 0, 10);
    }

    @Test
    public void prefetchItemsSkipAnimations() {
        LinearLayoutManager llm = new LinearLayoutManager(getContext());
        mRecyclerView.setLayoutManager(llm);
        final int[] expandedPosition = new int[] {-1};

        final RecyclerView.Adapter adapter = new RecyclerView.Adapter() {
            @Override
            public RecyclerView.ViewHolder onCreateViewHolder(
                    @NonNull ViewGroup parent, int viewType) {
                return new RecyclerView.ViewHolder(new View(parent.getContext())) {};
            }

            @Override
            public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
                int height = expandedPosition[0] == position ? 400 : 100;
                holder.itemView.setLayoutParams(new RecyclerView.LayoutParams(200, height));
            }

            @Override
            public int getItemCount() {
                return 10;
            }
        };

        // make move duration long enough to be able to see the effects
        RecyclerView.ItemAnimator itemAnimator = mRecyclerView.getItemAnimator();
        itemAnimator.setMoveDuration(10000);
        mRecyclerView.setAdapter(adapter);

        layout(200, 400);

        expandedPosition[0] = 1;
        // insert payload to avoid creating a new view
        adapter.notifyItemChanged(1, new Object());

        layout(200, 400);
        layout(200, 400);

        assertTrue(itemAnimator.isRunning());
        assertEquals(2, llm.getChildCount());
        assertEquals(4, mRecyclerView.getChildCount());

        // animating view should be observable as hidden, uncached...
        CacheUtils.verifyCacheDoesNotContainPositions(mRecyclerView, 2);
        assertNotNull("Animating view should be found, hidden",
                mRecyclerView.mChildHelper.findHiddenNonRemovedView(2));
        assertTrue(GapWorker.isPrefetchPositionAttached(mRecyclerView, 2));

        // ...but must not be removed for prefetch
        mRecyclerView.mPrefetchRegistry.setPrefetchVector(0, 1);
        mRecyclerView.mGapWorker.prefetch(RecyclerView.FOREVER_NS);

        assertEquals("Prefetch must target one view", 1, mRecyclerView.mPrefetchRegistry.mCount);
        int prefetchTarget = mRecyclerView.mPrefetchRegistry.mPrefetchArray[0];
        assertEquals("Prefetch must target view 2", 2, prefetchTarget);

        // animating view still observable as hidden, uncached
        CacheUtils.verifyCacheDoesNotContainPositions(mRecyclerView, 2);
        assertNotNull("Animating view should be found, hidden",
                mRecyclerView.mChildHelper.findHiddenNonRemovedView(2));
        assertTrue(GapWorker.isPrefetchPositionAttached(mRecyclerView, 2));

        assertTrue(itemAnimator.isRunning());
        assertEquals(2, llm.getChildCount());
        assertEquals(4, mRecyclerView.getChildCount());
    }

    @Test
    public void viewHolderFindsNestedRecyclerViews() {
        LinearLayoutManager llm = new LinearLayoutManager(getContext());
        mRecyclerView.setLayoutManager(llm);

        RecyclerView.Adapter mockAdapter = mock(RecyclerView.Adapter.class);
        when(mockAdapter.onCreateViewHolder(any(ViewGroup.class), anyInt()))
                .thenAnswer(new Answer<RecyclerView.ViewHolder>() {
                    @Override
                    public RecyclerView.ViewHolder answer(InvocationOnMock invocation)
                            throws Throwable {
                        View view = new RecyclerView(getContext());
                        view.setLayoutParams(new RecyclerView.LayoutParams(100, 100));
                        return new RecyclerView.ViewHolder(view) {};
                    }
                });
        when(mockAdapter.getItemCount()).thenReturn(100);
        mRecyclerView.setAdapter(mockAdapter);

        layout(100, 200);

        verify(mockAdapter, times(2)).onCreateViewHolder(any(ViewGroup.class), anyInt());
        verify(mockAdapter, times(2)).onBindViewHolder(
                argThat(new ArgumentMatcher<RecyclerView.ViewHolder>() {
                    @Override
                    public boolean matches(RecyclerView.ViewHolder holder) {
                        return holder.itemView == holder.mNestedRecyclerView.get();
                    }
                }),
                anyInt(),
                any(List.class));
    }

    class InnerAdapter extends RecyclerView.Adapter<InnerAdapter.ViewHolder> {
        private static final int INNER_ITEM_COUNT = 20;
        int mItemsBound = 0;

        class ViewHolder extends RecyclerView.ViewHolder {
            ViewHolder(View itemView) {
                super(itemView);
            }
        }

        InnerAdapter() {}

        @Override
        public ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
            mRecyclerView.registerTimePassingMs(5);
            View view = new View(parent.getContext());
            view.setLayoutParams(new RecyclerView.LayoutParams(100, 100));
            return new ViewHolder(view);
        }

        @Override
        public void onBindViewHolder(@NonNull ViewHolder holder, int position) {
            mRecyclerView.registerTimePassingMs(5);
            mItemsBound++;
        }

        @Override
        public int getItemCount() {
            return INNER_ITEM_COUNT;
        }
    }

    class OuterAdapter extends RecyclerView.Adapter<OuterAdapter.ViewHolder> {

        private boolean mReverseInner;

        class ViewHolder extends RecyclerView.ViewHolder {
            private final RecyclerView mRecyclerView;
            ViewHolder(RecyclerView itemView) {
                super(itemView);
                mRecyclerView = itemView;
            }
        }

        ArrayList<InnerAdapter> mAdapters = new ArrayList<>();
        ArrayList<Parcelable> mSavedStates = new ArrayList<>();
        RecyclerView.RecycledViewPool mSharedPool = new RecyclerView.RecycledViewPool();

        OuterAdapter() {
            this(false);
        }

        OuterAdapter(boolean reverseInner) {
            this(reverseInner, 10);
        }

        OuterAdapter(boolean reverseInner, int itemCount) {
            mReverseInner = reverseInner;
            for (int i = 0; i < itemCount; i++) {
                mAdapters.add(new InnerAdapter());
                mSavedStates.add(null);
            }
        }

        void addItem() {
            int index = getItemCount();
            mAdapters.add(new InnerAdapter());
            mSavedStates.add(null);
            notifyItemInserted(index);
        }

        @Override
        public ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
            mRecyclerView.registerTimePassingMs(5);

            RecyclerView rv = new RecyclerView(parent.getContext()) {
                @Override
                public int getWindowVisibility() {
                    // Pretend to be visible to avoid being filtered out
                    return View.VISIBLE;
                }
            };
            rv.setLayoutManager(new LinearLayoutManager(parent.getContext(),
                    LinearLayoutManager.HORIZONTAL, mReverseInner));
            rv.setRecycledViewPool(mSharedPool);
            rv.setLayoutParams(new RecyclerView.LayoutParams(200, 100));
            return new ViewHolder(rv);
        }

        @Override
        public void onBindViewHolder(@NonNull ViewHolder holder, int position) {
            mRecyclerView.registerTimePassingMs(5);

            // Tests may rely on bound holders not being shared between inner adapters,
            // since we force recycle here
            holder.mRecyclerView.swapAdapter(mAdapters.get(position), true);

            Parcelable savedState = mSavedStates.get(position);
            if (savedState != null) {
                holder.mRecyclerView.getLayoutManager().onRestoreInstanceState(savedState);
                mSavedStates.set(position, null);
            }
        }

        @Override
        public void onViewRecycled(@NonNull ViewHolder holder) {
            mSavedStates.set(holder.getAdapterPosition(),
                    holder.mRecyclerView.getLayoutManager().onSaveInstanceState());
        }

        @Override
        public int getItemCount() {
            return mAdapters.size();
        }
    }

    @Test
    public void nestedPrefetchSimple() {
        LinearLayoutManager llm = new LinearLayoutManager(getContext());
        assertEquals(2, llm.getInitialPrefetchItemCount());

        mRecyclerView.setLayoutManager(llm);
        mRecyclerView.setAdapter(new OuterAdapter());

        layout(200, 200);
        mRecyclerView.mPrefetchRegistry.setPrefetchVector(0, 1);

        // prefetch 2 (default)
        mRecyclerView.mGapWorker.prefetch(RecyclerView.FOREVER_NS);
        RecyclerView.ViewHolder holder = CacheUtils.peekAtCachedViewForPosition(mRecyclerView, 2);
        assertNotNull(holder);
        assertNotNull(holder.mNestedRecyclerView);
        RecyclerView innerView = holder.mNestedRecyclerView.get();
        CacheUtils.verifyCacheContainsPrefetchedPositions(innerView, 0, 1);

        // prefetch 4
        ((LinearLayoutManager) innerView.getLayoutManager())
                .setInitialPrefetchItemCount(4);
        mRecyclerView.mGapWorker.prefetch(RecyclerView.FOREVER_NS);
        CacheUtils.verifyCacheContainsPrefetchedPositions(innerView, 0, 1, 2, 3);
    }

    @Test
    public void nestedPrefetchNotClearInnerStructureChangeFlag() {
        LinearLayoutManager llm = new LinearLayoutManager(getContext());
        assertEquals(2, llm.getInitialPrefetchItemCount());

        mRecyclerView.setLayoutManager(llm);
        mRecyclerView.setAdapter(new OuterAdapter());

        layout(200, 200);
        mRecyclerView.mPrefetchRegistry.setPrefetchVector(0, 1);

        // prefetch 2 (default)
        mRecyclerView.mGapWorker.prefetch(RecyclerView.FOREVER_NS);
        RecyclerView.ViewHolder holder = CacheUtils.peekAtCachedViewForPosition(mRecyclerView, 2);
        assertNotNull(holder);
        assertNotNull(holder.mNestedRecyclerView);
        RecyclerView innerView = holder.mNestedRecyclerView.get();
        RecyclerView.Adapter innerAdapter = innerView.getAdapter();
        CacheUtils.verifyCacheContainsPrefetchedPositions(innerView, 0, 1);
        // mStructureChanged is initially true before first layout pass.
        assertTrue(innerView.mState.mStructureChanged);
        assertTrue(innerView.hasPendingAdapterUpdates());

        // layout position 2 and clear mStructureChanged
        mRecyclerView.scrollToPosition(2);
        layout(200, 200);
        mRecyclerView.scrollToPosition(0);
        layout(200, 200);
        assertFalse(innerView.mState.mStructureChanged);
        assertFalse(innerView.hasPendingAdapterUpdates());

        // notify change on the cached innerView.
        innerAdapter.notifyDataSetChanged();
        assertTrue(innerView.mState.mStructureChanged);
        assertTrue(innerView.hasPendingAdapterUpdates());

        // prefetch again
        mRecyclerView.mPrefetchRegistry.setPrefetchVector(0, 1);
        ((LinearLayoutManager) innerView.getLayoutManager())
                .setInitialPrefetchItemCount(2);
        mRecyclerView.mGapWorker.prefetch(RecyclerView.FOREVER_NS);
        CacheUtils.verifyCacheContainsPrefetchedPositions(innerView, 0, 1);

        // The re-prefetch is not necessary get the same inner view but we will get same Adapter
        holder = CacheUtils.peekAtCachedViewForPosition(mRecyclerView, 2);
        innerView = holder.mNestedRecyclerView.get();
        assertSame(innerAdapter, innerView.getAdapter());
        // prefetch shouldn't clear the mStructureChanged flag
        assertTrue(innerView.mState.mStructureChanged);
        assertTrue(innerView.hasPendingAdapterUpdates());
    }

    @Test
    public void nestedPrefetchReverseInner() {
        mRecyclerView.setLayoutManager(new LinearLayoutManager(getContext()));
        mRecyclerView.setAdapter(new OuterAdapter(/* reverseInner = */ true));

        layout(200, 200);
        mRecyclerView.mPrefetchRegistry.setPrefetchVector(0, 1);

        mRecyclerView.mGapWorker.prefetch(RecyclerView.FOREVER_NS);
        RecyclerView.ViewHolder holder = CacheUtils.peekAtCachedViewForPosition(mRecyclerView, 2);

        // anchor from right side, should see last two positions
        CacheUtils.verifyCacheContainsPrefetchedPositions(holder.mNestedRecyclerView.get(), 18, 19);
    }

    @Test
    public void nestedPrefetchOffset() {
        mRecyclerView.setLayoutManager(new LinearLayoutManager(getContext()));
        mRecyclerView.setAdapter(new OuterAdapter());

        layout(200, 200);

        // Scroll top row by 5.5 items, verify positions 5, 6, 7 showing
        RecyclerView inner = (RecyclerView) mRecyclerView.getChildAt(0);
        inner.scrollBy(550, 0);
        assertEquals(5, RecyclerView.getChildViewHolderInt(inner.getChildAt(0)).mPosition);
        assertEquals(6, RecyclerView.getChildViewHolderInt(inner.getChildAt(1)).mPosition);
        assertEquals(7, RecyclerView.getChildViewHolderInt(inner.getChildAt(2)).mPosition);

        // scroll down 4 rows, up 3 so row 0 is adjacent but uncached
        mRecyclerView.scrollBy(0, 400);
        mRecyclerView.scrollBy(0, -300);

        // top row no longer present
        CacheUtils.verifyCacheDoesNotContainPositions(mRecyclerView, 0);

        // prefetch upward, and validate that we've gotten the top row with correct offsets
        mRecyclerView.mPrefetchRegistry.setPrefetchVector(0, -1);
        mRecyclerView.mGapWorker.prefetch(RecyclerView.FOREVER_NS);
        inner = (RecyclerView) CacheUtils.peekAtCachedViewForPosition(mRecyclerView, 0).itemView;
        CacheUtils.verifyCacheContainsPrefetchedPositions(inner, 5, 6);

        // prefetch 4
        ((LinearLayoutManager) inner.getLayoutManager()).setInitialPrefetchItemCount(4);
        mRecyclerView.mGapWorker.prefetch(RecyclerView.FOREVER_NS);
        CacheUtils.verifyCacheContainsPrefetchedPositions(inner, 5, 6, 7, 8);
    }

    @Test
    public void nestedPrefetchNotReset() {
        mRecyclerView.setLayoutManager(new LinearLayoutManager(getContext()));
        OuterAdapter outerAdapter = new OuterAdapter();
        mRecyclerView.setAdapter(outerAdapter);

        layout(200, 200);

        mRecyclerView.mPrefetchRegistry.setPrefetchVector(0, 1);

        // prefetch row 2, items 0 & 1
        assertEquals(0, outerAdapter.mAdapters.get(2).mItemsBound);
        mRecyclerView.mGapWorker.prefetch(RecyclerView.FOREVER_NS);
        RecyclerView.ViewHolder holder = CacheUtils.peekAtCachedViewForPosition(mRecyclerView, 2);
        RecyclerView innerRecyclerView = holder.mNestedRecyclerView.get();

        assertNotNull(innerRecyclerView);
        CacheUtils.verifyCacheContainsPrefetchedPositions(innerRecyclerView, 0, 1);
        assertEquals(2, outerAdapter.mAdapters.get(2).mItemsBound);

        // new row comes on, triggers layout...
        mRecyclerView.scrollBy(0, 50);

        // ... which shouldn't require new items to be bound,
        // as prefetch has already done that work
        assertEquals(2, outerAdapter.mAdapters.get(2).mItemsBound);
    }

    static void validateRvChildrenValid(RecyclerView recyclerView, int childCount) {
        ChildHelper childHelper = recyclerView.mChildHelper;

        assertEquals(childCount, childHelper.getUnfilteredChildCount());
        for (int i = 0; i < childHelper.getUnfilteredChildCount(); i++) {
            assertFalse(recyclerView.getChildViewHolder(
                    childHelper.getUnfilteredChildAt(i)).isInvalid());
        }
    }

    @Test
    public void nestedPrefetchCacheNotTouched() {
        mRecyclerView.setLayoutManager(new LinearLayoutManager(getContext()));
        OuterAdapter outerAdapter = new OuterAdapter();
        mRecyclerView.setAdapter(outerAdapter);

        layout(200, 200);
        mRecyclerView.scrollBy(0, 100);

        // item 0 is cached
        assertEquals(2, outerAdapter.mAdapters.get(0).mItemsBound);
        RecyclerView.ViewHolder holder = CacheUtils.peekAtCachedViewForPosition(mRecyclerView, 0);
        validateRvChildrenValid(holder.mNestedRecyclerView.get(), 2);

        // try and prefetch it
        mRecyclerView.mPrefetchRegistry.setPrefetchVector(0, -1);
        mRecyclerView.mGapWorker.prefetch(RecyclerView.FOREVER_NS);

        // make sure cache's inner items aren't rebound unnecessarily
        assertEquals(2, outerAdapter.mAdapters.get(0).mItemsBound);
        validateRvChildrenValid(holder.mNestedRecyclerView.get(), 2);
    }

    @Test
    public void nestedRemoveAnimatingView() {
        mRecyclerView.setLayoutManager(new LinearLayoutManager(getContext()));
        OuterAdapter outerAdapter = new OuterAdapter(false, 1);
        mRecyclerView.setAdapter(outerAdapter);
        mRecyclerView.getItemAnimator().setAddDuration(TimeUnit.MILLISECONDS.toNanos(30));

        layout(200, 200);

        // Insert 3 items - only first one in viewport, so only it animates
        for (int i = 0; i < 3; i++) {
            outerAdapter.addItem();
        }
        layout(200, 200); // layout again to kick off animation


        // item 1 is animating, so scroll it out of viewport
        mRecyclerView.scrollBy(0, 200);

        // 2 items attached, 1 cached (pos 0), but item animating pos 1 not accounted for...
        assertEquals(2, mRecyclerView.mChildHelper.getUnfilteredChildCount());
        assertEquals(1, mRecycler.mCachedViews.size());
        CacheUtils.verifyCacheContainsPositions(mRecyclerView, 0);
        assertEquals(0, mRecyclerView.getRecycledViewPool().getRecycledViewCount(0));

        // until animation ends
        mRecyclerView.getItemAnimator().endAnimations();
        assertEquals(2, mRecyclerView.mChildHelper.getUnfilteredChildCount());
        assertEquals(2, mRecycler.mCachedViews.size());
        CacheUtils.verifyCacheContainsPositions(mRecyclerView, 0, 1);
        assertEquals(0, mRecyclerView.getRecycledViewPool().getRecycledViewCount(0));

        for (RecyclerView.ViewHolder viewHolder : mRecycler.mCachedViews) {
            assertNotNull(viewHolder.mNestedRecyclerView);
        }
    }

    @Test
    public void nestedExpandCacheCorrectly() {
        final int DEFAULT_CACHE_SIZE = RecyclerView.Recycler.DEFAULT_CACHE_SIZE;

        mRecyclerView.setLayoutManager(new LinearLayoutManager(getContext()));
        OuterAdapter outerAdapter = new OuterAdapter();
        mRecyclerView.setAdapter(outerAdapter);

        layout(200, 200);

        mRecyclerView.mPrefetchRegistry.setPrefetchVector(0, 1);
        mRecyclerView.mGapWorker.prefetch(RecyclerView.FOREVER_NS);

        // after initial prefetch, view cache max expanded by number of inner items prefetched (2)
        RecyclerView.ViewHolder holder = CacheUtils.peekAtCachedViewForPosition(mRecyclerView, 2);
        RecyclerView innerView = holder.mNestedRecyclerView.get();
        assertTrue(innerView.getLayoutManager().mPrefetchMaxObservedInInitialPrefetch);
        assertEquals(2, innerView.getLayoutManager().mPrefetchMaxCountObserved);
        assertEquals(2 + DEFAULT_CACHE_SIZE, innerView.mRecycler.mViewCacheMax);

        try {
            // Note: As a hack, we not only must manually dispatch attachToWindow(), but we
            // also have to be careful to call innerView.mGapWorker below. mRecyclerView.mGapWorker
            // is registered to the wrong thread, since @setup is called on a different thread
            // from @Test. Assert this, so this test can be fixed when setup == test thread.
            assertEquals(1, mRecyclerView.mGapWorker.mRecyclerViews.size());
            assertFalse(innerView.isAttachedToWindow());
            innerView.onAttachedToWindow();

            // bring prefetch view into viewport, at which point it shouldn't have cache expanded...
            mRecyclerView.scrollBy(0, 100);
            assertFalse(innerView.getLayoutManager().mPrefetchMaxObservedInInitialPrefetch);
            assertEquals(0, innerView.getLayoutManager().mPrefetchMaxCountObserved);
            assertEquals(DEFAULT_CACHE_SIZE, innerView.mRecycler.mViewCacheMax);

            // until a valid horizontal prefetch caches an item, and expands view count by one
            innerView.mPrefetchRegistry.setPrefetchVector(1, 0);
            innerView.mGapWorker.prefetch(RecyclerView.FOREVER_NS); // NB: must be innerView.mGapWorker
            assertFalse(innerView.getLayoutManager().mPrefetchMaxObservedInInitialPrefetch);
            assertEquals(1, innerView.getLayoutManager().mPrefetchMaxCountObserved);
            assertEquals(1 + DEFAULT_CACHE_SIZE, innerView.mRecycler.mViewCacheMax);
        } finally {
            if (innerView.isAttachedToWindow()) {
                innerView.onDetachedFromWindow();
            }
        }
    }

    /**
     * Similar to OuterAdapter above, but uses notifyDataSetChanged() instead of set/swapAdapter
     * to update data for the inner RecyclerViews when containing ViewHolder is bound.
     */
    class OuterNotifyAdapter extends RecyclerView.Adapter<OuterNotifyAdapter.ViewHolder> {
        private static final int OUTER_ITEM_COUNT = 10;

        private boolean mReverseInner;

        class ViewHolder extends RecyclerView.ViewHolder {
            private final RecyclerView mRecyclerView;
            private final InnerAdapter mAdapter;
            ViewHolder(RecyclerView itemView) {
                super(itemView);
                mRecyclerView = itemView;
                mAdapter = new InnerAdapter();
                mRecyclerView.setAdapter(mAdapter);
            }
        }

        ArrayList<Parcelable> mSavedStates = new ArrayList<>();
        RecyclerView.RecycledViewPool mSharedPool = new RecyclerView.RecycledViewPool();

        OuterNotifyAdapter() {
            this(false);
        }

        OuterNotifyAdapter(boolean reverseInner) {
            mReverseInner = reverseInner;
            for (int i = 0; i <= OUTER_ITEM_COUNT; i++) {
                mSavedStates.add(null);
            }
        }

        @NonNull
        @Override
        public ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
            mRecyclerView.registerTimePassingMs(5);
            RecyclerView rv = new RecyclerView(parent.getContext());
            rv.setLayoutManager(new LinearLayoutManager(parent.getContext(),
                    LinearLayoutManager.HORIZONTAL, mReverseInner));
            rv.setRecycledViewPool(mSharedPool);
            rv.setLayoutParams(new RecyclerView.LayoutParams(200, 100));
            return new ViewHolder(rv);
        }

        @Override
        public void onBindViewHolder(@NonNull ViewHolder holder, int position) {
            mRecyclerView.registerTimePassingMs(5);
            // if we had actual data to put into our adapter, this is where we'd do it...

            // ... then notify the adapter that it has new content:
            holder.mAdapter.notifyDataSetChanged();

            Parcelable savedState = mSavedStates.get(position);
            if (savedState != null) {
                holder.mRecyclerView.getLayoutManager().onRestoreInstanceState(savedState);
                mSavedStates.set(position, null);
            }
        }

        @Override
        public void onViewRecycled(@NonNull ViewHolder holder) {
            if (holder.getAdapterPosition() >= 0) {
                mSavedStates.set(holder.getAdapterPosition(),
                        holder.mRecyclerView.getLayoutManager().onSaveInstanceState());
            }
        }

        @Override
        public int getItemCount() {
            return OUTER_ITEM_COUNT;
        }
    }

    @Test
    public void nestedPrefetchDiscardStaleChildren() {
        LinearLayoutManager llm = new LinearLayoutManager(getContext());
        assertEquals(2, llm.getInitialPrefetchItemCount());

        mRecyclerView.setLayoutManager(llm);
        OuterNotifyAdapter outerAdapter = new OuterNotifyAdapter();
        mRecyclerView.setAdapter(outerAdapter);

        // zero cache, so item we prefetch can't already be ready
        mRecyclerView.setItemViewCacheSize(0);

        // layout 3 items, then resize to 2...
        layout(200, 300);
        layout(200, 200);

        // so 1 item is evicted into the RecycledViewPool (bypassing cache)
        assertEquals(1, mRecycler.mRecyclerPool.getRecycledViewCount(0));
        assertEquals(0, mRecycler.mCachedViews.size());

        // This is a simple imitation of other behavior (namely, varied types in the outer adapter)
        // that results in the same initial state to test: items in the pool with attached children
        for (RecyclerView.ViewHolder holder : mRecycler.mRecyclerPool.mScrap.get(0).mScrapHeap) {
            // verify that children are attached and valid, since the RVs haven't been rebound
            assertNotNull(holder.mNestedRecyclerView);
            assertFalse(holder.mNestedRecyclerView.get().mDataSetHasChangedAfterLayout);
            validateRvChildrenValid(holder.mNestedRecyclerView.get(), 2);
        }

        // prefetch the outer item bind, but without enough time to do any inner binds
        final long deadlineNs = mRecyclerView.getNanoTime() + TimeUnit.MILLISECONDS.toNanos(9);
        mRecyclerView.mPrefetchRegistry.setPrefetchVector(0, 1);
        mRecyclerView.mGapWorker.prefetch(deadlineNs);

        // 2 is prefetched without children
        CacheUtils.verifyCacheContainsPrefetchedPositions(mRecyclerView, 2);
        RecyclerView.ViewHolder holder = CacheUtils.peekAtCachedViewForPosition(mRecyclerView, 2);
        assertNotNull(holder);
        assertNotNull(holder.mNestedRecyclerView);
        assertEquals(0, holder.mNestedRecyclerView.get().mChildHelper.getUnfilteredChildCount());
        assertEquals(0, holder.mNestedRecyclerView.get().mRecycler.mCachedViews.size());

        // but if we give it more time to bind items, it'll now acquire its inner items
        mRecyclerView.mGapWorker.prefetch(RecyclerView.FOREVER_NS);
        CacheUtils.verifyCacheContainsPrefetchedPositions(holder.mNestedRecyclerView.get(), 0, 1);
    }


    @Test
    public void nestedPrefetchDiscardStalePrefetch() {
        mRecyclerView.setLayoutManager(new LinearLayoutManager(getContext()));
        OuterNotifyAdapter outerAdapter = new OuterNotifyAdapter();
        mRecyclerView.setAdapter(outerAdapter);

        // zero cache, so item we prefetch can't already be ready
        mRecyclerView.setItemViewCacheSize(0);

        // layout as 2x2, starting on row index 2, with empty cache
        layout(200, 200);
        mRecyclerView.scrollBy(0, 200);

        // no views cached, or previously used (so we can trust number in mItemsBound)
        mRecycler.mRecyclerPool.clear();
        assertEquals(0, mRecycler.mRecyclerPool.getRecycledViewCount(0));
        assertEquals(0, mRecycler.mCachedViews.size());

        // prefetch the outer item and its inner children
        mRecyclerView.mPrefetchRegistry.setPrefetchVector(0, 1);
        mRecyclerView.mGapWorker.prefetch(RecyclerView.FOREVER_NS);

        // 4 is prefetched with 2 inner children, first two binds
        CacheUtils.verifyCacheContainsPrefetchedPositions(mRecyclerView, 4);
        RecyclerView.ViewHolder holder = CacheUtils.peekAtCachedViewForPosition(mRecyclerView, 4);
        assertNotNull(holder);
        assertNotNull(holder.mNestedRecyclerView);
        RecyclerView innerRecyclerView = holder.mNestedRecyclerView.get();
        assertEquals(0, innerRecyclerView.mChildHelper.getUnfilteredChildCount());
        assertEquals(2, innerRecyclerView.mRecycler.mCachedViews.size());
        assertEquals(2, ((InnerAdapter) innerRecyclerView.getAdapter()).mItemsBound);

        // notify data set changed, so any previously prefetched items invalid, and re-prefetch
        innerRecyclerView.getAdapter().notifyDataSetChanged();
        mRecyclerView.mPrefetchRegistry.setPrefetchVector(0, 1);
        mRecyclerView.mGapWorker.prefetch(RecyclerView.FOREVER_NS);

        // 4 is prefetched again...
        CacheUtils.verifyCacheContainsPrefetchedPositions(mRecyclerView, 4);

        // reusing the same instance with 2 inner children...
        assertSame(holder, CacheUtils.peekAtCachedViewForPosition(mRecyclerView, 4));
        assertSame(innerRecyclerView, holder.mNestedRecyclerView.get());
        assertEquals(0, innerRecyclerView.mChildHelper.getUnfilteredChildCount());
        assertEquals(2, innerRecyclerView.mRecycler.mCachedViews.size());

        // ... but there should be two new binds
        assertEquals(4, ((InnerAdapter) innerRecyclerView.getAdapter()).mItemsBound);
    }

    @Test
    public void setRecycledViewPool_followedByTwoSetAdapters_clearsRecycledViewPool() {
        RecyclerView.ViewHolder viewHolder = new RecyclerView.ViewHolder(new View(getContext())) {};
        viewHolder.mItemViewType = 123;
        RecyclerView.Adapter adapter = mock(RecyclerView.Adapter.class);
        RecyclerView recyclerView = new RecyclerView(getContext());
        RecyclerView.RecycledViewPool recycledViewPool = new RecyclerView.RecycledViewPool();
        recycledViewPool.putRecycledView(viewHolder);

        recyclerView.setRecycledViewPool(recycledViewPool);
        recyclerView.setAdapter(adapter);
        recyclerView.setAdapter(adapter);

        assertThat(recycledViewPool.getRecycledViewCount(123), is(equalTo(0)));
    }

    @Test
    public void setRecycledViewPool_followedByTwoSwapAdapters_doesntClearRecycledViewPool() {
        RecyclerView.ViewHolder viewHolder = new RecyclerView.ViewHolder(new View(getContext())) {};
        viewHolder.mItemViewType = 123;
        RecyclerView.Adapter adapter = mock(RecyclerView.Adapter.class);
        RecyclerView recyclerView = new RecyclerView(getContext());
        RecyclerView.RecycledViewPool recycledViewPool = new RecyclerView.RecycledViewPool();
        recycledViewPool.putRecycledView(viewHolder);

        recyclerView.setRecycledViewPool(recycledViewPool);
        recyclerView.swapAdapter(adapter, false);
        recyclerView.swapAdapter(adapter, false);

        assertThat(recycledViewPool.getRecycledViewCount(123), is(equalTo(1)));
    }
}