/*
 * Copyright (C) 2017 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.leanback.widget;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.atLeast;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;

import android.content.Context;
import android.os.Bundle;
import android.support.test.InstrumentationRegistry;
import android.support.test.filters.SmallTest;
import android.view.View;
import android.view.ViewGroup;
import android.widget.FrameLayout;

import androidx.annotation.Nullable;
import androidx.leanback.R;
import androidx.recyclerview.widget.RecyclerView;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.mockito.Mockito;

import java.util.ArrayList;
import java.util.List;

@SmallTest
@RunWith(JUnit4.class)
public class ObjectAdapterTest {

    private static final String ID = "id";
    private static final String STRING_MEMBER_ONE = "stringMemberOne";
    private static final String STRING_MEMBER_TWO = "stringMemberTwo";
    private static final String NOT_RELATED_STRING_MEMBER = "notRelatedStringMember";

    protected ItemBridgeAdapter mBridgeAdapter;
    protected ArrayObjectAdapter mAdapter;

    private ArrayList mItems;
    private DiffCallback<AdapterItem> mMockedCallback;
    private DiffCallback<AdapterItem> mCallbackWithoutPayload;
    private RecyclerView.AdapterDataObserver mObserver;

    private Context mContext;
    private ListRowPresenter mListRowPresenter;
    private ListRowPresenter.ViewHolder mListVh;
    private ArrayObjectAdapter mRowsAdapter;
    private AdapterItemPresenter mAdapterItemPresenter;

    private ListRow mRow;

    /**
     * This type is used to test setItems() API.
     */
    private static class AdapterItem {
        private int mId;
        private String mStringMemberOne;

        // mStringMemberTwo is only used to test if correct payload can be generated.
        private String mStringMemberTwo;

        // not related string will not impact the result of our equals function.
        // Used to verify if payload computing process still honor the rule set by
        // areContentsTheSame() method
        private String mNotRelatedStringMember;

        AdapterItem(int id, String stringMemberOne) {
            mId = id;
            mStringMemberOne = stringMemberOne;
            mStringMemberTwo = "";
            mNotRelatedStringMember = "";
        }

        AdapterItem(int id, String stringMemberOne, String stringMemberTwo) {
            mId = id;
            mStringMemberOne = stringMemberOne;
            mStringMemberTwo = stringMemberTwo;
            mNotRelatedStringMember = "";
        }

        AdapterItem(int id, String stringMemberOne, String stringMemberTwo,
                String notRelatedStringMember) {
            mId = id;
            mStringMemberOne = stringMemberOne;
            mStringMemberTwo = stringMemberTwo;
            mNotRelatedStringMember = notRelatedStringMember;
        }

        public int getId() {
            return mId;
        }

        public String getStringMemberOne() {
            return mStringMemberOne;
        }

        public String getStringMemberTwo() {
            return mStringMemberTwo;
        }

        public String getNotRelatedStringMember() {
            return mNotRelatedStringMember;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;

            AdapterItem that = (AdapterItem) o;

            if (mId != that.mId) return false;
            if (mStringMemberOne != null ? !mStringMemberOne.equals(that.mStringMemberOne)
                    : that.mStringMemberOne != null) {
                return false;
            }
            return mStringMemberTwo != null ? mStringMemberTwo.equals(that.mStringMemberTwo)
                    : that.mStringMemberTwo == null;
        }

        @Override
        public int hashCode() {
            int result = mId;
            result = 31 * result + (mStringMemberOne != null ? mStringMemberOne.hashCode() : 0);
            result = 31 * result + (mStringMemberTwo != null ? mStringMemberTwo.hashCode() : 0);
            return result;
        }
    }

    /**
     * Extend from DiffCallback extended class to define the rule to compare if two items are the
     * same/ have the same content and how to calculate the payload.
     *
     * The payload will only be calculated when the two items are the same but with different
     * contents. So we make this class as a public class which can be mocked by mockito to verify
     * if the calculation process satisfies our requirement.
     */
    public static class DiffCallbackPayloadTesting extends DiffCallback<AdapterItem> {
        // Using item's mId as the standard to judge if two items is the same
        @Override
        public boolean areItemsTheSame(AdapterItem oldItem, AdapterItem newItem) {
            return oldItem.getId() == newItem.getId();
        }

        // Using equals method to judge if two items have the same content.
        @Override
        public boolean areContentsTheSame(AdapterItem oldItem, AdapterItem newItem) {
            return oldItem.equals(newItem);
        }

        @Nullable
        @Override
        public Object getChangePayload(AdapterItem oldItem,
                AdapterItem newItem) {
            Bundle diff = new Bundle();
            if (oldItem.getId() != newItem.getId()) {
                diff.putInt(ID, newItem.getId());
            }

            if (!oldItem.getStringMemberOne().equals(newItem.getStringMemberOne())) {
                diff.putString(STRING_MEMBER_ONE, newItem.getStringMemberOne());
            }

            if (!oldItem.getStringMemberTwo().equals(newItem.getStringMemberTwo())) {
                diff.putString(STRING_MEMBER_TWO, newItem.getStringMemberTwo());
            }

            if (!oldItem.getNotRelatedStringMember().equals(newItem.getNotRelatedStringMember())) {
                diff.putString(NOT_RELATED_STRING_MEMBER, newItem.getNotRelatedStringMember());
            }

            if (diff.size() == 0) {
                return null;
            }
            return diff;
        }
    }

    /**
     * The presenter designed for adapter item.
     *
     * The reason to set this class as a public class is for Mockito to mock it. So we can observe
     * method's dispatching easily
     */
    public static class AdapterItemPresenter extends Presenter {
        int mWidth;
        int mHeight;

        AdapterItemPresenter() {
            this(100, 100);
        }

        AdapterItemPresenter(int width, int height) {
            mWidth = width;
            mHeight = height;
        }

        @Override
        public ViewHolder onCreateViewHolder(ViewGroup parent) {
            View view = new View(parent.getContext());
            view.setFocusable(true);
            view.setId(R.id.lb_action_button);
            view.setLayoutParams(new ViewGroup.LayoutParams(mWidth, mHeight));
            return new Presenter.ViewHolder(view);
        }

        @Override
        public void onBindViewHolder(ViewHolder viewHolder, Object item) {
            // no - op
        }

        @Override
        public void onUnbindViewHolder(ViewHolder viewHolder) {
            // no - op
        }

        @Override
        public void onBindViewHolder(ViewHolder viewHolder, Object item,
                List<Object> payloads) {
            // no - op
        }
    }


    /**
     * Initialize test-related members.
     */
    @Before
    public void setup() {
        mAdapter = new ArrayObjectAdapter();
        mBridgeAdapter = new ItemBridgeAdapter(mAdapter);
        mItems = new ArrayList();
        mMockedCallback = Mockito.spy(DiffCallbackPayloadTesting.class);

        // the diff callback without calculating the payload
        mCallbackWithoutPayload = new DiffCallback<AdapterItem>() {

            // Using item's mId as the standard to judge if two items is the same
            @Override
            public boolean areItemsTheSame(AdapterItem oldItem, AdapterItem newItem) {
                return oldItem.getId() == newItem.getId();
            }

            // Using equals method to judge if two items have the same content.
            @Override
            public boolean areContentsTheSame(AdapterItem oldItem, AdapterItem newItem) {
                return oldItem.equals(newItem);
            }
        };

        // Spy the RecyclerView.AdapterObserver
        mObserver = Mockito.spy(RecyclerView.AdapterDataObserver.class);

        // register observer so we can observe the events
        mBridgeAdapter.registerAdapterDataObserver(mObserver);

        // obtain context through instrumentation registry
        mContext = InstrumentationRegistry.getInstrumentation().getTargetContext();

        //
        ListRowPresenter listRowPresenter = new ListRowPresenter();
        mListRowPresenter = Mockito.spy(listRowPresenter);

        // mock item presenter
        AdapterItemPresenter adapterItemPresenter = new AdapterItemPresenter();
        mAdapterItemPresenter = Mockito.spy(adapterItemPresenter);
        mRow = new ListRow(new ArrayObjectAdapter(mAdapterItemPresenter));
    }

    /**
     * The following test case is mainly focused on the basic functionality provided by
     * Object Adapter.
     *
     * The key purpose for this test is to make sure when adapter send out a signal through
     * notify function, it will finally be intercepted by recycler view's observer
     */
    @Test
    public void testBasicFunctionality() {
        mItems.add("a");
        mItems.add("b");
        mItems.add("c");
        mAdapter.addAll(0, mItems);

        // size
        assertEquals(mAdapter.size(), 3);

        // get
        assertEquals(mAdapter.get(0), "a");
        assertEquals(mAdapter.get(1), "b");
        assertEquals(mAdapter.get(2), "c");

        // indexOf
        assertEquals(mAdapter.indexOf("a"), 0);
        assertEquals(mAdapter.indexOf("b"), 1);
        assertEquals(mAdapter.indexOf("c"), 2);

        // insert
        mAdapter.add(1, "a1");
        Mockito.verify(mObserver).onItemRangeInserted(1, 1);
        assertAdapterContent(mAdapter, new Object[]{"a", "a1", "b", "c"});
        Mockito.reset(mObserver);

        // insert multiple
        ArrayList newItems1 = new ArrayList();
        newItems1.add("a2");
        newItems1.add("a3");
        mAdapter.addAll(1, newItems1);
        Mockito.verify(mObserver).onItemRangeInserted(1, 2);
        assertAdapterContent(mAdapter, new Object[]{"a", "a2", "a3", "a1", "b", "c"});
        Mockito.reset(mObserver);

        // update
        mAdapter.notifyArrayItemRangeChanged(2, 3);
        Mockito.verify(mObserver).onItemRangeChanged(2, 3);
        assertAdapterContent(mAdapter, new Object[]{"a", "a2", "a3", "a1", "b", "c"});
        Mockito.reset(mObserver);

        // remove
        mAdapter.removeItems(1, 4);
        Mockito.verify(mObserver).onItemRangeRemoved(1, 4);
        assertAdapterContent(mAdapter, new Object[]{"a", "c"});
        Mockito.reset(mObserver);

        // move
        mAdapter.move(0, 1);
        Mockito.verify(mObserver).onItemRangeMoved(0, 1, 1);
        assertAdapterContent(mAdapter, new Object[]{"c", "a"});
        Mockito.reset(mObserver);

        // replace
        mAdapter.replace(0, "a");
        Mockito.verify(mObserver).onItemRangeChanged(0, 1);
        assertAdapterContent(mAdapter, new Object[]{"a", "a"});
        Mockito.reset(mObserver);
        mAdapter.replace(1, "b");
        Mockito.verify(mObserver).onItemRangeChanged(1, 1);
        assertAdapterContent(mAdapter, new Object[]{"a", "b"});
        Mockito.reset(mObserver);

        // remove multiple
        mItems.clear();
        mItems.add("a");
        mItems.add("b");
        mAdapter.addAll(0, mItems);
        mAdapter.removeItems(0, 2);
        Mockito.verify(mObserver).onItemRangeRemoved(0, 2);
        assertAdapterContent(mAdapter, new Object[]{"a", "b"});
        Mockito.reset(mObserver);

        // clear
        mAdapter.clear();
        Mockito.verify(mObserver).onItemRangeRemoved(0, 2);
        assertAdapterContent(mAdapter, new Object[]{});
        Mockito.reset(mObserver);

        // isImmediateNotifySupported
        assertTrue(mAdapter.isImmediateNotifySupported());
    }


    @Test
    public void testSetItemsNoDiffCallback() {
        mItems.add(new AdapterItem(1, "a"));
        mItems.add(new AdapterItem(2, "b"));
        mItems.add(new AdapterItem(3, "c"));
        mAdapter.setItems(mItems, null);
        Mockito.verify(mObserver, times(1)).onChanged();
        Mockito.verify(mObserver, never()).onItemRangeInserted(anyInt(), anyInt());
        Mockito.verify(mObserver, never()).onItemRangeRemoved(anyInt(), anyInt());
        Mockito.verify(mObserver, never()).onItemRangeMoved(anyInt(), anyInt(), anyInt());

        mItems.add(new AdapterItem(4, "a"));
        mItems.add(new AdapterItem(5, "b"));
        mItems.add(new AdapterItem(6, "c"));
        mAdapter.setItems(mItems, null);
        Mockito.verify(mObserver, times(2)).onChanged();
        Mockito.verify(mObserver, never()).onItemRangeInserted(anyInt(), anyInt());
        Mockito.verify(mObserver, never()).onItemRangeRemoved(anyInt(), anyInt());
        Mockito.verify(mObserver, never()).onItemRangeMoved(anyInt(), anyInt(), anyInt());
    }

    /**
     * The following test cases are mainly focused on the basic functionality provided by setItems
     * function
     *
     * It can be deemed as an extension to the previous test, and won't consider payload in this
     * test case.
     *
     * Test0 will treat all items as the same item with same content.
     */
    @Test
    public void testSetItemsMethod0() {
        mItems.add("a");
        mItems.add("b");
        mItems.add("c");

        DiffCallback<String> callback = new DiffCallback<String>() {

            // Always treat two items are the same.
            @Override
            public boolean areItemsTheSame(String oldItem, String newItem) {
                return true;
            }

            // Always treat two items have the same content.
            @Override
            public boolean areContentsTheSame(String oldItem, String newItem) {
                return true;
            }
        };

        mAdapter.setItems(mItems, callback);
        // verify method dispatching
        Mockito.verify(mObserver).onItemRangeInserted(0, 3);

        // Clear previous items and set a new list of items.
        mItems.clear();
        mItems.add("a");
        mItems.add("b");
        mItems.add("c");

        // reset mocked object before calling setItems method
        Mockito.reset(mObserver);
        mAdapter.setItems(mItems, callback);

        // verify method dispatching
        Mockito.verify(mObserver, never()).onItemRangeChanged(anyInt(), anyInt(), any());
        Mockito.verify(mObserver, never()).onItemRangeMoved(anyInt(), anyInt(), anyInt());
        Mockito.verify(mObserver, never()).onItemRangeRemoved(anyInt(), anyInt());
        Mockito.verify(mObserver, never()).onItemRangeInserted(anyInt(), anyInt());
        assertAdapterContent(mAdapter, new Object[]{"a", "b", "c"});
    }

    /**
     * Test1 will treat all items as the same item with same content.
     */
    @Test
    public void testSetItemsMethod1() {
        mItems.add("a");
        mItems.add("b");
        mItems.add("c");

        DiffCallback<String> callback = new DiffCallback<String>() {

            // Always treat two items are the different.
            @Override
            public boolean areItemsTheSame(String oldItem, String newItem) {
                return false;
            }

            // Always treat two items have the different content.
            @Override
            public boolean areContentsTheSame(String oldItem, String newItem) {
                return false;
            }
        };

        mAdapter.setItems(mItems, callback);
        // verify method dispatching
        Mockito.verify(mObserver).onItemRangeInserted(0, 3);

        // Clear previous items and set a new list of items.
        mItems.clear();
        mItems.add("a");
        mItems.add("b");
        mItems.add("c");

        // reset mocked object before calling setItems method
        Mockito.reset(mObserver);
        mAdapter.setItems(mItems, callback);

        // No change or move event should be fired under current callback.
        Mockito.verify(mObserver, never()).onItemRangeChanged(anyInt(), anyInt(), any());
        Mockito.verify(mObserver, never()).onItemRangeMoved(anyInt(), anyInt(), anyInt());
        Mockito.verify(mObserver).onItemRangeRemoved(0, 3);
        Mockito.verify(mObserver).onItemRangeInserted(0, 3);
        assertAdapterContent(mAdapter, new Object[]{"a", "b", "c"});
    }

    /**
     * Test2 will trigger notifyItemRangeChanged event
     */
    @Test
    public void testSetItemsMethod2() {
        // initial item list
        mItems.add(new AdapterItem(1, "a"));
        mItems.add(new AdapterItem(2, "b"));
        mItems.add(new AdapterItem(3, "c"));
        mAdapter.setItems(mItems, mCallbackWithoutPayload);

        // Clear previous items and set a new list of items.
        mItems.clear();
        mItems.add(new AdapterItem(1, "a"));
        mItems.add(new AdapterItem(2, "c"));
        mItems.add(new AdapterItem(3, "b"));

        // reset mocked object before calling setItems method
        Mockito.reset(mObserver);
        mAdapter.setItems(mItems, mCallbackWithoutPayload);

        // verify method dispatching
        Mockito.verify(mObserver).onItemRangeChanged(1, 2, null);
    }


    /**
     * Test3 will trigger notifyItemMoved event
     */
    @Test
    public void testSetItemsMethod3() {
        // initial item list
        mItems.add(new AdapterItem(1, "a"));
        mItems.add(new AdapterItem(2, "b"));
        mItems.add(new AdapterItem(3, "c"));
        mAdapter.setItems(mItems, mCallbackWithoutPayload);

        // Clear previous items and set a new list of items.
        mItems.clear();
        mItems.add(new AdapterItem(2, "b"));
        mItems.add(new AdapterItem(1, "a"));
        mItems.add(new AdapterItem(3, "c"));

        // reset mocked object before calling setItems method
        Mockito.reset(mObserver);
        mAdapter.setItems(mItems, mCallbackWithoutPayload);

        // verify method dispatching
        Mockito.verify(mObserver).onItemRangeMoved(1, 0, 1);
    }

    /**
     * Test4 will trigger notifyItemRangeRemoved event
     */
    @Test
    public void testSetItemsMethod4() {
        // initial item list
        mItems.add(new AdapterItem(1, "a"));
        mItems.add(new AdapterItem(2, "b"));
        mItems.add(new AdapterItem(3, "c"));
        mAdapter.setItems(mItems, mCallbackWithoutPayload);

        // Clear previous items and set a new list of items.
        mItems.clear();
        mItems.add(new AdapterItem(2, "b"));
        mItems.add(new AdapterItem(3, "c"));

        // reset mocked object before calling setItems method
        Mockito.reset(mObserver);
        mAdapter.setItems(mItems, mCallbackWithoutPayload);

        // verify method dispatching
        Mockito.verify(mObserver).onItemRangeRemoved(0, 1);
    }

    /**
     * Test5 will trigger notifyItemRangeInserted event
     */
    @Test
    public void testSetItemsMethod5() {
        // initial item list
        mItems.add(new AdapterItem(1, "a"));
        mItems.add(new AdapterItem(2, "b"));
        mItems.add(new AdapterItem(3, "c"));
        mAdapter.setItems(mItems, mCallbackWithoutPayload);

        // Clear previous items and set a new list of items.
        mItems.clear();
        mItems.add(new AdapterItem(1, "a"));
        mItems.add(new AdapterItem(2, "b"));
        mItems.add(new AdapterItem(3, "c"));
        mItems.add(new AdapterItem(4, "d"));

        // reset mocked object before calling setItems method
        Mockito.reset(mObserver);
        mAdapter.setItems(mItems, mCallbackWithoutPayload);

        // verify method dispatching
        Mockito.verify(mObserver).onItemRangeInserted(3, 1);
    }


    /**
     * Test6 will trigger notifyItemRangeInserted event and notifyItemRangeRemoved event
     * simultaneously
     */
    @Test
    public void testSetItemsMethod6() {
        // initial item list
        mItems.add(new AdapterItem(1, "a"));
        mItems.add(new AdapterItem(2, "b"));
        mItems.add(new AdapterItem(3, "c"));
        mAdapter.setItems(mItems, mCallbackWithoutPayload);

        // Clear previous items and set a new list of items.
        mItems.clear();
        mItems.add(new AdapterItem(2, "a"));
        mItems.add(new AdapterItem(2, "b"));
        mItems.add(new AdapterItem(3, "c"));

        // reset mocked object before calling setItems method
        Mockito.reset(mObserver);
        mAdapter.setItems(mItems, mCallbackWithoutPayload);

        // verify method dispatching
        Mockito.verify(mObserver).onItemRangeRemoved(0, 1);
        Mockito.verify(mObserver).onItemRangeInserted(0, 1);
    }

    /**
     * Test7 will trigger notifyItemRangeMoved and notifyItemRangeChanged event simultaneously
     */
    @Test
    public void testItemsMethod7() {
        // initial item list
        mItems.add(new AdapterItem(1, "a"));
        mItems.add(new AdapterItem(2, "b"));
        mItems.add(new AdapterItem(3, "c"));
        mAdapter.setItems(mItems, mCallbackWithoutPayload);

        // Clear previous items and set a new list of items.
        mItems.clear();
        mItems.add(new AdapterItem(1, "aa"));
        mItems.add(new AdapterItem(3, "c"));
        mItems.add(new AdapterItem(2, "b"));

        // reset mocked object before calling setItems method
        Mockito.reset(mObserver);
        mAdapter.setItems(mItems, mCallbackWithoutPayload);

        // verify method dispatching
        Mockito.verify(mObserver).onItemRangeChanged(0, 1, null);
        Mockito.verify(mObserver).onItemRangeMoved(2, 1, 1);
    }

    /**
     * Test8 will trigger multiple items insertion event
     */
    @Test
    public void testSetItemsMethod8() {

        // initial item list
        mAdapter.clear();
        mItems.add(new AdapterItem(0, "a"));
        mItems.add(new AdapterItem(1, "b"));
        mAdapter.clear();
        mAdapter.setItems(mItems, mCallbackWithoutPayload);

        // Clear previous items and set a new list of items.
        mItems.clear();
        mItems.add(new AdapterItem(0, "a"));
        mItems.add(new AdapterItem(1, "b"));
        mItems.add(new AdapterItem(2, "c"));
        mItems.add(new AdapterItem(3, "d"));

        // reset mocked object before calling setItems method
        Mockito.reset(mObserver);
        mAdapter.setItems(mItems, mCallbackWithoutPayload);

        // verify method dispatching
        Mockito.verify(mObserver).onItemRangeInserted(2, 2);
        Mockito.reset(mObserver);
    }


    /**
     * The following test cases are mainly focused on testing setItems method when we need to
     * calculate payload
     *
     * The payload should only be calculated when two items are same but with different contents.
     * I.e. the calculate payload method should only be executed when the previous condition is
     * satisfied. In this test case we use a mocked callback object to verify it and compare the
     * calculated payload with our expected payload.
     *
     * Test 0 will calculate the difference on string member one.
     */
    @Test
    public void testPayloadCalculation0() {
        AdapterItem oldItem = new AdapterItem(1, "a", "a");
        mItems.add(oldItem);
        mAdapter.setItems(mItems, mMockedCallback);

        // Create a new item list which contain a new AdapterItem object
        // test if payload is computed correctly by changing string member 1
        mItems.clear();
        AdapterItem newItem = new AdapterItem(1, "aa", "a");
        mItems.add(newItem);


        // reset mocked object before calling setItems method
        Mockito.reset(mObserver);
        Mockito.reset(mMockedCallback);
        mAdapter.setItems(mItems, mMockedCallback);

        // Create expected payload manually for verification
        Bundle expectedPayload0 = new Bundle();
        expectedPayload0.putString(STRING_MEMBER_ONE, newItem.getStringMemberOne());

        // make sure no other event will be triggered in current scenario
        Mockito.verify(mObserver, never()).onItemRangeInserted(anyInt(), anyInt());
        Mockito.verify(mObserver, never()).onItemRangeRemoved(anyInt(), anyInt());
        Mockito.verify(mObserver, never()).onItemRangeMoved(anyInt(), anyInt(), anyInt());

        // Check if getChangePayload is executed as we expected
        Mockito.verify(mObserver, never()).onItemRangeChanged(anyInt(), anyInt(), eq(null));
        Mockito.verify(mMockedCallback).getChangePayload(oldItem,
                newItem);

        // compare the two bundles by iterating each member
        Bundle calculatedBundle0 = (Bundle) mMockedCallback.getChangePayload(
                oldItem, newItem);
        compareTwoBundles(calculatedBundle0, expectedPayload0);

    }

    /**
     * Test 1 will calculate the difference on string member two.
     */
    @Test
    public void testPayloadComputation1() {
        AdapterItem oldItem = new AdapterItem(1, "a", "a");
        mItems.add(oldItem);
        mAdapter.setItems(mItems, mMockedCallback);

        // Create a new item list which contain a new AdapterItem object
        // test if payload is computed correctly by changing string member 2
        mItems.clear();
        AdapterItem newItem = new AdapterItem(1, "a", "aa");
        mItems.add(newItem);

        // reset mocked object before calling setItems method
        Mockito.reset(mObserver);
        Mockito.reset(mMockedCallback);
        mAdapter.setItems(mItems, mMockedCallback);

        // Create expected payload manually for verification
        Bundle expectedPayload0 = new Bundle();
        expectedPayload0.putString(STRING_MEMBER_TWO, newItem.getStringMemberTwo());

        // make sure no other event will be triggered in current scenario
        Mockito.verify(mObserver, never()).onItemRangeInserted(anyInt(), anyInt());
        Mockito.verify(mObserver, never()).onItemRangeRemoved(anyInt(), anyInt());
        Mockito.verify(mObserver, never()).onItemRangeMoved(anyInt(), anyInt(), anyInt());

        // Check if getChangePayload is executed as we expected
        Mockito.verify(mObserver, never()).onItemRangeChanged(anyInt(), anyInt(), eq(null));
        Mockito.verify(mMockedCallback).getChangePayload(oldItem,
                newItem);

        // compare the two bundles by iterating each member
        Bundle calculatedBundle0 = (Bundle) mMockedCallback.getChangePayload(
                oldItem, newItem);
        compareTwoBundles(calculatedBundle0, expectedPayload0);

    }

    /**
     * Test 1 will calculate the difference on string member one and string member two.
     */
    @Test
    public void testPayloadComputation2() {
        AdapterItem oldItem = new AdapterItem(1, "a", "a");
        mItems.add(oldItem);
        mAdapter.setItems(mItems, mMockedCallback);

        // Create a new item list which contain a new AdapterItem object
        // test if payload is computed correctly by changing string member 1 and string member 2
        mItems.clear();
        AdapterItem newItem = new AdapterItem(1, "aa", "aa");
        mItems.add(newItem);

        // reset mocked object before calling setItems method
        Mockito.reset(mObserver);
        Mockito.reset(mMockedCallback);
        mAdapter.setItems(mItems, mMockedCallback);

        // Create expected payload manually for verification
        Bundle expectedPayload0 = new Bundle();
        expectedPayload0.putString(STRING_MEMBER_ONE, newItem.getStringMemberOne());
        expectedPayload0.putString(STRING_MEMBER_TWO, newItem.getStringMemberTwo());

        // make sure no other event will be triggered in current scenario
        Mockito.verify(mObserver, never()).onItemRangeInserted(anyInt(), anyInt());
        Mockito.verify(mObserver, never()).onItemRangeRemoved(anyInt(), anyInt());
        Mockito.verify(mObserver, never()).onItemRangeMoved(anyInt(), anyInt(), anyInt());

        // Check if getChangePayload is executed as we expected
        Mockito.verify(mObserver, never()).onItemRangeChanged(anyInt(), anyInt(), eq(null));
        Mockito.verify(mMockedCallback).getChangePayload(oldItem,
                newItem);

        // compare the two bundles by iterating each member
        Bundle calculatedBundle0 = (Bundle) mMockedCallback.getChangePayload(
                oldItem, newItem);
        compareTwoBundles(calculatedBundle0, expectedPayload0);

    }

    /**
     * Test payload computation process under the condition when two items are not the same
     * based on areItemsTheSame function in DiffUtilCallback
     */
    @Test
    public void testPayloadComputationNewItem0() {
        AdapterItem oldItem = new AdapterItem(1, "a", "a");
        mItems.add(oldItem);
        mAdapter.setItems(mItems, mMockedCallback);

        // Create a new item list which contain a new AdapterItem object
        // The id of the new item is changed, and will be treated as a new item according to the
        // rule we set in the callback. This test case is to verify the getChangePayload
        // method still honor the standard we set up to judge new item
        mItems.clear();
        AdapterItem newItem = new AdapterItem(2, "a", "a");
        mItems.add(newItem);

        // reset mocked object before calling setItems method
        Mockito.reset(mObserver);
        Mockito.reset(mMockedCallback);
        mAdapter.setItems(mItems, mMockedCallback);

        // Make sure only remove/ insert event will be fired under this circumstance
        Mockito.verify(mObserver).onItemRangeRemoved(0, 1);
        Mockito.verify(mObserver).onItemRangeInserted(0, 1);
        Mockito.verify(mObserver, never()).onItemRangeChanged(anyInt(), anyInt(), any());
        Mockito.verify(mMockedCallback, never()).getChangePayload((AdapterItem) any(),
                (AdapterItem) any());

    }

    /**
     * Test payload computation process under the condition when two items are not the same
     * based on areItemsTheSame function in DiffUtilCallback
     *
     * But in test 1 we have changed string member one for sanity check.
     */
    @Test
    public void testPayloadComputationNewItem1() {
        AdapterItem oldItem = new AdapterItem(1, "a", "a");
        mItems.add(oldItem);
        mAdapter.setItems(mItems, mMockedCallback);

        // Create a new item list which contain a new AdapterItem object
        // The id of the new item is changed, and will be treated as a new item according to the
        // rule we set in the callback. This test case is to verify the getChangePayload
        // method still honor the standard we set up to judge new item
        mItems.clear();
        AdapterItem newItem = new AdapterItem(2, "aa", "a");
        mItems.add(newItem);

        // reset mocked object before calling setItems method
        Mockito.reset(mObserver);
        Mockito.reset(mMockedCallback);
        mAdapter.setItems(mItems, mMockedCallback);

        // Make sure only remove/ insert event will be fired under this circumstance
        Mockito.verify(mObserver).onItemRangeRemoved(0, 1);
        Mockito.verify(mObserver).onItemRangeInserted(0, 1);
        Mockito.verify(mObserver, never()).onItemRangeChanged(anyInt(), anyInt(), any());
        Mockito.verify(mMockedCallback, never()).getChangePayload((AdapterItem) any(),
                (AdapterItem) any());

    }

    /**
     * Test payload computation process under the condition when two items are not the same
     * based on areItemsTheSame function in DiffUtilCallback
     *
     * But in test 2 we have changed string member two for sanity check.
     */
    @Test
    public void testPayloadComputationNewItem2() {
        AdapterItem oldItem = new AdapterItem(1, "a", "a");
        mItems.add(oldItem);
        mAdapter.setItems(mItems, mMockedCallback);

        // Create a new item list which contain a new AdapterItem object
        // The id of the new item is changed, and will be treated as a new item according to the
        // rule we set in the callback. This test case is to verify the getChangePayload
        // method still honor the standard we set up to judge new item
        mItems.clear();
        AdapterItem newItem = new AdapterItem(2, "a", "aa");
        mItems.add(newItem);

        // reset mocked object before calling setItems method
        Mockito.reset(mObserver);
        Mockito.reset(mMockedCallback);
        mAdapter.setItems(mItems, mMockedCallback);

        // Make sure only remove/ insert event will be fired under this circumstance
        Mockito.verify(mObserver).onItemRangeRemoved(0, 1);
        Mockito.verify(mObserver).onItemRangeInserted(0, 1);
        Mockito.verify(mObserver, never()).onItemRangeChanged(anyInt(), anyInt(), any());
        Mockito.verify(mMockedCallback, never()).getChangePayload((AdapterItem) any(),
                (AdapterItem) any());

    }

    /**
     * Test payload computation process under the condition when two items are not the same
     * based on areItemsTheSame function in DiffUtilCallback
     *
     * But in test 3 we have changed string member one and string member two for sanity check.
     */
    @Test
    public void testPayloadComputationNewItem3() {
        AdapterItem oldItem = new AdapterItem(1, "a", "a");
        mItems.add(oldItem);
        mAdapter.setItems(mItems, mMockedCallback);

        // Create a new item list which contain a new AdapterItem object
        // The id of the new item is changed, and will be treated as a new item according to the
        // rule we set in the callback. This test case is to verify the getChangePayload
        // method still honor the standard we set up to judge new item
        mItems.clear();
        AdapterItem newItem = new AdapterItem(2, "aa", "aa");
        mItems.add(newItem);

        // reset mocked object before calling setItems method
        Mockito.reset(mObserver);
        Mockito.reset(mMockedCallback);
        mAdapter.setItems(mItems, mMockedCallback);

        // Make sure only remove/ insert event will be fired under this circumstance
        Mockito.verify(mObserver).onItemRangeRemoved(0, 1);
        Mockito.verify(mObserver).onItemRangeInserted(0, 1);
        Mockito.verify(mObserver, never()).onItemRangeChanged(anyInt(), anyInt(), any());
        Mockito.verify(mMockedCallback, never()).getChangePayload((AdapterItem) any(),
                (AdapterItem) any());
    }

    /**
     * Test payload computation process under the condition when two items have the same content
     * based on areContentsTheSame function in DiffUtilCallback
     */
    @Test
    public void testPayloadComputationSameContent() {
        AdapterItem oldItem = new AdapterItem(1, "a", "a", "a");
        mItems.add(oldItem);
        mAdapter.setItems(mItems, mMockedCallback);

        // Create a new item list which contain a new AdapterItem object
        // The non-related string member of the new item is changed, but the two items are still
        // the same as well as the item's content according to the rule we set in the callback.
        // This test case is to verify the getChangePayload method still honor the standard
        // we set up to determine if a new object is 1. a new item 2. has the same content as the
        // previous one
        mItems.clear();
        AdapterItem newItem = new AdapterItem(1, "a", "a", "aa");
        mItems.add(newItem);

        // reset mocked object before calling setItems method
        Mockito.reset(mObserver);
        Mockito.reset(mMockedCallback);
        mAdapter.setItems(mItems, mMockedCallback);

        // Make sure no even will be fired up in this circumstance
        Mockito.verify(mObserver, never()).onItemRangeRemoved(anyInt(), anyInt());
        Mockito.verify(mObserver, never()).onItemRangeInserted(anyInt(), anyInt());
        Mockito.verify(mObserver, never()).onItemRangeChanged(anyInt(), anyInt(), any());
        Mockito.verify(mMockedCallback, never()).getChangePayload((AdapterItem) any(),
                (AdapterItem) any());
    }


    /**
     * This test case is targeted at real ui testing. I.e. making sure when the change of adapter's
     * items will trigger the rebinding of view holder with payload. That's item presenter's
     * onBindViewHolder method with payload supporting.
     *
     */
    @Test
    public void testPresenterAndItemBridgeAdapter() {
        // data set one
        final List<AdapterItem> dataSetOne = new ArrayList<>();
        AdapterItem dataSetOne0 = new AdapterItem(1, "a");
        AdapterItem dataSetOne1 = new AdapterItem(2, "b");
        AdapterItem dataSetOne2 = new AdapterItem(3, "c");
        AdapterItem dataSetOne3 = new AdapterItem(4, "d");
        AdapterItem dataSetOne4 = new AdapterItem(5, "3");
        dataSetOne.add(dataSetOne0);
        dataSetOne.add(dataSetOne1);
        dataSetOne.add(dataSetOne2);
        dataSetOne.add(dataSetOne3);
        dataSetOne.add(dataSetOne4);

        // data set two
        final List<AdapterItem> dataSetTwo = new ArrayList<>();
        AdapterItem dataSetTwo0 = new AdapterItem(1, "aa");
        AdapterItem dataSetTwo1 = new AdapterItem(2, "bb");
        AdapterItem dataSetTwo2 = new AdapterItem(3, "cc");
        AdapterItem dataSetTwo3 = new AdapterItem(4, "dd");
        AdapterItem dataSetTwo4 = new AdapterItem(5, "ee");
        dataSetTwo.add(dataSetTwo0);
        dataSetTwo.add(dataSetTwo1);
        dataSetTwo.add(dataSetTwo2);
        dataSetTwo.add(dataSetTwo3);
        dataSetTwo.add(dataSetTwo4);

        ((ArrayObjectAdapter) mRow.getAdapter()).addAll(0, dataSetOne);
        InstrumentationRegistry.getInstrumentation().runOnMainSync(new Runnable() {
            @Override
            public void run() {

                // obtain frame layout through context.
                final ViewGroup parent = new FrameLayout(mContext);

                // create view holder and obtain the view object from view holder
                // add view object to our layout
                Presenter.ViewHolder containerVh = mListRowPresenter.onCreateViewHolder(parent);
                parent.addView(containerVh.view, 1000, 1000);

                // set rows adapter and add row to that adapter
                mRowsAdapter = new ArrayObjectAdapter();
                mRowsAdapter.add(mRow);

                // use the presenter to bind row view holder explicitly. So the itemBridgeAdapter
                // will be connected to the adapter inside of the listRow successfully.
                mListVh = (ListRowPresenter.ViewHolder) mListRowPresenter.getRowViewHolder(
                        containerVh);
                mListRowPresenter.onBindRowViewHolder(mListVh, mRow);

                // layout the list row in recycler view
                runRecyclerViewLayout();

                // reset mocked presenter
                Mockito.reset(mListRowPresenter);
                Mockito.reset(mAdapterItemPresenter);

                // calling setItem's method to trigger the diff computation
                ((ArrayObjectAdapter) mRow.getAdapter()).setItems(dataSetTwo,
                        new DiffCallbackPayloadTesting());

                // re-layout the recycler view to trigger getViewForPosition event
                runRecyclerViewLayout();

                // verify method execution
                Mockito.verify(mAdapterItemPresenter, never()).onBindViewHolder(
                        (RowPresenter.ViewHolder) any(), (Object) any());
                Mockito.verify(mAdapterItemPresenter, atLeast(5)).onBindViewHolder(
                        (RowPresenter.ViewHolder) any(), (Object) any(), (List<Object>) any());
            }
        });
    }

    /**
     * Helper function to layout recycler view
     * So the recycler view will execute the getView() method then the onBindViewHolder() method
     * from presenter will be executed
     */
    private void runRecyclerViewLayout() {
        mListVh.view.measure(View.MeasureSpec.makeMeasureSpec(1000, View.MeasureSpec.EXACTLY),
                View.MeasureSpec.makeMeasureSpec(1000, View.MeasureSpec.EXACTLY));
        mListVh.view.layout(0, 0, 1000, 1000);
    }

    /**
     * Helper function to compare two bundles through iterating the fields.
     *
     * @param bundle1 bundle 1
     * @param bundle2 bundle 2
     */
    private void compareTwoBundles(Bundle bundle1, Bundle bundle2) {
        assertEquals(bundle1.getInt(ID), bundle2.getInt(ID));
        assertEquals(bundle1.getString(STRING_MEMBER_ONE), bundle2.getString(
                STRING_MEMBER_ONE));
        assertEquals(bundle1.getString(STRING_MEMBER_TWO), bundle2.getString(
                STRING_MEMBER_TWO));
        assertEquals(bundle1.getString(NOT_RELATED_STRING_MEMBER),
                bundle2.getString(NOT_RELATED_STRING_MEMBER));
    }

    /**
     * Helper function to test the content in adapter
     */
    private static void assertAdapterContent(ObjectAdapter adapter, Object[] data) {
        assertEquals(adapter.size(), data.length);
        for (int i = 0; i < adapter.size(); i++) {
            assertEquals(adapter.get(i), data[i]);
        }
    }
}