1/*
2 * Copyright (C) 2015 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.databinding.testapp;
17
18import android.databinding.ListChangeRegistry;
19import android.databinding.ObservableList;
20import android.databinding.ObservableList.OnListChangedCallback;
21import android.databinding.testapp.databinding.BasicBindingBinding;
22
23public class ListChangeRegistryTest extends BaseDataBinderTest<BasicBindingBinding> {
24
25    private ListChangeRegistry mListChangeRegistry;
26
27    private int mCallCount;
28
29    public ListChangeRegistryTest() {
30        super(BasicBindingBinding.class);
31    }
32
33    @Override
34    protected void setUp() throws Exception {
35        super.setUp();
36        mListChangeRegistry = new ListChangeRegistry();
37        mCallCount = 0;
38    }
39
40    @Override
41    protected void tearDown() throws Exception {
42        super.tearDown();
43        mListChangeRegistry = null;
44    }
45
46    public void testNotifyChangedAll() {
47        OnListChangedCallback listChangedCallback = new OnListChangedCallback() {
48            @Override
49            public void onChanged(ObservableList sender) {
50                mCallCount++;
51            }
52
53            @Override
54            public void onItemRangeChanged(ObservableList sender, int start, int count) {
55                fail("onItemRangeChanged should not be called");
56            }
57
58            @Override
59            public void onItemRangeInserted(ObservableList sender, int start, int count) {
60                fail("onItemRangeInserted should not be called");
61            }
62
63            @Override
64            public void onItemRangeMoved(ObservableList sender, int from, int to, int count) {
65                fail("onItemRangeMoved should not be called");
66            }
67
68            @Override
69            public void onItemRangeRemoved(ObservableList sender, int start, int count) {
70                fail("onItemRangeRemoved should not be called");
71            }
72        };
73
74        mListChangeRegistry.add(listChangedCallback);
75        assertEquals(0, mCallCount);
76        mListChangeRegistry.notifyChanged(null);
77        assertEquals(1, mCallCount);
78    }
79
80    public void testNotifyChanged() {
81        final int expectedStart = 10;
82        final int expectedCount = 3;
83
84        OnListChangedCallback listChangedCallback = new OnListChangedCallback() {
85            @Override
86            public void onChanged(ObservableList sender) {
87                fail("onChanged should not be called");
88            }
89
90            @Override
91            public void onItemRangeChanged(ObservableList sender, int start, int count) {
92                assertEquals(expectedStart, start);
93                assertEquals(expectedCount, count);
94                mCallCount++;
95            }
96
97            @Override
98            public void onItemRangeInserted(ObservableList sender, int start, int count) {
99                fail("onItemRangeInserted should not be called");
100            }
101
102            @Override
103            public void onItemRangeMoved(ObservableList sender, int from, int to, int count) {
104                fail("onItemRangeMoved should not be called");
105            }
106
107            @Override
108            public void onItemRangeRemoved(ObservableList sender, int start, int count) {
109                fail("onItemRangeRemoved should not be called");
110            }
111        };
112
113        mListChangeRegistry.add(listChangedCallback);
114        assertEquals(0, mCallCount);
115        mListChangeRegistry.notifyChanged(null, expectedStart, expectedCount);
116        assertEquals(1, mCallCount);
117    }
118
119    public void testNotifyInserted() {
120        final int expectedStart = 10;
121        final int expectedCount = 3;
122
123        OnListChangedCallback listChangedCallback = new OnListChangedCallback() {
124            @Override
125            public void onChanged(ObservableList sender) {
126                fail("onChanged should not be called");
127            }
128
129            @Override
130            public void onItemRangeChanged(ObservableList sender, int start, int count) {
131                fail("onItemRangeChanged should not be called");
132            }
133
134            @Override
135            public void onItemRangeInserted(ObservableList sender, int start, int count) {
136                assertEquals(expectedStart, start);
137                assertEquals(expectedCount, count);
138                mCallCount++;
139            }
140
141            @Override
142            public void onItemRangeMoved(ObservableList sender, int from, int to, int count) {
143                fail("onItemRangeMoved should not be called");
144            }
145
146            @Override
147            public void onItemRangeRemoved(ObservableList sender, int start, int count) {
148                fail("onItemRangeRemoved should not be called");
149            }
150        };
151
152        mListChangeRegistry.add(listChangedCallback);
153        assertEquals(0, mCallCount);
154        mListChangeRegistry.notifyInserted(null, expectedStart, expectedCount);
155        assertEquals(1, mCallCount);
156    }
157
158    public void testNotifyMoved() {
159        final int expectedFrom = 10;
160        final int expectedTo = 100;
161        final int expectedCount = 3;
162
163        OnListChangedCallback listChangedCallback = new OnListChangedCallback() {
164            @Override
165            public void onChanged(ObservableList sender) {
166                fail("onChanged should not be called");
167            }
168
169            @Override
170            public void onItemRangeChanged(ObservableList sender, int start, int count) {
171                fail("onItemRangeChanged should not be called");
172            }
173
174            @Override
175            public void onItemRangeInserted(ObservableList sender, int start, int count) {
176                fail("onItemRangeInserted should not be called");
177            }
178
179            @Override
180            public void onItemRangeMoved(ObservableList sender, int from, int to, int count) {
181                assertEquals(expectedFrom, from);
182                assertEquals(expectedTo, to);
183                assertEquals(expectedCount, count);
184                mCallCount++;
185            }
186
187            @Override
188            public void onItemRangeRemoved(ObservableList sender, int start, int count) {
189                fail("onItemRangeRemoved should not be called");
190            }
191        };
192
193        mListChangeRegistry.add(listChangedCallback);
194        assertEquals(0, mCallCount);
195        mListChangeRegistry.notifyMoved(null, expectedFrom, expectedTo, expectedCount);
196        assertEquals(1, mCallCount);
197    }
198
199    public void testNotifyRemoved() {
200        final int expectedStart = 10;
201        final int expectedCount = 3;
202
203        OnListChangedCallback listChangedCallback = new OnListChangedCallback() {
204            @Override
205            public void onChanged(ObservableList sender) {
206                fail("onChanged should not be called");
207            }
208
209            @Override
210            public void onItemRangeChanged(ObservableList sender, int start, int count) {
211                fail("onItemRangeChanged should not be called");
212            }
213
214            @Override
215            public void onItemRangeInserted(ObservableList sender, int start, int count) {
216                fail("onItemRangeInserted should not be called");
217            }
218
219            @Override
220            public void onItemRangeMoved(ObservableList sender, int from, int to, int count) {
221                fail("onItemRangeMoved should not be called");
222            }
223
224            @Override
225            public void onItemRangeRemoved(ObservableList sender, int start, int count) {
226                assertEquals(expectedStart, start);
227                assertEquals(expectedCount, count);
228                mCallCount++;
229            }
230        };
231
232        mListChangeRegistry.add(listChangedCallback);
233        assertEquals(0, mCallCount);
234        mListChangeRegistry.notifyRemoved(null, expectedStart, expectedCount);
235        assertEquals(1, mCallCount);
236    }
237}
238