1/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16package android.support.v7.util;
17
18import static org.mockito.Mockito.mock;
19import static org.mockito.Mockito.verify;
20import static org.mockito.Mockito.verifyNoMoreInteractions;
21
22import android.support.test.filters.SmallTest;
23
24import org.junit.Before;
25import org.junit.Test;
26import org.junit.runner.RunWith;
27import org.junit.runners.JUnit4;
28
29@RunWith(JUnit4.class)
30@SmallTest
31public class BatchingListUpdateCallbackTest {
32    BatchingListUpdateCallback mBatching;
33    ListUpdateCallback mCallback;
34
35    @Before
36    public void setup() {
37        mCallback = mock(ListUpdateCallback.class);
38        mBatching = new BatchingListUpdateCallback(mCallback);
39    }
40
41    @Test
42    public void addSimple() {
43        mBatching.onInserted(3, 2);
44        mBatching.dispatchLastEvent();
45        verify(mCallback).onInserted(3, 2);
46        verifyNoMoreInteractions(mCallback);
47    }
48
49    @Test
50    public void addToSamePos() {
51        mBatching.onInserted(3, 2);
52        mBatching.onInserted(3, 1);
53        mBatching.dispatchLastEvent();
54        verify(mCallback).onInserted(3, 3);
55        verifyNoMoreInteractions(mCallback);
56    }
57
58    @Test
59    public void addInsidePrevious() {
60        mBatching.onInserted(3, 5);
61        mBatching.onInserted(5, 1);
62        mBatching.dispatchLastEvent();
63        verify(mCallback).onInserted(3, 6);
64        verifyNoMoreInteractions(mCallback);
65    }
66
67    @Test
68    public void addBefore() {
69        mBatching.onInserted(3, 5);
70        mBatching.onInserted(2, 1);
71        mBatching.dispatchLastEvent();
72        verify(mCallback).onInserted(3, 5);
73        verify(mCallback).onInserted(2, 1);
74        verifyNoMoreInteractions(mCallback);
75    }
76
77    @Test
78    public void removeSimple() {
79        mBatching.onRemoved(3, 2);
80        mBatching.dispatchLastEvent();
81        verify(mCallback).onRemoved(3, 2);
82        verifyNoMoreInteractions(mCallback);
83    }
84
85    @Test
86    public void removeSamePosition() {
87        mBatching.onRemoved(3, 2);
88        mBatching.onRemoved(3, 1);
89        mBatching.dispatchLastEvent();
90        verify(mCallback).onRemoved(3, 3);
91        verifyNoMoreInteractions(mCallback);
92    }
93
94    @Test
95    public void removeInside() {
96        mBatching.onRemoved(3, 5);
97        mBatching.onRemoved(4, 2);
98        mBatching.dispatchLastEvent();
99        verify(mCallback).onRemoved(3, 5);
100        verify(mCallback).onRemoved(4, 2);
101        verifyNoMoreInteractions(mCallback);
102    }
103
104    @Test
105    public void removeBefore() {
106        mBatching.onRemoved(3, 2);
107        mBatching.onRemoved(2, 1);
108        mBatching.dispatchLastEvent();
109        verify(mCallback).onRemoved(2, 3);
110        verifyNoMoreInteractions(mCallback);
111    }
112
113    @Test
114    public void removeBefore2() {
115        mBatching.onRemoved(3, 2);
116        mBatching.onRemoved(2, 4);
117        mBatching.dispatchLastEvent();
118        verify(mCallback).onRemoved(2, 6);
119        verifyNoMoreInteractions(mCallback);
120    }
121
122    @Test
123    public void removeBefore3() {
124        mBatching.onRemoved(3, 2);
125        mBatching.onRemoved(1, 1);
126        mBatching.dispatchLastEvent();
127        verify(mCallback).onRemoved(3, 2);
128        verify(mCallback).onRemoved(1, 1);
129        verifyNoMoreInteractions(mCallback);
130    }
131
132    @Test
133    public void moveSimple() {
134        mBatching.onMoved(3, 2);
135        mBatching.dispatchLastEvent();
136        verify(mCallback).onMoved(3, 2);
137        verifyNoMoreInteractions(mCallback);
138    }
139
140    @Test
141    public void moveTwice() {
142        mBatching.onMoved(3, 2);
143        mBatching.onMoved(5, 6);
144        mBatching.dispatchLastEvent();
145        verify(mCallback).onMoved(3, 2);
146        verify(mCallback).onMoved(5, 6);
147        verifyNoMoreInteractions(mCallback);
148    }
149
150    @Test
151    public void changeSimple() {
152        mBatching.onChanged(3, 2, null);
153        mBatching.dispatchLastEvent();
154        verify(mCallback).onChanged(3, 2, null);
155        verifyNoMoreInteractions(mCallback);
156    }
157
158    @Test
159    public void changeConsecutive() {
160        mBatching.onChanged(3, 2, null);
161        mBatching.onChanged(5, 2, null);
162        mBatching.dispatchLastEvent();
163        verify(mCallback).onChanged(3, 4, null);
164        verifyNoMoreInteractions(mCallback);
165    }
166
167    @Test
168    public void changeTheSame() {
169        mBatching.onChanged(3, 2, null);
170        mBatching.onChanged(4, 2, null);
171        mBatching.dispatchLastEvent();
172        verify(mCallback).onChanged(3, 3, null);
173        verifyNoMoreInteractions(mCallback);
174    }
175
176    @Test
177    public void changeTheSame2() {
178        mBatching.onChanged(3, 2, null);
179        mBatching.onChanged(3, 2, null);
180        mBatching.dispatchLastEvent();
181        verify(mCallback).onChanged(3, 2, null);
182        verifyNoMoreInteractions(mCallback);
183    }
184
185    @Test
186    public void changeBefore() {
187        mBatching.onChanged(3, 2, null);
188        mBatching.onChanged(2, 1, null);
189        mBatching.dispatchLastEvent();
190        verify(mCallback).onChanged(2, 3, null);
191        verifyNoMoreInteractions(mCallback);
192    }
193
194    @Test
195    public void changeBeforeOverlap() {
196        mBatching.onChanged(3, 2, null);
197        mBatching.onChanged(2, 2, null);
198        mBatching.dispatchLastEvent();
199        verify(mCallback).onChanged(2, 3, null);
200        verifyNoMoreInteractions(mCallback);
201    }
202
203    @Test
204    public void changeSimpleWithPayload() {
205        Object payload = new Object();
206        mBatching.onChanged(3, 2, payload);
207        mBatching.dispatchLastEvent();
208        verify(mCallback).onChanged(3, 2, payload);
209    }
210
211    @Test
212    public void changeConsecutiveWithPayload() {
213        Object payload = new Object();
214        mBatching.onChanged(3, 2, payload);
215        mBatching.onChanged(5, 2, payload);
216        mBatching.dispatchLastEvent();
217        verify(mCallback).onChanged(3, 4, payload);
218        verifyNoMoreInteractions(mCallback);
219    }
220
221    @Test
222    public void changeTheSameWithPayload() {
223        Object payload = new Object();
224        mBatching.onChanged(3, 2, payload);
225        mBatching.onChanged(4, 2, payload);
226        mBatching.dispatchLastEvent();
227        verify(mCallback).onChanged(3, 3, payload);
228        verifyNoMoreInteractions(mCallback);
229    }
230
231    @Test
232    public void changeTheSame2WithPayload() {
233        Object payload = new Object();
234        mBatching.onChanged(3, 2, payload);
235        mBatching.onChanged(3, 2, payload);
236        mBatching.dispatchLastEvent();
237        verify(mCallback).onChanged(3, 2, payload);
238        verifyNoMoreInteractions(mCallback);
239    }
240
241    @Test
242    public void changeBeforeWithPayload() {
243        Object payload = new Object();
244        mBatching.onChanged(3, 2, payload);
245        mBatching.onChanged(2, 1, payload);
246        mBatching.dispatchLastEvent();
247        verify(mCallback).onChanged(2, 3, payload);
248        verifyNoMoreInteractions(mCallback);
249    }
250
251    @Test
252    public void changeBeforeOverlapWithPayload() {
253        Object payload = new Object();
254        mBatching.onChanged(3, 2, payload);
255        mBatching.onChanged(2, 2, payload);
256        mBatching.dispatchLastEvent();
257        verify(mCallback).onChanged(2, 3, payload);
258        verifyNoMoreInteractions(mCallback);
259    }
260
261    @Test
262    public void changeWithNewPayload() {
263        Object payload1 = new Object();
264        Object payload2 = new Object();
265        mBatching.onChanged(3, 2, payload1);
266        mBatching.onChanged(2, 2, payload2);
267        mBatching.dispatchLastEvent();
268        verify(mCallback).onChanged(3, 2, payload1);
269        verify(mCallback).onChanged(2, 2, payload2);
270        verifyNoMoreInteractions(mCallback);
271    }
272
273    @Test
274    public void changeWithEmptyPayload() {
275        Object payload = new Object();
276        mBatching.onChanged(3, 2, payload);
277        mBatching.onChanged(2, 2, null);
278        mBatching.dispatchLastEvent();
279        verify(mCallback).onChanged(3, 2, payload);
280        verify(mCallback).onChanged(2, 2, null);
281        verifyNoMoreInteractions(mCallback);
282    }
283
284    @Test
285    public void changeWithEmptyPayload2() {
286        Object payload = new Object();
287        mBatching.onChanged(3, 2, null);
288        mBatching.onChanged(2, 2, payload);
289        mBatching.dispatchLastEvent();
290        verify(mCallback).onChanged(3, 2, null);
291        verify(mCallback).onChanged(2, 2, payload);
292        verifyNoMoreInteractions(mCallback);
293    }
294}
295