/* * 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 junit.framework.AssertionFailedError; import junit.framework.TestResult; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; import android.test.AndroidTestCase; import android.util.Log; import android.view.View; import android.widget.TextView; import java.util.ArrayList; import java.util.LinkedList; import java.util.List; import java.util.Queue; import java.util.Random; import java.util.concurrent.atomic.AtomicInteger; import static android.support.v7.widget.RecyclerView.*; @RunWith(JUnit4.class) public class AdapterHelperTest extends AndroidTestCase { private static final boolean DEBUG = false; private boolean mCollectLogs = false; private static final String TAG = "AHT"; List<MockViewHolder> mViewHolders; AdapterHelper mAdapterHelper; List<AdapterHelper.UpdateOp> mFirstPassUpdates, mSecondPassUpdates; TestAdapter mTestAdapter; TestAdapter mPreProcessClone; // we clone adapter pre-process to run operations to see result private List<TestAdapter.Item> mPreLayoutItems; private StringBuilder mLog = new StringBuilder(); @Override public void run(TestResult result) { super.run(result); if (!result.wasSuccessful()) { result.addFailure(this, new AssertionFailedError(mLog.toString())); } } @Before public void cleanState() { mLog.setLength(0); mPreLayoutItems = new ArrayList<TestAdapter.Item>(); mViewHolders = new ArrayList<MockViewHolder>(); mFirstPassUpdates = new ArrayList<AdapterHelper.UpdateOp>(); mSecondPassUpdates = new ArrayList<AdapterHelper.UpdateOp>(); mPreProcessClone = null; mAdapterHelper = new AdapterHelper(new AdapterHelper.Callback() { @Override public RecyclerView.ViewHolder findViewHolder(int position) { for (ViewHolder vh : mViewHolders) { if (vh.mPosition == position && !vh.isRemoved()) { return vh; } } return null; } @Override public void offsetPositionsForRemovingInvisible(int positionStart, int itemCount) { final int positionEnd = positionStart + itemCount; for (ViewHolder holder : mViewHolders) { if (holder.mPosition >= positionEnd) { holder.offsetPosition(-itemCount, true); } else if (holder.mPosition >= positionStart) { holder.flagRemovedAndOffsetPosition(positionStart - 1, -itemCount, true); } } } @Override public void offsetPositionsForRemovingLaidOutOrNewView(int positionStart, int itemCount) { final int positionEnd = positionStart + itemCount; for (ViewHolder holder : mViewHolders) { if (holder.mPosition >= positionEnd) { holder.offsetPosition(-itemCount, false); } else if (holder.mPosition >= positionStart) { holder.flagRemovedAndOffsetPosition(positionStart - 1, -itemCount, false); } } } @Override public void markViewHoldersUpdated(int positionStart, int itemCount, Object payload) { final int positionEnd = positionStart + itemCount; for (ViewHolder holder : mViewHolders) { if (holder.mPosition >= positionStart && holder.mPosition < positionEnd) { holder.addFlags(ViewHolder.FLAG_UPDATE); holder.addChangePayload(payload); } } } @Override public void onDispatchFirstPass(AdapterHelper.UpdateOp updateOp) { if (DEBUG) { log("first pass:" + updateOp.toString()); } for (ViewHolder viewHolder : mViewHolders) { for (int i = 0; i < updateOp.itemCount; i++) { // events are dispatched before view holders are updated for consistency assertFalse("update op should not match any existing view holders", viewHolder.getLayoutPosition() == updateOp.positionStart + i); } } mFirstPassUpdates.add(updateOp); } @Override public void onDispatchSecondPass(AdapterHelper.UpdateOp updateOp) { if (DEBUG) { log("second pass:" + updateOp.toString()); } mSecondPassUpdates.add(updateOp); } @Override public void offsetPositionsForAdd(int positionStart, int itemCount) { for (ViewHolder holder : mViewHolders) { if (holder != null && holder.mPosition >= positionStart) { holder.offsetPosition(itemCount, false); } } } @Override public void offsetPositionsForMove(int from, int to) { final int start, end, inBetweenOffset; if (from < to) { start = from; end = to; inBetweenOffset = -1; } else { start = to; end = from; inBetweenOffset = 1; } for (ViewHolder holder : mViewHolders) { if (holder == null || holder.mPosition < start || holder.mPosition > end) { continue; } if (holder.mPosition == from) { holder.offsetPosition(to - from, false); } else { holder.offsetPosition(inBetweenOffset, false); } } } }, true); } void log(String msg) { if (mCollectLogs) { mLog.append(msg).append("\n"); } else { Log.d(TAG, msg); } } void setupBasic(int count, int visibleStart, int visibleCount) { if (DEBUG) { log("setupBasic(" + count + "," + visibleStart + "," + visibleCount + ");"); } mTestAdapter = new TestAdapter(count, mAdapterHelper); for (int i = 0; i < visibleCount; i++) { addViewHolder(visibleStart + i); } mPreProcessClone = mTestAdapter.createCopy(); } private void addViewHolder(int position) { MockViewHolder viewHolder = new MockViewHolder( new TextView(getContext())); viewHolder.mPosition = position; viewHolder.mItem = mTestAdapter.mItems.get(position); mViewHolders.add(viewHolder); } @Test public void testChangeAll() throws Exception { try { setupBasic(5, 0, 3); up(0, 5); mAdapterHelper.preProcess(); } catch (Throwable t) { throw new Exception(mLog.toString()); } } @Test public void testFindPositionOffsetInPreLayout() { setupBasic(50, 25, 10); rm(24, 5); mAdapterHelper.preProcess(); // since 25 is invisible, we offset by one while checking assertEquals("find position for view 23", 23, mAdapterHelper.findPositionOffset(23)); assertEquals("find position for view 24", -1, mAdapterHelper.findPositionOffset(24)); assertEquals("find position for view 25", -1, mAdapterHelper.findPositionOffset(25)); assertEquals("find position for view 26", -1, mAdapterHelper.findPositionOffset(26)); assertEquals("find position for view 27", -1, mAdapterHelper.findPositionOffset(27)); assertEquals("find position for view 28", 24, mAdapterHelper.findPositionOffset(28)); assertEquals("find position for view 29", 25, mAdapterHelper.findPositionOffset(29)); } @Test public void testSinglePass() { setupBasic(10, 2, 3); add(2, 1); rm(1, 2); add(1, 5); mAdapterHelper.consumeUpdatesInOnePass(); assertDispatch(0, 3); } @Test public void testDeleteVisible() { setupBasic(10, 2, 3); rm(2, 1); preProcess(); assertDispatch(0, 1); } @Test public void testDeleteInvisible() { setupBasic(10, 3, 4); rm(2, 1); preProcess(); assertDispatch(1, 0); } @Test public void testAddCount() { setupBasic(0, 0, 0); add(0, 1); assertEquals(1, mAdapterHelper.mPendingUpdates.size()); } @Test public void testDeleteCount() { setupBasic(1, 0, 0); rm(0, 1); assertEquals(1, mAdapterHelper.mPendingUpdates.size()); } @Test public void testAddProcess() { setupBasic(0, 0, 0); add(0, 1); preProcess(); assertEquals(0, mAdapterHelper.mPendingUpdates.size()); } @Test public void testAddRemoveSeparate() { setupBasic(10, 2, 2); add(6, 1); rm(5, 1); preProcess(); assertDispatch(1, 1); } @Test public void testScenario1() { setupBasic(10, 3, 2); rm(4, 1); rm(3, 1); rm(3, 1); preProcess(); assertDispatch(1, 2); } @Test public void testDivideDelete() { setupBasic(10, 3, 4); rm(2, 2); preProcess(); assertDispatch(1, 1); } @Test public void testScenario2() { setupBasic(10, 3, 3); // 3-4-5 add(4, 2); // 3 a b 4 5 rm(0, 1); // (0) 3(2) a(3) b(4) 4(3) 5(4) rm(1, 3); // (1,2) (x) a(1) b(2) 4(3) preProcess(); assertDispatch(2, 2); } @Test public void testScenario3() { setupBasic(10, 2, 2); rm(0, 5); preProcess(); assertDispatch(2, 1); assertOps(mFirstPassUpdates, rmOp(0, 2), rmOp(2, 1)); assertOps(mSecondPassUpdates, rmOp(0, 2)); } // TODO test MOVE then remove items in between. // TODO test MOVE then remove it, make sure it is not dispatched @Test public void testScenario4() { setupBasic(5, 0, 5); // 0 1 2 3 4 // 0 1 2 a b 3 4 // 0 2 a b 3 4 // 0 c d 2 a b 3 4 // 0 c d 2 a 4 // c d 2 a 4 // pre: 0 1 2 3 4 add(3, 2); rm(1, 1); add(1, 2); rm(5, 2); rm(0, 1); preProcess(); } @Test public void testScenario5() { setupBasic(5, 0, 5); // 0 1 2 3 4 // 0 1 2 a b 3 4 // 0 1 b 3 4 // pre: 0 1 2 3 4 // pre w/ adap: 0 1 2 b 3 4 add(3, 2); rm(2, 2); preProcess(); } @Test public void testScenario6() { // setupBasic(47, 19, 24); // mv(11, 12); // add(24, 16); // rm(9, 3); setupBasic(10, 5, 3); mv(2, 3); add(6, 4); rm(4, 1); preProcess(); } @Test public void testScenario8() { setupBasic(68, 51, 13); mv(22, 11); mv(22, 52); rm(37, 19); add(12, 38); preProcess(); } @Test public void testScenario9() { setupBasic(44, 3, 7); add(7, 21); rm(31, 3); rm(32, 11); mv(29, 5); mv(30, 32); add(25, 32); rm(15, 66); preProcess(); } @Test public void testScenario10() { setupBasic(14, 10, 3); rm(4, 4); add(5, 11); mv(5, 18); rm(2, 9); preProcess(); } @Test public void testScenario11() { setupBasic(78, 3, 64); mv(34, 28); add(1, 11); rm(9, 74); preProcess(); } @Test public void testScenario12() { setupBasic(38, 9, 7); rm(26, 3); mv(29, 15); rm(30, 1); preProcess(); } @Test public void testScenario13() { setupBasic(49, 41, 3); rm(30, 13); add(4, 10); mv(3, 38); mv(20, 17); rm(18, 23); preProcess(); } @Test public void testScenario14() { setupBasic(24, 3, 11); rm(2, 15); mv(2, 1); add(2, 34); add(11, 3); rm(10, 25); rm(13, 6); rm(4, 4); rm(6, 4); preProcess(); } @Test public void testScenario15() { setupBasic(10, 8, 1); mv(6, 1); mv(1, 4); rm(3, 1); preProcess(); } @Test public void testScenario16() { setupBasic(10, 3, 3); rm(2, 1); rm(1, 7); rm(0, 1); preProcess(); } @Test public void testScenario17() { setupBasic(10, 8, 1); mv(1, 0); mv(5, 1); rm(1, 7); preProcess(); } @Test public void testScenario18() throws InterruptedException { setupBasic(10, 1, 4); add(2, 11); rm(16, 1); add(3, 1); rm(9, 10); preProcess(); } @Test public void testScenario19() { setupBasic(10, 8, 1); mv(9, 7); mv(9, 3); rm(5, 4); preProcess(); } @Test public void testScenario20() { setupBasic(10, 7, 1); mv(9, 1); mv(3, 9); rm(7, 2); preProcess(); } @Test public void testScenario21() { setupBasic(10, 5, 2); mv(1, 0); mv(9, 1); rm(2, 3); preProcess(); } @Test public void testScenario22() { setupBasic(10, 7, 2); add(2, 16); mv(20, 9); rm(17, 6); preProcess(); } @Test public void testScenario23() { setupBasic(10, 5, 3); mv(9, 6); add(4, 15); rm(21, 3); preProcess(); } @Test public void testScenario24() { setupBasic(10, 1, 6); add(6, 5); mv(14, 6); rm(7, 6); preProcess(); } @Test public void testScenario25() { setupBasic(10, 3, 4); mv(3, 9); rm(5, 4); preProcess(); } @Test public void testScenario25a() { setupBasic(10, 3, 4); rm(6, 4); mv(3, 5); preProcess(); } @Test public void testScenario26() { setupBasic(10, 4, 4); rm(3, 5); mv(2, 0); mv(1, 0); rm(1, 1); mv(0, 2); preProcess(); } @Test public void testScenario27() { setupBasic(10, 0, 3); mv(9, 4); mv(8, 4); add(7, 6); rm(5, 5); preProcess(); } @Test public void testScenerio28() { setupBasic(10, 4, 1); mv(8, 6); rm(8, 1); mv(7, 5); rm(3, 3); rm(1, 4); preProcess(); } @Test public void testScenerio29() { setupBasic(10, 6, 3); mv(3, 6); up(6, 2); add(5, 5); } @Test public void testScenerio30() throws InterruptedException { mCollectLogs = true; setupBasic(10, 3, 1); rm(3, 2); rm(2, 5); preProcess(); } @Test public void testScenerio31() throws InterruptedException { mCollectLogs = true; setupBasic(10, 3, 1); rm(3, 1); rm(2, 3); preProcess(); } @Test public void testScenerio32() { setupBasic(10, 8, 1); add(9, 2); add(7, 39); up(0, 39); mv(36, 20); add(1, 48); mv(22, 98); mv(96, 29); up(36, 29); add(60, 36); add(127, 34); rm(142, 22); up(12, 69); up(116, 13); up(118, 19); mv(94, 69); up(98, 21); add(89, 18); rm(94, 70); up(71, 8); rm(54, 26); add(2, 20); mv(78, 84); mv(56, 2); mv(1, 79); rm(76, 7); rm(57, 12); rm(30, 27); add(24, 13); add(21, 5); rm(11, 27); rm(32, 1); up(0, 5); mv(14, 9); rm(15, 12); up(19, 1); rm(7, 1); mv(10, 4); up(4, 3); rm(16, 1); up(13, 5); up(2, 8); add(10, 19); add(15, 42); preProcess(); } @Test public void testScenerio33() throws Throwable { try { mCollectLogs = true; setupBasic(10, 7, 1); mv(0, 6); up(0, 7); preProcess(); } catch (Throwable t) { throw new Throwable(t.getMessage() + "\n" + mLog.toString()); } } @Test public void testScenerio34() { setupBasic(10, 6, 1); mv(9, 7); rm(5, 2); up(4, 3); preProcess(); } @Test public void testScenerio35() { setupBasic(10, 4, 4); mv(1, 4); up(2, 7); up(0, 1); preProcess(); } @Test public void testScenerio36() { setupBasic(10, 7, 2); rm(4, 1); mv(1, 6); up(4, 4); preProcess(); } @Test public void testScenerio37() throws Throwable { try { mCollectLogs = true; setupBasic(10, 5, 2); mv(3, 6); rm(4, 4); rm(3, 2); preProcess(); } catch (Throwable t) { throw new Throwable(t.getMessage() + "\n" + mLog.toString()); } } @Test public void testScenerio38() { setupBasic(10, 2, 2); add(0, 24); rm(26, 4); rm(1, 24); preProcess(); } @Test public void testScenerio39() { setupBasic(10, 7, 1); mv(0, 2); rm(8, 1); rm(2, 6); preProcess(); } @Test public void testScenerio40() { setupBasic(10, 5, 3); rm(5, 4); mv(0, 5); rm(2, 3); preProcess(); } @Test public void testScenerio41() { setupBasic(10, 7, 2); mv(4, 9); rm(0, 6); rm(0, 1); preProcess(); } @Test public void testScenerio42() { setupBasic(10, 6, 2); mv(5, 9); rm(5, 1); rm(2, 6); preProcess(); } @Test public void testScenerio43() { setupBasic(10, 1, 6); mv(6, 8); rm(3, 5); up(3, 1); preProcess(); } @Test public void testScenerio44() { setupBasic(10, 5, 2); mv(6, 4); mv(4, 1); rm(5, 3); preProcess(); } @Test public void testScenerio45() { setupBasic(10, 4, 2); rm(1, 4); preProcess(); } @Test public void testScenerio46() { setupBasic(10, 4, 3); up(6, 1); mv(8, 0); rm(2, 7); preProcess(); } @Test public void testMoveAdded() { setupBasic(10, 2, 2); add(3, 5); mv(4, 2); preProcess(); } @Test public void testPayloads() { setupBasic(10, 2, 2); up(3, 3, "payload"); preProcess(); assertOps(mFirstPassUpdates, upOp(4, 2, "payload")); assertOps(mSecondPassUpdates, upOp(3, 1, "payload")); } @Test public void testRandom() throws Throwable { mCollectLogs = true; Random random = new Random(System.nanoTime()); for (int i = 0; i < 100; i++) { try { Log.d(TAG, "running random test " + i); randomTest(random, Math.max(40, 10 + nextInt(random, i))); } catch (Throwable t) { throw new Throwable("failure at random test " + i + "\n" + t.getMessage() + "\n" + mLog.toString(), t); } } } public void randomTest(Random random, int opCount) { cleanState(); if (DEBUG) { log("randomTest"); } final int count = 10;// + nextInt(random,100); final int start = nextInt(random, count - 1); final int layoutCount = Math.max(1, nextInt(random, count - start)); setupBasic(count, start, layoutCount); while (opCount-- > 0) { final int op = nextInt(random, 5); switch (op) { case 0: if (mTestAdapter.mItems.size() > 1) { int s = nextInt(random, mTestAdapter.mItems.size() - 1); int len = Math.max(1, nextInt(random, mTestAdapter.mItems.size() - s)); rm(s, len); } break; case 1: int s = mTestAdapter.mItems.size() == 0 ? 0 : nextInt(random, mTestAdapter.mItems.size()); add(s, nextInt(random, 50)); break; case 2: if (mTestAdapter.mItems.size() >= 2) { int from = nextInt(random, mTestAdapter.mItems.size()); int to; do { to = nextInt(random, mTestAdapter.mItems.size()); } while (to == from); mv(from, to); } break; case 3: if (mTestAdapter.mItems.size() > 1) { s = nextInt(random, mTestAdapter.mItems.size() - 1); int len = Math.max(1, nextInt(random, mTestAdapter.mItems.size() - s)); up(s, len); } break; case 4: if (mTestAdapter.mItems.size() > 1) { s = nextInt(random, mTestAdapter.mItems.size() - 1); int len = Math.max(1, nextInt(random, mTestAdapter.mItems.size() - s)); up(s, len, Integer.toString(s)); } break; } } preProcess(); } int nextInt(Random random, int n) { if (n == 0) { return 0; } return random.nextInt(n); } public void assertOps(List<AdapterHelper.UpdateOp> actual, AdapterHelper.UpdateOp... expected) { assertEquals(expected.length, actual.size()); for (int i = 0; i < expected.length; i++) { assertEquals(expected[i], actual.get(i)); } } void assertDispatch(int firstPass, int secondPass) { assertEquals(firstPass, mFirstPassUpdates.size()); assertEquals(secondPass, mSecondPassUpdates.size()); } void preProcess() { for (MockViewHolder vh : mViewHolders) { final int ind = mTestAdapter.mItems.indexOf(vh.mItem); assertEquals("actual adapter position should match", ind, mAdapterHelper.applyPendingUpdatesToPosition(vh.mPosition)); } mAdapterHelper.preProcess(); for (int i = 0; i < mPreProcessClone.mItems.size(); i++) { TestAdapter.Item item = mPreProcessClone.mItems.get(i); final int preLayoutIndex = mPreLayoutItems.indexOf(item); final int endIndex = mTestAdapter.mItems.indexOf(item); if (preLayoutIndex != -1) { assertEquals("find position offset should work properly for existing elements" + i + " at pre layout position " + preLayoutIndex + " and post layout position " + endIndex, endIndex, mAdapterHelper.findPositionOffset(preLayoutIndex)); } } // make sure visible view holders still have continuous positions final StringBuilder vhLogBuilder = new StringBuilder(); for (ViewHolder vh : mViewHolders) { vhLogBuilder.append("\n").append(vh.toString()); } if (mViewHolders.size() > 0) { final String vhLog = vhLogBuilder.toString(); final int start = mViewHolders.get(0).getLayoutPosition(); for (int i = 1; i < mViewHolders.size(); i++) { assertEquals("view holder positions should be continious in pre-layout" + vhLog, start + i, mViewHolders.get(i).getLayoutPosition()); } } mAdapterHelper.consumePostponedUpdates(); // now assert these two adapters have identical data. mPreProcessClone.applyOps(mFirstPassUpdates, mTestAdapter); mPreProcessClone.applyOps(mSecondPassUpdates, mTestAdapter); assertAdaptersEqual(mTestAdapter, mPreProcessClone); } private void assertAdaptersEqual(TestAdapter a1, TestAdapter a2) { assertEquals(a1.mItems.size(), a2.mItems.size()); for (int i = 0; i < a1.mItems.size(); i++) { TestAdapter.Item item = a1.mItems.get(i); assertSame(item, a2.mItems.get(i)); assertEquals(0, item.getUpdateCount()); } assertEquals(0, a1.mPendingAdded.size()); assertEquals(0, a2.mPendingAdded.size()); } AdapterHelper.UpdateOp op(int cmd, int start, int count) { return new AdapterHelper.UpdateOp(cmd, start, count, null); } AdapterHelper.UpdateOp op(int cmd, int start, int count, Object payload) { return new AdapterHelper.UpdateOp(cmd, start, count, payload); } AdapterHelper.UpdateOp addOp(int start, int count) { return op(AdapterHelper.UpdateOp.ADD, start, count); } AdapterHelper.UpdateOp rmOp(int start, int count) { return op(AdapterHelper.UpdateOp.REMOVE, start, count); } AdapterHelper.UpdateOp upOp(int start, int count, Object payload) { return op(AdapterHelper.UpdateOp.UPDATE, start, count, payload); } void add(int start, int count) { if (DEBUG) { log("add(" + start + "," + count + ");"); } mTestAdapter.add(start, count); } boolean isItemLaidOut(int pos) { for (ViewHolder viewHolder : mViewHolders) { if (viewHolder.mOldPosition == pos) { return true; } } return false; } private void mv(int from, int to) { if (DEBUG) { log("mv(" + from + "," + to + ");"); } mTestAdapter.move(from, to); } void rm(int start, int count) { if (DEBUG) { log("rm(" + start + "," + count + ");"); } for (int i = start; i < start + count; i++) { if (!isItemLaidOut(i)) { TestAdapter.Item item = mTestAdapter.mItems.get(i); mPreLayoutItems.remove(item); } } mTestAdapter.remove(start, count); } void up(int start, int count) { if (DEBUG) { log("up(" + start + "," + count + ");"); } mTestAdapter.update(start, count); } void up(int start, int count, Object payload) { if (DEBUG) { log("up(" + start + "," + count + "," + payload + ");"); } mTestAdapter.update(start, count, payload); } static class TestAdapter { List<Item> mItems; final AdapterHelper mAdapterHelper; Queue<Item> mPendingAdded; public TestAdapter(int initialCount, AdapterHelper container) { mItems = new ArrayList<Item>(); mAdapterHelper = container; mPendingAdded = new LinkedList<Item>(); for (int i = 0; i < initialCount; i++) { mItems.add(new Item()); } } public void add(int index, int count) { for (int i = 0; i < count; i++) { Item item = new Item(); mPendingAdded.add(item); mItems.add(index + i, item); } mAdapterHelper.addUpdateOp(new AdapterHelper.UpdateOp( AdapterHelper.UpdateOp.ADD, index, count, null )); } public void move(int from, int to) { mItems.add(to, mItems.remove(from)); mAdapterHelper.addUpdateOp(new AdapterHelper.UpdateOp( AdapterHelper.UpdateOp.MOVE, from, to, null )); } public void remove(int index, int count) { for (int i = 0; i < count; i++) { mItems.remove(index); } mAdapterHelper.addUpdateOp(new AdapterHelper.UpdateOp( AdapterHelper.UpdateOp.REMOVE, index, count, null )); } public void update(int index, int count) { update(index, count, null); } public void update(int index, int count, Object payload) { for (int i = 0; i < count; i++) { mItems.get(index + i).update(payload); } mAdapterHelper.addUpdateOp(new AdapterHelper.UpdateOp( AdapterHelper.UpdateOp.UPDATE, index, count, payload )); } protected TestAdapter createCopy() { TestAdapter adapter = new TestAdapter(0, mAdapterHelper); for (Item item : mItems) { adapter.mItems.add(item); } return adapter; } public void applyOps(List<AdapterHelper.UpdateOp> updates, TestAdapter dataSource) { for (AdapterHelper.UpdateOp op : updates) { switch (op.cmd) { case AdapterHelper.UpdateOp.ADD: for (int i = 0; i < op.itemCount; i++) { mItems.add(op.positionStart + i, dataSource.consumeNextAdded()); } break; case AdapterHelper.UpdateOp.REMOVE: for (int i = 0; i < op.itemCount; i++) { mItems.remove(op.positionStart); } break; case AdapterHelper.UpdateOp.UPDATE: for (int i = 0; i < op.itemCount; i++) { mItems.get(op.positionStart + i).handleUpdate(op.payload); } break; case AdapterHelper.UpdateOp.MOVE: mItems.add(op.itemCount, mItems.remove(op.positionStart)); break; } } } private Item consumeNextAdded() { return mPendingAdded.remove(); } public void createFakeItemAt(int fakeAddedItemIndex) { Item fakeItem = new Item(); ((LinkedList<Item>) mPendingAdded).add(fakeAddedItemIndex, fakeItem); } public static class Item { private static AtomicInteger itemCounter = new AtomicInteger(); private final int id; private int mVersionCount = 0; private ArrayList<Object> mPayloads = new ArrayList<Object>(); public Item() { id = itemCounter.incrementAndGet(); } public void update(Object payload) { mPayloads.add(payload); mVersionCount++; } public void handleUpdate(Object payload) { assertSame(payload, mPayloads.get(0)); mPayloads.remove(0); mVersionCount--; } public int getUpdateCount() { return mVersionCount; } } } void waitForDebugger() { android.os.Debug.waitForDebugger(); } static class MockViewHolder extends RecyclerView.ViewHolder { public Object mItem; public MockViewHolder(View itemView) { super(itemView); } } }