/*
* Copyright (C) 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.support.v7.widget;
import android.graphics.Rect;
import android.os.Debug;
import android.os.Looper;
import android.os.Parcel;
import android.os.Parcelable;
import android.support.v4.view.AccessibilityDelegateCompat;
import android.support.v4.view.accessibility.AccessibilityEventCompat;
import android.support.v4.view.accessibility.AccessibilityRecordCompat;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.view.accessibility.AccessibilityEvent;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import static android.support.v7.widget.LayoutState.*;
import static android.support.v7.widget.LinearLayoutManager.VERTICAL;
import static android.support.v7.widget.StaggeredGridLayoutManager.*;
public class StaggeredGridLayoutManagerTest extends BaseRecyclerViewInstrumentationTest {
private static final boolean DEBUG = false;
private static final String TAG = "StaggeredGridLayoutManagerTest";
volatile WrappedLayoutManager mLayoutManager;
GridTestAdapter mAdapter;
final List<Config> mBaseVariations = new ArrayList<Config>();
@Override
protected void setUp() throws Exception {
super.setUp();
for (int orientation : new int[]{VERTICAL, HORIZONTAL}) {
for (boolean reverseLayout : new boolean[]{false, true}) {
for (int spanCount : new int[]{1, 3}) {
for (int gapStrategy : new int[]{GAP_HANDLING_NONE,
GAP_HANDLING_MOVE_ITEMS_BETWEEN_SPANS}) {
mBaseVariations.add(new Config(orientation, reverseLayout, spanCount,
gapStrategy));
}
}
}
}
}
void setupByConfig(Config config) throws Throwable {
mAdapter = new GridTestAdapter(config.mItemCount, config.mOrientation);
mRecyclerView = new RecyclerView(getActivity());
mRecyclerView.setAdapter(mAdapter);
mRecyclerView.setHasFixedSize(true);
mLayoutManager = new WrappedLayoutManager(config.mSpanCount,
config.mOrientation);
mLayoutManager.setGapStrategy(config.mGapStrategy);
mLayoutManager.setReverseLayout(config.mReverseLayout);
mRecyclerView.setLayoutManager(mLayoutManager);
mRecyclerView.addItemDecoration(new RecyclerView.ItemDecoration() {
@Override
public void getItemOffsets(Rect outRect, View view, RecyclerView parent,
RecyclerView.State state) {
try {
LayoutParams lp = (LayoutParams) view.getLayoutParams();
assertNotNull("view should have layout params assigned", lp);
assertNotNull("when item offsets are requested, view should have a valid span",
lp.mSpan);
} catch (Throwable t) {
postExceptionToInstrumentation(t);
}
}
});
}
public void testAreAllStartsTheSame() throws Throwable {
setupByConfig(new Config(VERTICAL, false, 3, GAP_HANDLING_NONE).itemCount(300));
waitFirstLayout();
smoothScrollToPosition(100);
mLayoutManager.expectLayouts(1);
mAdapter.deleteAndNotify(0, 2);
mLayoutManager.waitForLayout(2);
smoothScrollToPosition(0);
assertFalse("all starts should not be the same", mLayoutManager.areAllStartsEqual());
}
public void testAreAllEndsTheSame() throws Throwable {
setupByConfig(new Config(VERTICAL, true, 3, GAP_HANDLING_NONE).itemCount(300));
waitFirstLayout();
smoothScrollToPosition(100);
mLayoutManager.expectLayouts(1);
mAdapter.deleteAndNotify(0, 2);
mLayoutManager.waitForLayout(2);
smoothScrollToPosition(0);
assertFalse("all ends should not be the same", mLayoutManager.areAllEndsEqual());
}
public void testFindLastInUnevenDistribution() throws Throwable {
setupByConfig(new Config(VERTICAL, false, 2, GAP_HANDLING_MOVE_ITEMS_BETWEEN_SPANS)
.itemCount(5));
mAdapter.mOnBindHandler = new OnBindHandler() {
@Override
void onBoundItem(TestViewHolder vh, int position) {
LayoutParams lp = (LayoutParams) vh.itemView.getLayoutParams();
if (position == 1) {
lp.height = mRecyclerView.getHeight() - 10;
} else {
lp.height = 5;
}
}
};
waitFirstLayout();
int[] into = new int[2];
mLayoutManager.findFirstCompletelyVisibleItemPositions(into);
assertEquals("first completely visible item from span 0 should be 0", 0, into[0]);
assertEquals("first completely visible item from span 1 should be 1", 1, into[1]);
mLayoutManager.findLastCompletelyVisibleItemPositions(into);
assertEquals("last completely visible item from span 0 should be 4", 4, into[0]);
assertEquals("last completely visible item from span 1 should be 1", 1, into[1]);
assertEquals("first fully visible child should be at position",
0, mRecyclerView.getChildViewHolder(mLayoutManager.
findFirstVisibleItemClosestToStart(true, true)).getPosition());
assertEquals("last fully visible child should be at position",
4, mRecyclerView.getChildViewHolder(mLayoutManager.
findFirstVisibleItemClosestToEnd(true, true)).getPosition());
assertEquals("first visible child should be at position",
0, mRecyclerView.getChildViewHolder(mLayoutManager.
findFirstVisibleItemClosestToStart(false, true)).getPosition());
assertEquals("last visible child should be at position",
4, mRecyclerView.getChildViewHolder(mLayoutManager.
findFirstVisibleItemClosestToEnd(false, true)).getPosition());
}
public void testCustomWidthInHorizontal() throws Throwable {
customSizeInScrollDirectionTest(
new Config(HORIZONTAL, false, 3, GAP_HANDLING_MOVE_ITEMS_BETWEEN_SPANS));
}
public void testCustomHeightInVertical() throws Throwable {
customSizeInScrollDirectionTest(
new Config(VERTICAL, false, 3, GAP_HANDLING_MOVE_ITEMS_BETWEEN_SPANS));
}
public void customSizeInScrollDirectionTest(final Config config) throws Throwable {
setupByConfig(config);
final Map<View, Integer> sizeMap = new HashMap<View, Integer>();
mAdapter.mOnBindHandler = new OnBindHandler() {
@Override
void onBoundItem(TestViewHolder vh, int position) {
final ViewGroup.LayoutParams layoutParams = vh.itemView.getLayoutParams();
final int size = 1 + position * 5;
if (config.mOrientation == HORIZONTAL) {
layoutParams.width = size;
} else {
layoutParams.height = size;
}
sizeMap.put(vh.itemView, size);
if (position == 3) {
getLp(vh.itemView).setFullSpan(true);
}
}
@Override
boolean assignRandomSize() {
return false;
}
};
waitFirstLayout();
assertTrue("[test sanity] some views should be laid out", sizeMap.size() > 0);
for (int i = 0; i < mRecyclerView.getChildCount(); i++) {
View child = mRecyclerView.getChildAt(i);
final int size = config.mOrientation == HORIZONTAL ? child.getWidth()
: child.getHeight();
assertEquals("child " + i + " should have the size specified in its layout params",
sizeMap.get(child).intValue(), size);
}
checkForMainThreadException();
}
public void testGrowLookup() throws Throwable {
setupByConfig(new Config(VERTICAL, false, 3, GAP_HANDLING_MOVE_ITEMS_BETWEEN_SPANS));
waitFirstLayout();
mLayoutManager.expectLayouts(1);
mAdapter.mItems.clear();
mAdapter.dispatchDataSetChanged();
mLayoutManager.waitForLayout(2);
checkForMainThreadException();
mLayoutManager.expectLayouts(2);
mAdapter.addAndNotify(0, 30);
mLayoutManager.waitForLayout(2);
checkForMainThreadException();
}
public void testRTL() throws Throwable {
for (boolean changeRtlAfter : new boolean[]{false, true}) {
for (Config config : mBaseVariations) {
rtlTest(config, changeRtlAfter);
removeRecyclerView();
}
}
}
void rtlTest(Config config, boolean changeRtlAfter) throws Throwable {
if (config.mSpanCount == 1) {
config.mSpanCount = 2;
}
String logPrefix = config + ", changeRtlAfterLayout:" + changeRtlAfter;
setupByConfig(config.itemCount(5));
if (changeRtlAfter) {
waitFirstLayout();
mLayoutManager.expectLayouts(1);
mLayoutManager.setFakeRtl(true);
mLayoutManager.waitForLayout(2);
} else {
mLayoutManager.mFakeRTL = true;
waitFirstLayout();
}
assertEquals("view should become rtl", true, mLayoutManager.isLayoutRTL());
OrientationHelper helper = OrientationHelper.createHorizontalHelper(mLayoutManager);
View child0 = mLayoutManager.findViewByPosition(0);
View child1 = mLayoutManager.findViewByPosition(config.mOrientation == VERTICAL ? 1
: config.mSpanCount);
assertNotNull(logPrefix + " child position 0 should be laid out", child0);
assertNotNull(logPrefix + " child position 0 should be laid out", child1);
if (config.mOrientation == VERTICAL || !config.mReverseLayout) {
assertTrue(logPrefix + " second child should be to the left of first child",
helper.getDecoratedStart(child0) >= helper.getDecoratedEnd(child1));
assertEquals(logPrefix + " first child should be right aligned",
helper.getDecoratedEnd(child0), helper.getEndAfterPadding());
} else {
assertTrue(logPrefix + " first child should be to the left of second child",
helper.getDecoratedStart(child1) >= helper.getDecoratedEnd(child0));
assertEquals(logPrefix + " first child should be left aligned",
helper.getDecoratedStart(child0), helper.getStartAfterPadding());
}
checkForMainThreadException();
}
public void testScrollBackAndPreservePositions() throws Throwable {
for (boolean saveRestore : new boolean[]{false, true}) {
for (Config config : mBaseVariations) {
scrollBackAndPreservePositionsTest(config, saveRestore);
removeRecyclerView();
}
}
}
public void scrollBackAndPreservePositionsTest(final Config config,
final boolean saveRestoreInBetween)
throws Throwable {
setupByConfig(config);
mAdapter.mOnBindHandler = new OnBindHandler() {
@Override
public void onBoundItem(TestViewHolder vh, int position) {
LayoutParams lp = (LayoutParams) vh.itemView.getLayoutParams();
lp.setFullSpan((position * 7) % (config.mSpanCount + 1) == 0);
}
};
waitFirstLayout();
final int[] globalPositions = new int[mAdapter.getItemCount()];
Arrays.fill(globalPositions, Integer.MIN_VALUE);
final int scrollStep = (mLayoutManager.mPrimaryOrientation.getTotalSpace() / 10)
* (config.mReverseLayout ? -1 : 1);
final int[] globalPos = new int[1];
runTestOnUiThread(new Runnable() {
@Override
public void run() {
int globalScrollPosition = 0;
while (globalPositions[mAdapter.getItemCount() - 1] == Integer.MIN_VALUE) {
for (int i = 0; i < mRecyclerView.getChildCount(); i++) {
View child = mRecyclerView.getChildAt(i);
final int pos = mRecyclerView.getChildLayoutPosition(child);
if (globalPositions[pos] != Integer.MIN_VALUE) {
continue;
}
if (config.mReverseLayout) {
globalPositions[pos] = globalScrollPosition +
mLayoutManager.mPrimaryOrientation.getDecoratedEnd(child);
} else {
globalPositions[pos] = globalScrollPosition +
mLayoutManager.mPrimaryOrientation.getDecoratedStart(child);
}
}
globalScrollPosition += mLayoutManager.scrollBy(scrollStep,
mRecyclerView.mRecycler, mRecyclerView.mState);
}
if (DEBUG) {
Log.d(TAG, "done recording positions " + Arrays.toString(globalPositions));
}
globalPos[0] = globalScrollPosition;
}
});
checkForMainThreadException();
if (saveRestoreInBetween) {
saveRestore(config);
}
checkForMainThreadException();
runTestOnUiThread(new Runnable() {
@Override
public void run() {
int globalScrollPosition = globalPos[0];
// now scroll back and make sure global positions match
BitSet shouldTest = new BitSet(mAdapter.getItemCount());
shouldTest.set(0, mAdapter.getItemCount() - 1, true);
String assertPrefix = config + ", restored in between:" + saveRestoreInBetween
+ " global pos must match when scrolling in reverse for position ";
int scrollAmount = Integer.MAX_VALUE;
while (!shouldTest.isEmpty() && scrollAmount != 0) {
for (int i = 0; i < mRecyclerView.getChildCount(); i++) {
View child = mRecyclerView.getChildAt(i);
int pos = mRecyclerView.getChildLayoutPosition(child);
if (!shouldTest.get(pos)) {
continue;
}
shouldTest.clear(pos);
int globalPos;
if (config.mReverseLayout) {
globalPos = globalScrollPosition +
mLayoutManager.mPrimaryOrientation.getDecoratedEnd(child);
} else {
globalPos = globalScrollPosition +
mLayoutManager.mPrimaryOrientation.getDecoratedStart(child);
}
assertEquals(assertPrefix + pos,
globalPositions[pos], globalPos);
}
scrollAmount = mLayoutManager.scrollBy(-scrollStep,
mRecyclerView.mRecycler, mRecyclerView.mState);
globalScrollPosition += scrollAmount;
}
assertTrue("all views should be seen", shouldTest.isEmpty());
}
});
checkForMainThreadException();
}
public void testScrollToPositionWithPredictive() throws Throwable {
scrollToPositionWithPredictive(0, LinearLayoutManager.INVALID_OFFSET);
removeRecyclerView();
scrollToPositionWithPredictive(Config.DEFAULT_ITEM_COUNT / 2,
LinearLayoutManager.INVALID_OFFSET);
removeRecyclerView();
scrollToPositionWithPredictive(9, 20);
removeRecyclerView();
scrollToPositionWithPredictive(Config.DEFAULT_ITEM_COUNT / 2, 10);
}
public void scrollToPositionWithPredictive(final int scrollPosition, final int scrollOffset)
throws Throwable {
setupByConfig(new Config(StaggeredGridLayoutManager.VERTICAL,
false, 3, StaggeredGridLayoutManager.GAP_HANDLING_NONE));
waitFirstLayout();
mLayoutManager.mOnLayoutListener = new OnLayoutListener() {
@Override
void after(RecyclerView.Recycler recycler, RecyclerView.State state) {
RecyclerView rv = mLayoutManager.mRecyclerView;
if (state.isPreLayout()) {
assertEquals("pending scroll position should still be pending",
scrollPosition, mLayoutManager.mPendingScrollPosition);
if (scrollOffset != LinearLayoutManager.INVALID_OFFSET) {
assertEquals("pending scroll position offset should still be pending",
scrollOffset, mLayoutManager.mPendingScrollPositionOffset);
}
} else {
RecyclerView.ViewHolder vh = rv.findViewHolderForLayoutPosition(scrollPosition);
assertNotNull("scroll to position should work", vh);
if (scrollOffset != LinearLayoutManager.INVALID_OFFSET) {
assertEquals("scroll offset should be applied properly",
mLayoutManager.getPaddingTop() + scrollOffset
+ ((RecyclerView.LayoutParams) vh.itemView
.getLayoutParams()).topMargin,
mLayoutManager.getDecoratedTop(vh.itemView));
}
}
}
};
mLayoutManager.expectLayouts(2);
runTestOnUiThread(new Runnable() {
@Override
public void run() {
try {
mAdapter.addAndNotify(0, 1);
if (scrollOffset == LinearLayoutManager.INVALID_OFFSET) {
mLayoutManager.scrollToPosition(scrollPosition);
} else {
mLayoutManager.scrollToPositionWithOffset(scrollPosition,
scrollOffset);
}
} catch (Throwable throwable) {
throwable.printStackTrace();
}
}
});
mLayoutManager.waitForLayout(2);
checkForMainThreadException();
}
LayoutParams getLp(View view) {
return (LayoutParams) view.getLayoutParams();
}
public void testGetFirstLastChildrenTest() throws Throwable {
for (boolean provideArr : new boolean[]{true, false}) {
for (Config config : mBaseVariations) {
getFirstLastChildrenTest(config, provideArr);
removeRecyclerView();
}
}
}
public void getFirstLastChildrenTest(final Config config, final boolean provideArr)
throws Throwable {
setupByConfig(config);
waitFirstLayout();
Runnable viewInBoundsTest = new Runnable() {
@Override
public void run() {
VisibleChildren visibleChildren = mLayoutManager.traverseAndFindVisibleChildren();
final String boundsLog = mLayoutManager.getBoundsLog();
VisibleChildren queryResult = new VisibleChildren(mLayoutManager.getSpanCount());
queryResult.firstFullyVisiblePositions = mLayoutManager
.findFirstCompletelyVisibleItemPositions(
provideArr ? new int[mLayoutManager.getSpanCount()] : null);
queryResult.firstVisiblePositions = mLayoutManager
.findFirstVisibleItemPositions(
provideArr ? new int[mLayoutManager.getSpanCount()] : null);
queryResult.lastFullyVisiblePositions = mLayoutManager
.findLastCompletelyVisibleItemPositions(
provideArr ? new int[mLayoutManager.getSpanCount()] : null);
queryResult.lastVisiblePositions = mLayoutManager
.findLastVisibleItemPositions(
provideArr ? new int[mLayoutManager.getSpanCount()] : null);
assertEquals(config + ":\nfirst visible child should match traversal result\n"
+ "traversed:" + visibleChildren + "\n"
+ "queried:" + queryResult + "\n"
+ boundsLog, visibleChildren, queryResult
);
}
};
runTestOnUiThread(viewInBoundsTest);
// smooth scroll to end of the list and keep testing meanwhile. This will test pre-caching
// case
final int scrollPosition = mAdapter.getItemCount();
runTestOnUiThread(new Runnable() {
@Override
public void run() {
mRecyclerView.smoothScrollToPosition(scrollPosition);
}
});
while (mLayoutManager.isSmoothScrolling() ||
mRecyclerView.getScrollState() != RecyclerView.SCROLL_STATE_IDLE) {
runTestOnUiThread(viewInBoundsTest);
checkForMainThreadException();
Thread.sleep(400);
}
// delete all items
mLayoutManager.expectLayouts(2);
mAdapter.deleteAndNotify(0, mAdapter.getItemCount());
mLayoutManager.waitForLayout(2);
// test empty case
runTestOnUiThread(viewInBoundsTest);
// set a new adapter with huge items to test full bounds check
mLayoutManager.expectLayouts(1);
final int totalSpace = mLayoutManager.mPrimaryOrientation.getTotalSpace();
final TestAdapter newAdapter = new TestAdapter(100) {
@Override
public void onBindViewHolder(TestViewHolder holder,
int position) {
super.onBindViewHolder(holder, position);
if (config.mOrientation == LinearLayoutManager.HORIZONTAL) {
holder.itemView.setMinimumWidth(totalSpace + 5);
} else {
holder.itemView.setMinimumHeight(totalSpace + 5);
}
}
};
runTestOnUiThread(new Runnable() {
@Override
public void run() {
mRecyclerView.setAdapter(newAdapter);
}
});
mLayoutManager.waitForLayout(2);
runTestOnUiThread(viewInBoundsTest);
checkForMainThreadException();
}
public void testMoveGapHandling() throws Throwable {
Config config = new Config().spanCount(2).itemCount(40);
setupByConfig(config);
waitFirstLayout();
mLayoutManager.expectLayouts(2);
mAdapter.moveAndNotify(4, 1);
mLayoutManager.waitForLayout(2);
assertNull("moving item to upper should not cause gaps", mLayoutManager.hasGapsToFix());
}
public void testUpdateAfterFullSpan() throws Throwable {
updateAfterFullSpanGapHandlingTest(0);
}
public void testUpdateAfterFullSpan2() throws Throwable {
updateAfterFullSpanGapHandlingTest(20);
}
public void testTemporaryGapHandling() throws Throwable {
int fullSpanIndex = 200;
setupByConfig(new Config().spanCount(2).itemCount(500));
mAdapter.mFullSpanItems.add(fullSpanIndex);
waitFirstLayout();
smoothScrollToPosition(fullSpanIndex + 30);
mLayoutManager.expectLayouts(1);
mAdapter.deleteAndNotify(fullSpanIndex + 1, 3);
mLayoutManager.waitForLayout(1);
smoothScrollToPosition(0);
mLayoutManager.expectLayouts(1);
smoothScrollToPosition(fullSpanIndex + 5);
mLayoutManager.assertNoLayout("if an interim gap is fixed, it should not cause a "
+ "relayout", 2);
View fullSpan = mLayoutManager.findViewByPosition(fullSpanIndex);
View view1 = mLayoutManager.findViewByPosition(fullSpanIndex + 1);
View view2 = mLayoutManager.findViewByPosition(fullSpanIndex + 2);
LayoutParams lp1 = (LayoutParams) view1.getLayoutParams();
LayoutParams lp2 = (LayoutParams) view2.getLayoutParams();
assertEquals("view 1 span index", 0, lp1.getSpanIndex());
assertEquals("view 2 span index", 1, lp2.getSpanIndex());
assertEquals("no gap between span and view 1",
mLayoutManager.mPrimaryOrientation.getDecoratedEnd(fullSpan),
mLayoutManager.mPrimaryOrientation.getDecoratedStart(view1));
assertEquals("no gap between span and view 2",
mLayoutManager.mPrimaryOrientation.getDecoratedEnd(fullSpan),
mLayoutManager.mPrimaryOrientation.getDecoratedStart(view2));
}
public void updateAfterFullSpanGapHandlingTest(int fullSpanIndex) throws Throwable {
setupByConfig(new Config().spanCount(2).itemCount(100));
mAdapter.mFullSpanItems.add(fullSpanIndex);
waitFirstLayout();
smoothScrollToPosition(fullSpanIndex + 30);
mLayoutManager.expectLayouts(1);
mAdapter.deleteAndNotify(fullSpanIndex + 1, 3);
mLayoutManager.waitForLayout(1);
smoothScrollToPosition(fullSpanIndex);
// give it some time to fix the gap
Thread.sleep(500);
View fullSpan = mLayoutManager.findViewByPosition(fullSpanIndex);
View view1 = mLayoutManager.findViewByPosition(fullSpanIndex + 1);
View view2 = mLayoutManager.findViewByPosition(fullSpanIndex + 2);
LayoutParams lp1 = (LayoutParams) view1.getLayoutParams();
LayoutParams lp2 = (LayoutParams) view2.getLayoutParams();
assertEquals("view 1 span index", 0, lp1.getSpanIndex());
assertEquals("view 2 span index", 1, lp2.getSpanIndex());
assertEquals("no gap between span and view 1",
mLayoutManager.mPrimaryOrientation.getDecoratedEnd(fullSpan),
mLayoutManager.mPrimaryOrientation.getDecoratedStart(view1));
assertEquals("no gap between span and view 2",
mLayoutManager.mPrimaryOrientation.getDecoratedEnd(fullSpan),
mLayoutManager.mPrimaryOrientation.getDecoratedStart(view2));
}
public void testInnerGapHandling() throws Throwable {
innerGapHandlingTest(StaggeredGridLayoutManager.GAP_HANDLING_NONE);
innerGapHandlingTest(StaggeredGridLayoutManager.GAP_HANDLING_MOVE_ITEMS_BETWEEN_SPANS);
}
public void innerGapHandlingTest(int strategy) throws Throwable {
Config config = new Config().spanCount(3).itemCount(500);
setupByConfig(config);
mLayoutManager.setGapStrategy(strategy);
mAdapter.mFullSpanItems.add(100);
mAdapter.mFullSpanItems.add(104);
mAdapter.mViewsHaveEqualSize = true;
waitFirstLayout();
mLayoutManager.expectLayouts(1);
scrollToPosition(400);
mLayoutManager.waitForLayout(2);
mLayoutManager.expectLayouts(2);
mAdapter.addAndNotify(101, 1);
mLayoutManager.waitForLayout(2);
if (strategy == GAP_HANDLING_MOVE_ITEMS_BETWEEN_SPANS) {
mLayoutManager.expectLayouts(1);
}
// state
// now smooth scroll to 99 to trigger a layout around 100
smoothScrollToPosition(99);
switch (strategy) {
case GAP_HANDLING_NONE:
assertSpans("gap handling:" + Config.gapStrategyName(strategy), new int[]{100, 0},
new int[]{101, 2}, new int[]{102, 0}, new int[]{103, 1}, new int[]{104, 2},
new int[]{105, 0});
break;
case GAP_HANDLING_MOVE_ITEMS_BETWEEN_SPANS:
mLayoutManager.waitForLayout(2);
assertSpans("swap items between spans", new int[]{100, 0}, new int[]{101, 0},
new int[]{102, 1}, new int[]{103, 2}, new int[]{104, 0}, new int[]{105, 0});
break;
}
}
public void testFullSizeSpans() throws Throwable {
Config config = new Config().spanCount(5).itemCount(30);
setupByConfig(config);
mAdapter.mFullSpanItems.add(3);
waitFirstLayout();
assertSpans("Testing full size span", new int[]{0, 0}, new int[]{1, 1}, new int[]{2, 2},
new int[]{3, 0}, new int[]{4, 0}, new int[]{5, 1}, new int[]{6, 2},
new int[]{7, 3}, new int[]{8, 4});
}
void assertSpans(String msg, int[]... childSpanTuples) {
for (int i = 0; i < childSpanTuples.length; i++) {
assertSpan(msg, childSpanTuples[i][0], childSpanTuples[i][1]);
}
}
void assertSpan(String msg, int childPosition, int expectedSpan) {
View view = mLayoutManager.findViewByPosition(childPosition);
assertNotNull(msg + "view at position " + childPosition + " should exists", view);
assertEquals(msg + "[child:" + childPosition + "]", expectedSpan,
getLp(view).mSpan.mIndex);
}
public void gapInTheMiddle(Config config) throws Throwable {
}
public void testGapAtTheBeginning() throws Throwable {
for (Config config : mBaseVariations) {
for (int deleteCount = 1; deleteCount < config.mSpanCount * 2; deleteCount++) {
for (int deletePosition = config.mSpanCount - 1;
deletePosition < config.mSpanCount + 2; deletePosition++) {
gapAtTheBeginningOfTheListTest(config, deletePosition, deleteCount);
removeRecyclerView();
}
}
}
}
public void gapAtTheBeginningOfTheListTest(final Config config, int deletePosition,
int deleteCount) throws Throwable {
if (config.mSpanCount < 2 || config.mGapStrategy == GAP_HANDLING_NONE) {
return;
}
if (config.mItemCount < 100) {
config.itemCount(100);
}
final String logPrefix = config + ", deletePos:" + deletePosition + ", deleteCount:"
+ deleteCount;
setupByConfig(config);
final RecyclerView.Adapter adapter = mAdapter;
waitFirstLayout();
// scroll far away
smoothScrollToPosition(config.mItemCount / 2);
// assert to be deleted child is not visible
assertNull(logPrefix + " test sanity, to be deleted child should be invisible",
mRecyclerView.findViewHolderForLayoutPosition(deletePosition));
// delete the child and notify
mAdapter.deleteAndNotify(deletePosition, deleteCount);
getInstrumentation().waitForIdleSync();
mLayoutManager.expectLayouts(1);
smoothScrollToPosition(0);
mLayoutManager.waitForLayout(2);
// due to data changes, first item may become visible before others which will cause
// smooth scrolling to stop. Triggering it twice more is a naive hack.
// Until we have time to consider it as a bug, this is the only workaround.
smoothScrollToPosition(0);
Thread.sleep(300);
smoothScrollToPosition(0);
Thread.sleep(500);
// some animations should happen and we should recover layout
final Map<Item, Rect> actualCoords = mLayoutManager.collectChildCoordinates();
// now layout another RV with same adapter
removeRecyclerView();
setupByConfig(config);
mRecyclerView.setAdapter(adapter);// use same adapter so that items can be matched
waitFirstLayout();
final Map<Item, Rect> desiredCoords = mLayoutManager.collectChildCoordinates();
assertRectSetsEqual(logPrefix + " when an item from the start of the list is deleted, "
+ "layout should recover the state once scrolling is stopped",
desiredCoords, actualCoords);
}
public void testPartialSpanInvalidation() throws Throwable {
Config config = new Config().spanCount(5).itemCount(100);
setupByConfig(config);
for (int i = 20; i < mAdapter.getItemCount(); i += 20) {
mAdapter.mFullSpanItems.add(i);
}
waitFirstLayout();
smoothScrollToPosition(50);
int prevSpanId = mLayoutManager.mLazySpanLookup.mData[30];
mAdapter.changeAndNotify(15, 2);
Thread.sleep(200);
assertEquals("Invalidation should happen within full span item boundaries", prevSpanId,
mLayoutManager.mLazySpanLookup.mData[30]);
assertEquals("item in invalidated range should have clear span id",
LayoutParams.INVALID_SPAN_ID, mLayoutManager.mLazySpanLookup.mData[16]);
smoothScrollToPosition(85);
int[] prevSpans = copyOfRange(mLayoutManager.mLazySpanLookup.mData, 62, 85);
mAdapter.deleteAndNotify(55, 2);
Thread.sleep(200);
assertEquals("item in invalidated range should have clear span id",
LayoutParams.INVALID_SPAN_ID, mLayoutManager.mLazySpanLookup.mData[16]);
int[] newSpans = copyOfRange(mLayoutManager.mLazySpanLookup.mData, 60, 83);
assertSpanAssignmentEquality("valid spans should be shifted for deleted item", prevSpans,
newSpans, 0, 0, newSpans.length);
}
// Same as Arrays.copyOfRange but for API 7
private int[] copyOfRange(int[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0) {
throw new IllegalArgumentException(from + " > " + to);
}
int[] copy = new int[newLength];
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
return copy;
}
public void testSpanReassignmentsOnItemChange() throws Throwable {
Config config = new Config().spanCount(5);
setupByConfig(config);
waitFirstLayout();
smoothScrollToPosition(mAdapter.getItemCount() / 2);
final int changePosition = mAdapter.getItemCount() / 4;
mLayoutManager.expectLayouts(1);
mAdapter.changeAndNotify(changePosition, 1);
mLayoutManager.assertNoLayout("no layout should happen when an invisible child is updated",
1);
// delete an item before visible area
int deletedPosition = mLayoutManager.getPosition(mLayoutManager.getChildAt(0)) - 2;
Map<Item, Rect> before = mLayoutManager.collectChildCoordinates();
if (DEBUG) {
Log.d(TAG, "before:");
for (Map.Entry<Item, Rect> entry : before.entrySet()) {
Log.d(TAG, entry.getKey().mAdapterIndex + ":" + entry.getValue());
}
}
mLayoutManager.expectLayouts(1);
mAdapter.deleteAndNotify(deletedPosition, 1);
mLayoutManager.waitForLayout(2);
assertRectSetsEqual(config + " when an item towards the head of the list is deleted, it "
+ "should not affect the layout if it is not visible", before,
mLayoutManager.collectChildCoordinates()
);
deletedPosition = mLayoutManager.getPosition(mLayoutManager.getChildAt(2));
mLayoutManager.expectLayouts(1);
mAdapter.deleteAndNotify(deletedPosition, 1);
mLayoutManager.waitForLayout(2);
assertRectSetsNotEqual(config + " when a visible item is deleted, it should affect the "
+ "layout", before, mLayoutManager.collectChildCoordinates());
}
void assertSpanAssignmentEquality(String msg, int[] set1, int[] set2, int start, int end) {
for (int i = start; i < end; i++) {
assertEquals(msg + " ind:" + i, set1[i], set2[i]);
}
}
void assertSpanAssignmentEquality(String msg, int[] set1, int[] set2, int start1, int start2,
int length) {
for (int i = 0; i < length; i++) {
assertEquals(msg + " ind1:" + (start1 + i) + ", ind2:" + (start2 + i), set1[start1 + i],
set2[start2 + i]);
}
}
public void testViewSnapping() throws Throwable {
for (Config config : mBaseVariations) {
viewSnapTest(config.itemCount(config.mSpanCount + 1));
removeRecyclerView();
}
}
public void viewSnapTest(Config config) throws Throwable {
setupByConfig(config);
waitFirstLayout();
// run these tests twice. once initial layout, once after scroll
String logSuffix = "";
for (int i = 0; i < 2; i++) {
Map<Item, Rect> itemRectMap = mLayoutManager.collectChildCoordinates();
Rect recyclerViewBounds = getDecoratedRecyclerViewBounds();
Rect usedLayoutBounds = new Rect();
for (Rect rect : itemRectMap.values()) {
usedLayoutBounds.union(rect);
}
if (DEBUG) {
Log.d(TAG, "testing view snapping (" + logSuffix + ") for config " + config);
}
if (config.mOrientation == VERTICAL) {
assertEquals(config + " there should be no gap on left" + logSuffix,
usedLayoutBounds.left, recyclerViewBounds.left);
assertEquals(config + " there should be no gap on right" + logSuffix,
usedLayoutBounds.right, recyclerViewBounds.right);
if (config.mReverseLayout) {
assertEquals(config + " there should be no gap on bottom" + logSuffix,
usedLayoutBounds.bottom, recyclerViewBounds.bottom);
assertTrue(config + " there should be some gap on top" + logSuffix,
usedLayoutBounds.top > recyclerViewBounds.top);
} else {
assertEquals(config + " there should be no gap on top" + logSuffix,
usedLayoutBounds.top, recyclerViewBounds.top);
assertTrue(config + " there should be some gap at the bottom" + logSuffix,
usedLayoutBounds.bottom < recyclerViewBounds.bottom);
}
} else {
assertEquals(config + " there should be no gap on top" + logSuffix,
usedLayoutBounds.top, recyclerViewBounds.top);
assertEquals(config + " there should be no gap at the bottom" + logSuffix,
usedLayoutBounds.bottom, recyclerViewBounds.bottom);
if (config.mReverseLayout) {
assertEquals(config + " there should be no on right" + logSuffix,
usedLayoutBounds.right, recyclerViewBounds.right);
assertTrue(config + " there should be some gap on left" + logSuffix,
usedLayoutBounds.left > recyclerViewBounds.left);
} else {
assertEquals(config + " there should be no gap on left" + logSuffix,
usedLayoutBounds.left, recyclerViewBounds.left);
assertTrue(config + " there should be some gap on right" + logSuffix,
usedLayoutBounds.right < recyclerViewBounds.right);
}
}
final int scroll = config.mReverseLayout ? -500 : 500;
scrollBy(scroll);
logSuffix = " scrolled " + scroll;
}
}
public void testSpanCountChangeOnRestoreSavedState() throws Throwable {
Config config = new Config(HORIZONTAL, true, 5, GAP_HANDLING_NONE);
setupByConfig(config);
waitFirstLayout();
int beforeChildCount = mLayoutManager.getChildCount();
Parcelable savedState = mRecyclerView.onSaveInstanceState();
// we append a suffix to the parcelable to test out of bounds
String parcelSuffix = UUID.randomUUID().toString();
Parcel parcel = Parcel.obtain();
savedState.writeToParcel(parcel, 0);
parcel.writeString(parcelSuffix);
removeRecyclerView();
// reset for reading
parcel.setDataPosition(0);
// re-create
savedState = RecyclerView.SavedState.CREATOR.createFromParcel(parcel);
removeRecyclerView();
RecyclerView restored = new RecyclerView(getActivity());
mLayoutManager = new WrappedLayoutManager(config.mSpanCount, config.mOrientation);
mLayoutManager.setReverseLayout(config.mReverseLayout);
mLayoutManager.setGapStrategy(config.mGapStrategy);
restored.setLayoutManager(mLayoutManager);
// use the same adapter for Rect matching
restored.setAdapter(mAdapter);
restored.onRestoreInstanceState(savedState);
mLayoutManager.setSpanCount(1);
mLayoutManager.expectLayouts(1);
setRecyclerView(restored);
mLayoutManager.waitForLayout(2);
assertEquals("on saved state, reverse layout should be preserved",
config.mReverseLayout, mLayoutManager.getReverseLayout());
assertEquals("on saved state, orientation should be preserved",
config.mOrientation, mLayoutManager.getOrientation());
assertEquals("after setting new span count, layout manager should keep new value",
1, mLayoutManager.getSpanCount());
assertEquals("on saved state, gap strategy should be preserved",
config.mGapStrategy, mLayoutManager.getGapStrategy());
assertTrue("when span count is dramatically changed after restore, # of child views "
+ "should change", beforeChildCount > mLayoutManager.getChildCount());
// make sure LLM can layout all children. is some span info is leaked, this would crash
smoothScrollToPosition(mAdapter.getItemCount() - 1);
}
public void testSavedState() throws Throwable {
PostLayoutRunnable[] postLayoutOptions = new PostLayoutRunnable[]{
new PostLayoutRunnable() {
@Override
public void run() throws Throwable {
// do nothing
}
@Override
public String describe() {
return "doing nothing";
}
},
new PostLayoutRunnable() {
@Override
public void run() throws Throwable {
mLayoutManager.expectLayouts(1);
scrollToPosition(mAdapter.getItemCount() * 3 / 4);
mLayoutManager.waitForLayout(2);
}
@Override
public String describe() {
return "scroll to position " + (mAdapter == null ? "" :
mAdapter.getItemCount() * 3 / 4);
}
},
new PostLayoutRunnable() {
@Override
public void run() throws Throwable {
mLayoutManager.expectLayouts(1);
scrollToPositionWithOffset(mAdapter.getItemCount() / 3,
50);
mLayoutManager.waitForLayout(2);
}
@Override
public String describe() {
return "scroll to position " + (mAdapter == null ? "" :
mAdapter.getItemCount() / 3) + "with positive offset";
}
},
new PostLayoutRunnable() {
@Override
public void run() throws Throwable {
mLayoutManager.expectLayouts(1);
scrollToPositionWithOffset(mAdapter.getItemCount() * 2 / 3,
-50);
mLayoutManager.waitForLayout(2);
}
@Override
public String describe() {
return "scroll to position with negative offset";
}
}
};
boolean[] waitForLayoutOptions = new boolean[]{false, true};
List<Config> testVariations = new ArrayList<Config>();
testVariations.addAll(mBaseVariations);
for (Config config : mBaseVariations) {
if (config.mSpanCount < 2) {
continue;
}
final Config clone = (Config) config.clone();
clone.mItemCount = clone.mSpanCount - 1;
testVariations.add(clone);
}
for (Config config : testVariations) {
for (PostLayoutRunnable runnable : postLayoutOptions) {
for (boolean waitForLayout : waitForLayoutOptions) {
savedStateTest(config, waitForLayout, runnable);
removeRecyclerView();
}
}
}
}
private void saveRestore(final Config config) throws Throwable {
runTestOnUiThread(new Runnable() {
@Override
public void run() {
try {
Parcelable savedState = mRecyclerView.onSaveInstanceState();
// we append a suffix to the parcelable to test out of bounds
String parcelSuffix = UUID.randomUUID().toString();
Parcel parcel = Parcel.obtain();
savedState.writeToParcel(parcel, 0);
parcel.writeString(parcelSuffix);
removeRecyclerView();
// reset for reading
parcel.setDataPosition(0);
// re-create
savedState = RecyclerView.SavedState.CREATOR.createFromParcel(parcel);
RecyclerView restored = new RecyclerView(getActivity());
mLayoutManager = new WrappedLayoutManager(config.mSpanCount,
config.mOrientation);
mLayoutManager.setGapStrategy(config.mGapStrategy);
restored.setLayoutManager(mLayoutManager);
// use the same adapter for Rect matching
restored.setAdapter(mAdapter);
restored.onRestoreInstanceState(savedState);
if (Looper.myLooper() == Looper.getMainLooper()) {
mLayoutManager.expectLayouts(1);
setRecyclerView(restored);
} else {
mLayoutManager.expectLayouts(1);
setRecyclerView(restored);
mLayoutManager.waitForLayout(2);
}
} catch (Throwable t) {
postExceptionToInstrumentation(t);
}
}
});
checkForMainThreadException();
}
public void savedStateTest(Config config, boolean waitForLayout,
PostLayoutRunnable postLayoutOperations)
throws Throwable {
if (DEBUG) {
Log.d(TAG, "testing saved state with wait for layout = " + waitForLayout + " config "
+ config + " post layout action " + postLayoutOperations.describe());
}
setupByConfig(config);
waitFirstLayout();
if (waitForLayout) {
postLayoutOperations.run();
}
final int firstCompletelyVisiblePosition = mLayoutManager.findFirstVisibleItemPositionInt();
Map<Item, Rect> before = mLayoutManager.collectChildCoordinates();
Parcelable savedState = mRecyclerView.onSaveInstanceState();
// we append a suffix to the parcelable to test out of bounds
String parcelSuffix = UUID.randomUUID().toString();
Parcel parcel = Parcel.obtain();
savedState.writeToParcel(parcel, 0);
parcel.writeString(parcelSuffix);
removeRecyclerView();
// reset for reading
parcel.setDataPosition(0);
// re-create
savedState = RecyclerView.SavedState.CREATOR.createFromParcel(parcel);
removeRecyclerView();
RecyclerView restored = new RecyclerView(getActivity());
mLayoutManager = new WrappedLayoutManager(config.mSpanCount, config.mOrientation);
mLayoutManager.setGapStrategy(config.mGapStrategy);
restored.setLayoutManager(mLayoutManager);
// use the same adapter for Rect matching
restored.setAdapter(mAdapter);
restored.onRestoreInstanceState(savedState);
assertEquals("Parcel reading should not go out of bounds", parcelSuffix,
parcel.readString());
mLayoutManager.expectLayouts(1);
setRecyclerView(restored);
mLayoutManager.waitForLayout(2);
assertEquals(config + " on saved state, reverse layout should be preserved",
config.mReverseLayout, mLayoutManager.getReverseLayout());
assertEquals(config + " on saved state, orientation should be preserved",
config.mOrientation, mLayoutManager.getOrientation());
assertEquals(config + " on saved state, span count should be preserved",
config.mSpanCount, mLayoutManager.getSpanCount());
assertEquals(config + " on saved state, gap strategy should be preserved",
config.mGapStrategy, mLayoutManager.getGapStrategy());
assertEquals(config + " on saved state, first completely visible child position should"
+ " be preserved", firstCompletelyVisiblePosition,
mLayoutManager.findFirstVisibleItemPositionInt());
if (waitForLayout) {
assertRectSetsEqual(config + "\npost layout op:" + postLayoutOperations.describe()
+ ": on restore, previous view positions should be preserved",
before, mLayoutManager.collectChildCoordinates()
);
}
// TODO add tests for changing values after restore before layout
}
public void testScrollToPositionWithOffset() throws Throwable {
for (Config config : mBaseVariations) {
scrollToPositionWithOffsetTest(config);
removeRecyclerView();
}
}
public void scrollToPositionWithOffsetTest(Config config) throws Throwable {
setupByConfig(config);
waitFirstLayout();
OrientationHelper orientationHelper = OrientationHelper
.createOrientationHelper(mLayoutManager, config.mOrientation);
Rect layoutBounds = getDecoratedRecyclerViewBounds();
// try scrolling towards head, should not affect anything
Map<Item, Rect> before = mLayoutManager.collectChildCoordinates();
scrollToPositionWithOffset(0, 20);
assertRectSetsEqual(config + " trying to over scroll with offset should be no-op",
before, mLayoutManager.collectChildCoordinates());
// try offsetting some visible children
int testCount = 10;
while (testCount-- > 0) {
// get middle child
final View child = mLayoutManager.getChildAt(mLayoutManager.getChildCount() / 2);
final int position = mRecyclerView.getChildLayoutPosition(child);
final int startOffset = config.mReverseLayout ?
orientationHelper.getEndAfterPadding() - orientationHelper
.getDecoratedEnd(child)
: orientationHelper.getDecoratedStart(child) - orientationHelper
.getStartAfterPadding();
final int scrollOffset = startOffset / 2;
mLayoutManager.expectLayouts(1);
scrollToPositionWithOffset(position, scrollOffset);
mLayoutManager.waitForLayout(2);
final int finalOffset = config.mReverseLayout ?
orientationHelper.getEndAfterPadding() - orientationHelper
.getDecoratedEnd(child)
: orientationHelper.getDecoratedStart(child) - orientationHelper
.getStartAfterPadding();
assertEquals(config + " scroll with offset on a visible child should work fine",
scrollOffset, finalOffset);
}
// try scrolling to invisible children
testCount = 10;
// we test above and below, one by one
int offsetMultiplier = -1;
while (testCount-- > 0) {
final TargetTuple target = findInvisibleTarget(config);
mLayoutManager.expectLayouts(1);
final int offset = offsetMultiplier
* orientationHelper.getDecoratedMeasurement(mLayoutManager.getChildAt(0)) / 3;
scrollToPositionWithOffset(target.mPosition, offset);
mLayoutManager.waitForLayout(2);
final View child = mLayoutManager.findViewByPosition(target.mPosition);
assertNotNull(config + " scrolling to a mPosition with offset " + offset
+ " should layout it", child);
final Rect bounds = mLayoutManager.getViewBounds(child);
if (DEBUG) {
Log.d(TAG, config + " post scroll to invisible mPosition " + bounds + " in "
+ layoutBounds + " with offset " + offset);
}
if (config.mReverseLayout) {
assertEquals(config + " when scrolling with offset to an invisible in reverse "
+ "layout, its end should align with recycler view's end - offset",
orientationHelper.getEndAfterPadding() - offset,
orientationHelper.getDecoratedEnd(child)
);
} else {
assertEquals(config + " when scrolling with offset to an invisible child in normal"
+ " layout its start should align with recycler view's start + "
+ "offset",
orientationHelper.getStartAfterPadding() + offset,
orientationHelper.getDecoratedStart(child)
);
}
offsetMultiplier *= -1;
}
}
public void testScrollToPosition() throws Throwable {
for (Config config : mBaseVariations) {
scrollToPositionTest(config);
removeRecyclerView();
}
}
private TargetTuple findInvisibleTarget(Config config) {
int minPosition = Integer.MAX_VALUE, maxPosition = Integer.MIN_VALUE;
for (int i = 0; i < mLayoutManager.getChildCount(); i++) {
View child = mLayoutManager.getChildAt(i);
int position = mRecyclerView.getChildLayoutPosition(child);
if (position < minPosition) {
minPosition = position;
}
if (position > maxPosition) {
maxPosition = position;
}
}
final int tailTarget = maxPosition + (mAdapter.getItemCount() - maxPosition) / 2;
final int headTarget = minPosition / 2;
final int target;
// where will the child come from ?
final int itemLayoutDirection;
if (Math.abs(tailTarget - maxPosition) > Math.abs(headTarget - minPosition)) {
target = tailTarget;
itemLayoutDirection = config.mReverseLayout ? LAYOUT_START : LAYOUT_END;
} else {
target = headTarget;
itemLayoutDirection = config.mReverseLayout ? LAYOUT_END : LAYOUT_START;
}
if (DEBUG) {
Log.d(TAG,
config + " target:" + target + " min:" + minPosition + ", max:" + maxPosition);
}
return new TargetTuple(target, itemLayoutDirection);
}
public void scrollToPositionTest(Config config) throws Throwable {
setupByConfig(config);
waitFirstLayout();
OrientationHelper orientationHelper = OrientationHelper
.createOrientationHelper(mLayoutManager, config.mOrientation);
Rect layoutBounds = getDecoratedRecyclerViewBounds();
for (int i = 0; i < mLayoutManager.getChildCount(); i++) {
View view = mLayoutManager.getChildAt(i);
Rect bounds = mLayoutManager.getViewBounds(view);
if (layoutBounds.contains(bounds)) {
Map<Item, Rect> initialBounds = mLayoutManager.collectChildCoordinates();
final int position = mRecyclerView.getChildLayoutPosition(view);
LayoutParams layoutParams
= (LayoutParams) (view.getLayoutParams());
TestViewHolder vh = (TestViewHolder) layoutParams.mViewHolder;
assertEquals("recycler view mPosition should match adapter mPosition", position,
vh.mBoundItem.mAdapterIndex);
if (DEBUG) {
Log.d(TAG, "testing scroll to visible mPosition at " + position
+ " " + bounds + " inside " + layoutBounds);
}
mLayoutManager.expectLayouts(1);
scrollToPosition(position);
mLayoutManager.waitForLayout(2);
if (DEBUG) {
view = mLayoutManager.findViewByPosition(position);
Rect newBounds = mLayoutManager.getViewBounds(view);
Log.d(TAG, "after scrolling to visible mPosition " +
bounds + " equals " + newBounds);
}
assertRectSetsEqual(
config + "scroll to mPosition on fully visible child should be no-op",
initialBounds, mLayoutManager.collectChildCoordinates());
} else {
final int position = mRecyclerView.getChildLayoutPosition(view);
if (DEBUG) {
Log.d(TAG,
"child(" + position + ") not fully visible " + bounds + " not inside "
+ layoutBounds
+ mRecyclerView.getChildLayoutPosition(view)
);
}
mLayoutManager.expectLayouts(1);
runTestOnUiThread(new Runnable() {
@Override
public void run() {
mLayoutManager.scrollToPosition(position);
}
});
mLayoutManager.waitForLayout(2);
view = mLayoutManager.findViewByPosition(position);
bounds = mLayoutManager.getViewBounds(view);
if (DEBUG) {
Log.d(TAG, "after scroll to partially visible child " + bounds + " in "
+ layoutBounds);
}
assertTrue(config
+ " after scrolling to a partially visible child, it should become fully "
+ " visible. " + bounds + " not inside " + layoutBounds,
layoutBounds.contains(bounds)
);
assertTrue(config + " when scrolling to a partially visible item, one of its edges "
+ "should be on the boundaries", orientationHelper.getStartAfterPadding() ==
orientationHelper.getDecoratedStart(view)
|| orientationHelper.getEndAfterPadding() ==
orientationHelper.getDecoratedEnd(view));
}
}
// try scrolling to invisible children
int testCount = 10;
while (testCount-- > 0) {
final TargetTuple target = findInvisibleTarget(config);
mLayoutManager.expectLayouts(1);
scrollToPosition(target.mPosition);
mLayoutManager.waitForLayout(2);
final View child = mLayoutManager.findViewByPosition(target.mPosition);
assertNotNull(config + " scrolling to a mPosition should lay it out", child);
final Rect bounds = mLayoutManager.getViewBounds(child);
if (DEBUG) {
Log.d(TAG, config + " post scroll to invisible mPosition " + bounds + " in "
+ layoutBounds);
}
assertTrue(config + " scrolling to a mPosition should make it fully visible",
layoutBounds.contains(bounds));
if (target.mLayoutDirection == LAYOUT_START) {
assertEquals(
config + " when scrolling to an invisible child above, its start should"
+ " align with recycler view's start",
orientationHelper.getStartAfterPadding(),
orientationHelper.getDecoratedStart(child)
);
} else {
assertEquals(config + " when scrolling to an invisible child below, its end "
+ "should align with recycler view's end",
orientationHelper.getEndAfterPadding(),
orientationHelper.getDecoratedEnd(child)
);
}
}
}
private void scrollToPositionWithOffset(final int position, final int offset) throws Throwable {
runTestOnUiThread(new Runnable() {
@Override
public void run() {
mLayoutManager.scrollToPositionWithOffset(position, offset);
}
});
}
public void testLayoutOrder() throws Throwable {
for (Config config : mBaseVariations) {
layoutOrderTest(config);
removeRecyclerView();
}
}
public void layoutOrderTest(Config config) throws Throwable {
setupByConfig(config);
assertViewPositions(config);
}
void assertViewPositions(Config config) {
ArrayList<ArrayList<View>> viewsBySpan = mLayoutManager.collectChildrenBySpan();
OrientationHelper orientationHelper = OrientationHelper
.createOrientationHelper(mLayoutManager, config.mOrientation);
for (ArrayList<View> span : viewsBySpan) {
// validate all children's order. first child should have min start mPosition
final int count = span.size();
for (int i = 0, j = 1; j < count; i++, j++) {
View prev = span.get(i);
View next = span.get(j);
assertTrue(config + " prev item should be above next item",
orientationHelper.getDecoratedEnd(prev) <= orientationHelper
.getDecoratedStart(next)
);
}
}
}
public void testScrollBy() throws Throwable {
for (Config config : mBaseVariations) {
scrollByTest(config);
removeRecyclerView();
}
}
void waitFirstLayout() throws Throwable {
mLayoutManager.expectLayouts(1);
setRecyclerView(mRecyclerView);
mLayoutManager.waitForLayout(2);
getInstrumentation().waitForIdleSync();
}
public void scrollByTest(Config config) throws Throwable {
setupByConfig(config);
waitFirstLayout();
// try invalid scroll. should not happen
final View first = mLayoutManager.getChildAt(0);
OrientationHelper primaryOrientation = OrientationHelper
.createOrientationHelper(mLayoutManager, config.mOrientation);
int scrollDist;
if (config.mReverseLayout) {
scrollDist = primaryOrientation.getDecoratedMeasurement(first) / 2;
} else {
scrollDist = -primaryOrientation.getDecoratedMeasurement(first) / 2;
}
Map<Item, Rect> before = mLayoutManager.collectChildCoordinates();
scrollBy(scrollDist);
Map<Item, Rect> after = mLayoutManager.collectChildCoordinates();
assertRectSetsEqual(
config + " if there are no more items, scroll should not happen (dt:" + scrollDist
+ ")",
before, after
);
scrollDist = -scrollDist * 3;
before = mLayoutManager.collectChildCoordinates();
scrollBy(scrollDist);
after = mLayoutManager.collectChildCoordinates();
int layoutStart = primaryOrientation.getStartAfterPadding();
int layoutEnd = primaryOrientation.getEndAfterPadding();
for (Map.Entry<Item, Rect> entry : before.entrySet()) {
Rect afterRect = after.get(entry.getKey());
// offset rect
if (config.mOrientation == VERTICAL) {
entry.getValue().offset(0, -scrollDist);
} else {
entry.getValue().offset(-scrollDist, 0);
}
if (afterRect == null || afterRect.isEmpty()) {
// assert item is out of bounds
int start, end;
if (config.mOrientation == VERTICAL) {
start = entry.getValue().top;
end = entry.getValue().bottom;
} else {
start = entry.getValue().left;
end = entry.getValue().right;
}
assertTrue(
config + " if item is missing after relayout, it should be out of bounds."
+ "item start: " + start + ", end:" + end + " layout start:"
+ layoutStart +
", layout end:" + layoutEnd,
start <= layoutStart && end <= layoutEnd ||
start >= layoutEnd && end >= layoutEnd
);
} else {
assertEquals(config + " Item should be laid out at the scroll offset coordinates",
entry.getValue(),
afterRect);
}
}
assertViewPositions(config);
}
public void testAccessibilityPositions() throws Throwable {
setupByConfig(new Config(VERTICAL, false, 3, GAP_HANDLING_NONE));
waitFirstLayout();
final AccessibilityDelegateCompat delegateCompat = mRecyclerView
.getCompatAccessibilityDelegate();
final AccessibilityEvent event = AccessibilityEvent.obtain();
runTestOnUiThread(new Runnable() {
@Override
public void run() {
delegateCompat.onInitializeAccessibilityEvent(mRecyclerView, event);
}
});
final AccessibilityRecordCompat record = AccessibilityEventCompat
.asRecord(event);
final int start = mRecyclerView
.getChildLayoutPosition(
mLayoutManager.findFirstVisibleItemClosestToStart(false, true));
final int end = mRecyclerView
.getChildLayoutPosition(
mLayoutManager.findFirstVisibleItemClosestToEnd(false, true));
assertEquals("first item position should match",
Math.min(start, end), record.getFromIndex());
assertEquals("last item position should match",
Math.max(start, end), record.getToIndex());
}
public void testConsistentRelayout() throws Throwable {
for (Config config : mBaseVariations) {
for (boolean firstChildMultiSpan : new boolean[]{false, true}) {
consistentRelayoutTest(config, firstChildMultiSpan);
}
removeRecyclerView();
}
}
public void consistentRelayoutTest(Config config, boolean firstChildMultiSpan)
throws Throwable {
setupByConfig(config);
if (firstChildMultiSpan) {
mAdapter.mFullSpanItems.add(0);
}
waitFirstLayout();
// record all child positions
Map<Item, Rect> before = mLayoutManager.collectChildCoordinates();
requestLayoutOnUIThread(mRecyclerView);
Map<Item, Rect> after = mLayoutManager.collectChildCoordinates();
assertRectSetsEqual(
config + " simple re-layout, firstChildMultiSpan:" + firstChildMultiSpan, before,
after);
// scroll some to create inconsistency
View firstChild = mLayoutManager.getChildAt(0);
final int firstChildStartBeforeScroll = mLayoutManager.mPrimaryOrientation
.getDecoratedStart(firstChild);
int distance = mLayoutManager.mPrimaryOrientation.getDecoratedMeasurement(firstChild) / 2;
if (config.mReverseLayout) {
distance *= -1;
}
scrollBy(distance);
waitForMainThread(2);
assertTrue("scroll by should move children", firstChildStartBeforeScroll !=
mLayoutManager.mPrimaryOrientation.getDecoratedStart(firstChild));
before = mLayoutManager.collectChildCoordinates();
mLayoutManager.expectLayouts(1);
requestLayoutOnUIThread(mRecyclerView);
mLayoutManager.waitForLayout(2);
after = mLayoutManager.collectChildCoordinates();
assertRectSetsEqual(config + " simple re-layout after scroll", before, after);
}
/**
* enqueues an empty runnable to main thread so that we can be assured it did run
*
* @param count Number of times to run
*/
private void waitForMainThread(int count) throws Throwable {
final AtomicInteger i = new AtomicInteger(count);
while (i.get() > 0) {
runTestOnUiThread(new Runnable() {
@Override
public void run() {
i.decrementAndGet();
}
});
}
}
public void assertRectSetsNotEqual(String message, Map<Item, Rect> before,
Map<Item, Rect> after) {
Throwable throwable = null;
try {
assertRectSetsEqual("NOT " + message, before, after);
} catch (Throwable t) {
throwable = t;
}
assertNotNull(message + " two layout should be different", throwable);
}
public void assertRectSetsEqual(String message, Map<Item, Rect> before, Map<Item, Rect> after) {
StringBuilder log = new StringBuilder();
if (DEBUG) {
log.append("checking rectangle equality.\n");
log.append("before:");
for (Map.Entry<Item, Rect> entry : before.entrySet()) {
log.append("\n").append(entry.getKey().mAdapterIndex).append(":")
.append(entry.getValue());
}
log.append("\nafter:");
for (Map.Entry<Item, Rect> entry : after.entrySet()) {
log.append("\n").append(entry.getKey().mAdapterIndex).append(":")
.append(entry.getValue());
}
message += "\n\n" + log.toString();
}
assertEquals(message + ": item counts should be equal", before.size()
, after.size());
for (Map.Entry<Item, Rect> entry : before.entrySet()) {
Rect afterRect = after.get(entry.getKey());
assertNotNull(message + ": Same item should be visible after simple re-layout",
afterRect);
assertEquals(message + ": Item should be laid out at the same coordinates",
entry.getValue(),
afterRect);
}
}
// test layout params assignment
static class OnLayoutListener {
void before(RecyclerView.Recycler recycler, RecyclerView.State state) {
}
void after(RecyclerView.Recycler recycler, RecyclerView.State state) {
}
}
class WrappedLayoutManager extends StaggeredGridLayoutManager {
CountDownLatch layoutLatch;
OnLayoutListener mOnLayoutListener;
// gradle does not yet let us customize manifest for tests which is necessary to test RTL.
// until bug is fixed, we'll fake it.
// public issue id: 57819
Boolean mFakeRTL;
@Override
boolean isLayoutRTL() {
return mFakeRTL == null ? super.isLayoutRTL() : mFakeRTL;
}
public void expectLayouts(int count) {
layoutLatch = new CountDownLatch(count);
}
public void waitForLayout(long timeout) throws InterruptedException {
waitForLayout(timeout * (DEBUG ? 1000 : 1), TimeUnit.SECONDS);
}
public void waitForLayout(long timeout, TimeUnit timeUnit) throws InterruptedException {
layoutLatch.await(timeout, timeUnit);
assertEquals("all expected layouts should be executed at the expected time",
0, layoutLatch.getCount());
}
public void assertNoLayout(String msg, long timeout) throws Throwable {
layoutLatch.await(timeout, TimeUnit.SECONDS);
assertFalse(msg, layoutLatch.getCount() == 0);
}
@Override
public void onLayoutChildren(RecyclerView.Recycler recycler, RecyclerView.State state) {
try {
if (mOnLayoutListener != null) {
mOnLayoutListener.before(recycler, state);
}
super.onLayoutChildren(recycler, state);
if (mOnLayoutListener != null) {
mOnLayoutListener.after(recycler, state);
}
} catch (Throwable t) {
postExceptionToInstrumentation(t);
}
layoutLatch.countDown();
}
public WrappedLayoutManager(int spanCount, int orientation) {
super(spanCount, orientation);
}
ArrayList<ArrayList<View>> collectChildrenBySpan() {
ArrayList<ArrayList<View>> viewsBySpan = new ArrayList<ArrayList<View>>();
for (int i = 0; i < getSpanCount(); i++) {
viewsBySpan.add(new ArrayList<View>());
}
for (int i = 0; i < getChildCount(); i++) {
View view = getChildAt(i);
LayoutParams lp
= (LayoutParams) view
.getLayoutParams();
viewsBySpan.get(lp.mSpan.mIndex).add(view);
}
return viewsBySpan;
}
Rect getViewBounds(View view) {
if (getOrientation() == HORIZONTAL) {
return new Rect(
mPrimaryOrientation.getDecoratedStart(view),
mSecondaryOrientation.getDecoratedStart(view),
mPrimaryOrientation.getDecoratedEnd(view),
mSecondaryOrientation.getDecoratedEnd(view));
} else {
return new Rect(
mSecondaryOrientation.getDecoratedStart(view),
mPrimaryOrientation.getDecoratedStart(view),
mSecondaryOrientation.getDecoratedEnd(view),
mPrimaryOrientation.getDecoratedEnd(view));
}
}
public String getBoundsLog() {
StringBuilder sb = new StringBuilder();
sb.append("view bounds:[start:").append(mPrimaryOrientation.getStartAfterPadding())
.append(",").append(" end").append(mPrimaryOrientation.getEndAfterPadding());
sb.append("\nchildren bounds\n");
final int childCount = getChildCount();
for (int i = 0; i < childCount; i++) {
View child = getChildAt(i);
sb.append("child (ind:").append(i).append(", pos:").append(getPosition(child))
.append("[").append("start:").append(
mPrimaryOrientation.getDecoratedStart(child)).append(", end:")
.append(mPrimaryOrientation.getDecoratedEnd(child)).append("]\n");
}
return sb.toString();
}
public VisibleChildren traverseAndFindVisibleChildren() {
int childCount = getChildCount();
final VisibleChildren visibleChildren = new VisibleChildren(getSpanCount());
final int start = mPrimaryOrientation.getStartAfterPadding();
final int end = mPrimaryOrientation.getEndAfterPadding();
for (int i = 0; i < childCount; i++) {
View child = getChildAt(i);
final int childStart = mPrimaryOrientation.getDecoratedStart(child);
final int childEnd = mPrimaryOrientation.getDecoratedEnd(child);
final boolean fullyVisible = childStart >= start && childEnd <= end;
final boolean hidden = childEnd <= start || childStart >= end;
if (hidden) {
continue;
}
final int position = getPosition(child);
final int span = getLp(child).getSpanIndex();
if (fullyVisible) {
if (position < visibleChildren.firstFullyVisiblePositions[span] ||
visibleChildren.firstFullyVisiblePositions[span]
== RecyclerView.NO_POSITION) {
visibleChildren.firstFullyVisiblePositions[span] = position;
}
if (position > visibleChildren.lastFullyVisiblePositions[span]) {
visibleChildren.lastFullyVisiblePositions[span] = position;
}
}
if (position < visibleChildren.firstVisiblePositions[span] ||
visibleChildren.firstVisiblePositions[span] == RecyclerView.NO_POSITION) {
visibleChildren.firstVisiblePositions[span] = position;
}
if (position > visibleChildren.lastVisiblePositions[span]) {
visibleChildren.lastVisiblePositions[span] = position;
}
}
return visibleChildren;
}
Map<Item, Rect> collectChildCoordinates() throws Throwable {
final Map<Item, Rect> items = new LinkedHashMap<Item, Rect>();
runTestOnUiThread(new Runnable() {
@Override
public void run() {
final int childCount = getChildCount();
for (int i = 0; i < childCount; i++) {
View child = getChildAt(i);
// do it if and only if child is visible
if (child.getRight() < 0 || child.getBottom() < 0 ||
child.getLeft() >= getWidth() || child.getTop() >= getHeight()) {
// invisible children may be drawn in cases like scrolling so we should
// ignore them
continue;
}
LayoutParams lp = (LayoutParams) child
.getLayoutParams();
TestViewHolder vh = (TestViewHolder) lp.mViewHolder;
items.put(vh.mBoundItem, getViewBounds(child));
}
}
});
return items;
}
public void setFakeRtl(Boolean fakeRtl) {
mFakeRTL = fakeRtl;
try {
requestLayoutOnUIThread(mRecyclerView);
} catch (Throwable throwable) {
postExceptionToInstrumentation(throwable);
}
}
}
static class VisibleChildren {
int[] firstVisiblePositions;
int[] firstFullyVisiblePositions;
int[] lastVisiblePositions;
int[] lastFullyVisiblePositions;
VisibleChildren(int spanCount) {
firstFullyVisiblePositions = new int[spanCount];
firstVisiblePositions = new int[spanCount];
lastVisiblePositions = new int[spanCount];
lastFullyVisiblePositions = new int[spanCount];
for (int i = 0; i < spanCount; i++) {
firstFullyVisiblePositions[i] = RecyclerView.NO_POSITION;
firstVisiblePositions[i] = RecyclerView.NO_POSITION;
lastVisiblePositions[i] = RecyclerView.NO_POSITION;
lastFullyVisiblePositions[i] = RecyclerView.NO_POSITION;
}
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
VisibleChildren that = (VisibleChildren) o;
if (!Arrays.equals(firstFullyVisiblePositions, that.firstFullyVisiblePositions)) {
return false;
}
if (!Arrays.equals(firstVisiblePositions, that.firstVisiblePositions)) {
return false;
}
if (!Arrays.equals(lastFullyVisiblePositions, that.lastFullyVisiblePositions)) {
return false;
}
if (!Arrays.equals(lastVisiblePositions, that.lastVisiblePositions)) {
return false;
}
return true;
}
@Override
public int hashCode() {
int result = firstVisiblePositions != null ? Arrays.hashCode(firstVisiblePositions) : 0;
result = 31 * result + (firstFullyVisiblePositions != null ? Arrays
.hashCode(firstFullyVisiblePositions) : 0);
result = 31 * result + (lastVisiblePositions != null ? Arrays
.hashCode(lastVisiblePositions)
: 0);
result = 31 * result + (lastFullyVisiblePositions != null ? Arrays
.hashCode(lastFullyVisiblePositions) : 0);
return result;
}
@Override
public String toString() {
return "VisibleChildren{" +
"firstVisiblePositions=" + Arrays.toString(firstVisiblePositions) +
", firstFullyVisiblePositions=" + Arrays.toString(firstFullyVisiblePositions) +
", lastVisiblePositions=" + Arrays.toString(lastVisiblePositions) +
", lastFullyVisiblePositions=" + Arrays.toString(lastFullyVisiblePositions) +
'}';
}
}
class GridTestAdapter extends TestAdapter {
int mOrientation;
// original ids of items that should be full span
HashSet<Integer> mFullSpanItems = new HashSet<Integer>();
private boolean mViewsHaveEqualSize = false; // size in the scrollable direction
private OnBindHandler mOnBindHandler;
GridTestAdapter(int count, int orientation) {
super(count);
mOrientation = orientation;
}
@Override
public void offsetOriginalIndices(int start, int offset) {
if (mFullSpanItems.size() > 0) {
HashSet<Integer> old = mFullSpanItems;
mFullSpanItems = new HashSet<Integer>();
for (Integer i : old) {
if (i < start) {
mFullSpanItems.add(i);
} else if (offset > 0 || (start + Math.abs(offset)) <= i) {
mFullSpanItems.add(i + offset);
} else if (DEBUG) {
Log.d(TAG, "removed full span item " + i);
}
}
}
super.offsetOriginalIndices(start, offset);
}
@Override
public void onBindViewHolder(TestViewHolder holder,
int position) {
super.onBindViewHolder(holder, position);
Item item = mItems.get(position);
RecyclerView.LayoutParams lp = (RecyclerView.LayoutParams) holder.itemView
.getLayoutParams();
if (lp instanceof LayoutParams) {
((LayoutParams) lp).setFullSpan(mFullSpanItems.contains(item.mAdapterIndex));
} else {
LayoutParams slp = new LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT,
ViewGroup.LayoutParams.WRAP_CONTENT);
holder.itemView.setLayoutParams(slp);
slp.setFullSpan(mFullSpanItems.contains(item.mAdapterIndex));
lp = slp;
}
if (mOnBindHandler == null || mOnBindHandler.assignRandomSize()) {
final int minSize = mViewsHaveEqualSize ? 200 : 200 + 20 * (position % 10);
if (mOrientation == OrientationHelper.HORIZONTAL) {
holder.itemView.setMinimumWidth(minSize);
} else {
holder.itemView.setMinimumHeight(minSize);
}
lp.topMargin = 3;
lp.leftMargin = 5;
lp.rightMargin = 7;
lp.bottomMargin = 9;
}
if (mOnBindHandler != null) {
mOnBindHandler.onBoundItem(holder, position);
}
}
}
abstract static class OnBindHandler {
abstract void onBoundItem(TestViewHolder vh, int position);
boolean assignRandomSize() {
return true;
}
}
static class Config implements Cloneable {
private static final int DEFAULT_ITEM_COUNT = 300;
int mOrientation = OrientationHelper.VERTICAL;
boolean mReverseLayout = false;
int mSpanCount = 3;
int mGapStrategy = GAP_HANDLING_MOVE_ITEMS_BETWEEN_SPANS;
int mItemCount = DEFAULT_ITEM_COUNT;
Config(int orientation, boolean reverseLayout, int spanCount, int gapStrategy) {
mOrientation = orientation;
mReverseLayout = reverseLayout;
mSpanCount = spanCount;
mGapStrategy = gapStrategy;
}
public Config() {
}
Config orientation(int orientation) {
mOrientation = orientation;
return this;
}
Config reverseLayout(boolean reverseLayout) {
mReverseLayout = reverseLayout;
return this;
}
Config spanCount(int spanCount) {
mSpanCount = spanCount;
return this;
}
Config gapStrategy(int gapStrategy) {
mGapStrategy = gapStrategy;
return this;
}
public Config itemCount(int itemCount) {
mItemCount = itemCount;
return this;
}
@Override
public String toString() {
return "[CONFIG:" +
" span:" + mSpanCount + "," +
" orientation:" + (mOrientation == HORIZONTAL ? "horz," : "vert,") +
" reverse:" + (mReverseLayout ? "T" : "F") +
" itemCount:" + mItemCount +
" gap strategy: " + gapStrategyName(mGapStrategy);
}
private static String gapStrategyName(int gapStrategy) {
switch (gapStrategy) {
case GAP_HANDLING_NONE:
return "none";
case GAP_HANDLING_MOVE_ITEMS_BETWEEN_SPANS:
return "move spans";
}
return "gap strategy: unknown";
}
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
private interface PostLayoutRunnable {
void run() throws Throwable;
String describe();
}
}
|
