[go: nahoru, domu]
Google Git
Sign in
android / platform / frameworks / support / 792ed30b1e6c4056e121d6b2b9a8bee4f5529828 / . / paging / common / src / test / java / android / arch / paging / ItemKeyedDataSourceTest.kt
blob: dd4dcaa05c6a2fdaf0bd214e05a05b1998ea9786 [file] [log] [blame]
Chris Craike1178ed2017-09-29 17:50:00 -0700[diff] [blame]1/*
2 * Copyright (C) 2017 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 */
16
Chris Craikef346ae2017-08-28 17:42:07 -0700[diff] [blame]17package android.arch.paging
Chris Craik2e9d5132017-08-24 18:10:23 -0700[diff] [blame]18
19import org.junit.Assert.assertEquals
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]20import org.junit.Assert.assertNotNull
Chris Craik2e9d5132017-08-24 18:10:23 -0700[diff] [blame]21import org.junit.Assert.assertTrue
Chris Craikf174a1c2017-11-28 11:11:32 -0800[diff] [blame]22import org.junit.Assert.fail
Chris Craik2e9d5132017-08-24 18:10:23 -0700[diff] [blame]23import org.junit.Test
24import org.junit.runner.RunWith
25import org.junit.runners.JUnit4
Chris Craike1178ed2017-09-29 17:50:00 -0700[diff] [blame]26import org.mockito.ArgumentCaptor
Chris Craik5dc2fd42017-10-30 10:47:38 -0700[diff] [blame]27import org.mockito.ArgumentMatchers.anyInt
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]28import org.mockito.Mockito.mock
29import org.mockito.Mockito.verify
30import org.mockito.Mockito.verifyNoMoreInteractions
Chris Craik2e9d5132017-08-24 18:10:23 -0700[diff] [blame]31
32@RunWith(JUnit4::class)
Chris Craikb632de52017-11-30 16:09:04 -0800[diff] [blame]33class ItemKeyedDataSourceTest {
Chris Craik2e9d5132017-08-24 18:10:23 -0700[diff] [blame]34
35 // ----- STANDARD -----
36
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]37 private fun loadInitial(dataSource: ItemDataSource, key: Key?, initialLoadSize: Int,
Chris Craik5dc2fd42017-10-30 10:47:38 -0700[diff] [blame]38 enablePlaceholders: Boolean): PageResult<Item> {
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]39 @Suppress("UNCHECKED_CAST")
Chris Craik5dc2fd42017-10-30 10:47:38 -0700[diff] [blame]40 val receiver = mock(PageResult.Receiver::class.java) as PageResult.Receiver<Item>
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]41 @Suppress("UNCHECKED_CAST")
42 val captor = ArgumentCaptor.forClass(PageResult::class.java)
Chris Craik5dc2fd42017-10-30 10:47:38 -0700[diff] [blame]43 as ArgumentCaptor<PageResult<Item>>
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]44
Chris Craik694588d2017-11-28 16:19:46 -0800[diff] [blame]45 dataSource.dispatchLoadInitial(key, initialLoadSize,
Chris Craikf174a1c2017-11-28 11:11:32 -0800[diff] [blame]46 /* ignored pageSize */ 10, enablePlaceholders, FailExecutor(), receiver)
Chris Craik5dc2fd42017-10-30 10:47:38 -0700[diff] [blame]47
48 verify(receiver).onPageResult(anyInt(), captor.capture())
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]49 verifyNoMoreInteractions(receiver)
50 assertNotNull(captor.value)
51 return captor.value
52 }
53
Chris Craik2e9d5132017-08-24 18:10:23 -0700[diff] [blame]54 @Test
Chris Craikfd4fa4a2017-08-31 14:08:37 -0700[diff] [blame]55 fun loadInitial() {
56 val dataSource = ItemDataSource()
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]57 val result = loadInitial(dataSource, dataSource.getKey(ITEMS_BY_NAME_ID[49]), 10, true)
Chris Craikfd4fa4a2017-08-31 14:08:37 -0700[diff] [blame]58
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]59 assertEquals(45, result.leadingNulls)
Chris Craik5dc2fd42017-10-30 10:47:38 -0700[diff] [blame]60 assertEquals(ITEMS_BY_NAME_ID.subList(45, 55), result.page)
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]61 assertEquals(45, result.trailingNulls)
Chris Craikfd4fa4a2017-08-31 14:08:37 -0700[diff] [blame]62 }
63
64 @Test
65 fun loadInitial_keyMatchesSingleItem() {
66 val dataSource = ItemDataSource(items = ITEMS_BY_NAME_ID.subList(0, 1))
67
68 // this is tricky, since load after and load before with the passed key will fail
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]69 val result = loadInitial(dataSource, dataSource.getKey(ITEMS_BY_NAME_ID[0]), 20, true)
Chris Craikfd4fa4a2017-08-31 14:08:37 -0700[diff] [blame]70
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]71 assertEquals(0, result.leadingNulls)
Chris Craik5dc2fd42017-10-30 10:47:38 -0700[diff] [blame]72 assertEquals(ITEMS_BY_NAME_ID.subList(0, 1), result.page)
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]73 assertEquals(0, result.trailingNulls)
Chris Craikfd4fa4a2017-08-31 14:08:37 -0700[diff] [blame]74 }
75
76 @Test
77 fun loadInitial_keyMatchesLastItem() {
78 val dataSource = ItemDataSource()
79
80 // tricky, because load after key is empty, so another load before and load after required
81 val key = dataSource.getKey(ITEMS_BY_NAME_ID.last())
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]82 val result = loadInitial(dataSource, key, 20, true)
Chris Craikfd4fa4a2017-08-31 14:08:37 -0700[diff] [blame]83
Chris Craik5dc2fd42017-10-30 10:47:38 -0700[diff] [blame]84 assertEquals(90, result.leadingNulls)
85 assertEquals(ITEMS_BY_NAME_ID.subList(90, 100), result.page)
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]86 assertEquals(0, result.trailingNulls)
Chris Craikfd4fa4a2017-08-31 14:08:37 -0700[diff] [blame]87 }
88
89 @Test
90 fun loadInitial_nullKey() {
Chris Craik2e9d5132017-08-24 18:10:23 -0700[diff] [blame]91 val dataSource = ItemDataSource()
92
Chris Craik694588d2017-11-28 16:19:46 -0800[diff] [blame]93 // dispatchLoadInitial(null, count) == dispatchLoadInitial(count)
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]94 val result = loadInitial(dataSource, null, 10, true)
Chris Craik2e9d5132017-08-24 18:10:23 -0700[diff] [blame]95
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]96 assertEquals(0, result.leadingNulls)
Chris Craik5dc2fd42017-10-30 10:47:38 -0700[diff] [blame]97 assertEquals(ITEMS_BY_NAME_ID.subList(0, 10), result.page)
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]98 assertEquals(90, result.trailingNulls)
Chris Craik2e9d5132017-08-24 18:10:23 -0700[diff] [blame]99 }
100
101 @Test
Chris Craikfd4fa4a2017-08-31 14:08:37 -0700[diff] [blame]102 fun loadInitial_keyPastEndOfList() {
Chris Craik2e9d5132017-08-24 18:10:23 -0700[diff] [blame]103 val dataSource = ItemDataSource()
104
105 // if key is past entire data set, should return last items in data set
106 val key = Key("fz", 0)
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]107 val result = loadInitial(dataSource, key, 10, true)
Chris Craik2e9d5132017-08-24 18:10:23 -0700[diff] [blame]108
Chris Craikfd4fa4a2017-08-31 14:08:37 -0700[diff] [blame]109 // NOTE: ideally we'd load 10 items here, but it adds complexity and unpredictability to
110 // do: load after was empty, so pass full size to load before, since this can incur larger
111 // loads than requested (see keyMatchesLastItem test)
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]112 assertEquals(95, result.leadingNulls)
Chris Craik5dc2fd42017-10-30 10:47:38 -0700[diff] [blame]113 assertEquals(ITEMS_BY_NAME_ID.subList(95, 100), result.page)
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]114 assertEquals(0, result.trailingNulls)
Chris Craik2e9d5132017-08-24 18:10:23 -0700[diff] [blame]115 }
116
117 // ----- UNCOUNTED -----
118
119 @Test
Chris Craikfd4fa4a2017-08-31 14:08:37 -0700[diff] [blame]120 fun loadInitial_disablePlaceholders() {
121 val dataSource = ItemDataSource()
122
Chris Craik694588d2017-11-28 16:19:46 -0800[diff] [blame]123 // dispatchLoadInitial(key, count) == null padding, loadAfter(key, count), null padding
Chris Craikfd4fa4a2017-08-31 14:08:37 -0700[diff] [blame]124 val key = dataSource.getKey(ITEMS_BY_NAME_ID[49])
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]125 val result = loadInitial(dataSource, key, 10, false)
Chris Craikfd4fa4a2017-08-31 14:08:37 -0700[diff] [blame]126
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]127 assertEquals(0, result.leadingNulls)
Chris Craik5dc2fd42017-10-30 10:47:38 -0700[diff] [blame]128 assertEquals(ITEMS_BY_NAME_ID.subList(45, 55), result.page)
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]129 assertEquals(0, result.trailingNulls)
Chris Craikfd4fa4a2017-08-31 14:08:37 -0700[diff] [blame]130 }
131
132 @Test
133 fun loadInitial_uncounted() {
134 val dataSource = ItemDataSource(counted = false)
135
Chris Craik694588d2017-11-28 16:19:46 -0800[diff] [blame]136 // dispatchLoadInitial(key, count) == null padding, loadAfter(key, count), null padding
Chris Craikfd4fa4a2017-08-31 14:08:37 -0700[diff] [blame]137 val key = dataSource.getKey(ITEMS_BY_NAME_ID[49])
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]138 val result = loadInitial(dataSource, key, 10, true)
Chris Craikfd4fa4a2017-08-31 14:08:37 -0700[diff] [blame]139
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]140 assertEquals(0, result.leadingNulls)
Chris Craik5dc2fd42017-10-30 10:47:38 -0700[diff] [blame]141 assertEquals(ITEMS_BY_NAME_ID.subList(45, 55), result.page)
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]142 assertEquals(0, result.trailingNulls)
Chris Craikfd4fa4a2017-08-31 14:08:37 -0700[diff] [blame]143 }
144
145 @Test
146 fun loadInitial_nullKey_uncounted() {
Chris Craik2e9d5132017-08-24 18:10:23 -0700[diff] [blame]147 val dataSource = ItemDataSource(counted = false)
148
Chris Craik694588d2017-11-28 16:19:46 -0800[diff] [blame]149 // dispatchLoadInitial(null, count) == dispatchLoadInitial(count)
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]150 val result = loadInitial(dataSource, null, 10, true)
Chris Craik2e9d5132017-08-24 18:10:23 -0700[diff] [blame]151
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]152 assertEquals(0, result.leadingNulls)
Chris Craik5dc2fd42017-10-30 10:47:38 -0700[diff] [blame]153 assertEquals(ITEMS_BY_NAME_ID.subList(0, 10), result.page)
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]154 assertEquals(0, result.trailingNulls)
Chris Craik2e9d5132017-08-24 18:10:23 -0700[diff] [blame]155 }
156
Chris Craik2e9d5132017-08-24 18:10:23 -0700[diff] [blame]157 // ----- EMPTY -----
158
159 @Test
Chris Craikfd4fa4a2017-08-31 14:08:37 -0700[diff] [blame]160 fun loadInitial_empty() {
161 val dataSource = ItemDataSource(items = ArrayList())
162
Chris Craik694588d2017-11-28 16:19:46 -0800[diff] [blame]163 // dispatchLoadInitial(key, count) == null padding, loadAfter(key, count), null padding
Chris Craikfd4fa4a2017-08-31 14:08:37 -0700[diff] [blame]164 val key = dataSource.getKey(ITEMS_BY_NAME_ID[49])
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]165 val result = loadInitial(dataSource, key, 10, true)
Chris Craik2e9d5132017-08-24 18:10:23 -0700[diff] [blame]166
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]167 assertEquals(0, result.leadingNulls)
Chris Craik5dc2fd42017-10-30 10:47:38 -0700[diff] [blame]168 assertTrue(result.page.isEmpty())
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]169 assertEquals(0, result.trailingNulls)
Chris Craik2e9d5132017-08-24 18:10:23 -0700[diff] [blame]170 }
171
172 @Test
Chris Craikfd4fa4a2017-08-31 14:08:37 -0700[diff] [blame]173 fun loadInitial_nullKey_empty() {
174 val dataSource = ItemDataSource(items = ArrayList())
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]175 val result = loadInitial(dataSource, null, 10, true)
Chris Craik2e9d5132017-08-24 18:10:23 -0700[diff] [blame]176
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]177 assertEquals(0, result.leadingNulls)
Chris Craik5dc2fd42017-10-30 10:47:38 -0700[diff] [blame]178 assertTrue(result.page.isEmpty())
Chris Craik771816b2017-10-26 13:02:34 -0700[diff] [blame]179 assertEquals(0, result.trailingNulls)
Chris Craik2e9d5132017-08-24 18:10:23 -0700[diff] [blame]180 }
181
Chris Craike1178ed2017-09-29 17:50:00 -0700[diff] [blame]182 // ----- Other behavior -----
183
184 @Test
185 fun loadBefore() {
186 val dataSource = ItemDataSource()
187 @Suppress("UNCHECKED_CAST")
Chris Craikb632de52017-11-30 16:09:04 -0800[diff] [blame]188 val callback = mock(ItemKeyedDataSource.LoadCallback::class.java)
189 as ItemKeyedDataSource.LoadCallback<Item>
Chris Craike1178ed2017-09-29 17:50:00 -0700[diff] [blame]190
Chris Craik694588d2017-11-28 16:19:46 -0800[diff] [blame]191 dataSource.loadBefore(
Chris Craikb632de52017-11-30 16:09:04 -0800[diff] [blame]192 ItemKeyedDataSource.LoadParams(dataSource.getKey(ITEMS_BY_NAME_ID[5]), 5), callback)
Chris Craike1178ed2017-09-29 17:50:00 -0700[diff] [blame]193
194 @Suppress("UNCHECKED_CAST")
Chris Craik5dc2fd42017-10-30 10:47:38 -0700[diff] [blame]195 val argument = ArgumentCaptor.forClass(List::class.java) as ArgumentCaptor<List<Item>>
196 verify(callback).onResult(argument.capture())
197 verifyNoMoreInteractions(callback)
Chris Craike1178ed2017-09-29 17:50:00 -0700[diff] [blame]198
199 val observed = argument.value
200
Chris Craik5dc2fd42017-10-30 10:47:38 -0700[diff] [blame]201 assertEquals(ITEMS_BY_NAME_ID.subList(0, 5), observed)
Chris Craike1178ed2017-09-29 17:50:00 -0700[diff] [blame]202 }
203
Chris Craik2e9d5132017-08-24 18:10:23 -0700[diff] [blame]204 internal data class Key(val name: String, val id: Int)
205
206 internal data class Item(
207 val name: String, val id: Int, val balance: Double, val address: String)
208
Chris Craik5dc2fd42017-10-30 10:47:38 -0700[diff] [blame]209 internal class ItemDataSource(private val counted: Boolean = true,
210 private val items: List<Item> = ITEMS_BY_NAME_ID)
Chris Craikb632de52017-11-30 16:09:04 -0800[diff] [blame]211 : ItemKeyedDataSource<Key, Item>() {
Chris Craik5dc2fd42017-10-30 10:47:38 -0700[diff] [blame]212
Chris Craik694588d2017-11-28 16:19:46 -0800[diff] [blame]213 override fun loadInitial(
214 params: LoadInitialParams<Key>,
215 callback: LoadInitialCallback<Item>) {
216 val key = params.requestedInitialKey ?: Key("", Integer.MAX_VALUE)
217 val start = Math.max(0, findFirstIndexAfter(key) - params.requestedLoadSize / 2)
218 val endExclusive = Math.min(start + params.requestedLoadSize, items.size)
219
220 if (params.placeholdersEnabled && counted) {
Chris Craik5dc2fd42017-10-30 10:47:38 -0700[diff] [blame]221 callback.onResult(items.subList(start, endExclusive), start, items.size)
222 } else {
223 callback.onResult(items.subList(start, endExclusive))
224 }
225 }
226
Chris Craik694588d2017-11-28 16:19:46 -0800[diff] [blame]227 override fun loadAfter(params: LoadParams<Key>, callback: LoadCallback<Item>) {
228 val start = findFirstIndexAfter(params.key)
229 val endExclusive = Math.min(start + params.requestedLoadSize, items.size)
Chris Craik5dc2fd42017-10-30 10:47:38 -0700[diff] [blame]230
231 callback.onResult(items.subList(start, endExclusive))
232 }
233
Chris Craik694588d2017-11-28 16:19:46 -0800[diff] [blame]234 override fun loadBefore(params: LoadParams<Key>, callback: LoadCallback<Item>) {
235 val firstIndexBefore = findFirstIndexBefore(params.key)
Chris Craik5dc2fd42017-10-30 10:47:38 -0700[diff] [blame]236 val endExclusive = Math.max(0, firstIndexBefore + 1)
Chris Craik694588d2017-11-28 16:19:46 -0800[diff] [blame]237 val start = Math.max(0, firstIndexBefore - params.requestedLoadSize + 1)
Chris Craik5dc2fd42017-10-30 10:47:38 -0700[diff] [blame]238
239 callback.onResult(items.subList(start, endExclusive))
240 }
Chris Craikfd4fa4a2017-08-31 14:08:37 -0700[diff] [blame]241
Chris Craik2e9d5132017-08-24 18:10:23 -0700[diff] [blame]242 override fun getKey(item: Item): Key {
243 return Key(item.name, item.id)
244 }
245
Chris Craik5dc2fd42017-10-30 10:47:38 -0700[diff] [blame]246 private fun findFirstIndexAfter(key: Key): Int {
Chris Craikfd4fa4a2017-08-31 14:08:37 -0700[diff] [blame]247 return items.indices.firstOrNull {
248 KEY_COMPARATOR.compare(key, getKey(items[it])) < 0
249 } ?: items.size
Chris Craik2e9d5132017-08-24 18:10:23 -0700[diff] [blame]250 }
251
Chris Craik5dc2fd42017-10-30 10:47:38 -0700[diff] [blame]252 private fun findFirstIndexBefore(key: Key): Int {
Chris Craikfd4fa4a2017-08-31 14:08:37 -0700[diff] [blame]253 return items.indices.reversed().firstOrNull {
254 KEY_COMPARATOR.compare(key, getKey(items[it])) > 0
Chris Craik2e9d5132017-08-24 18:10:23 -0700[diff] [blame]255 } ?: -1
256 }
Chris Craik2e9d5132017-08-24 18:10:23 -0700[diff] [blame]257 }
258
Chris Craikb632de52017-11-30 16:09:04 -0800[diff] [blame]259 private fun performLoadInitial(
Chris Craik7f66b3c2017-12-08 11:13:26 -0800[diff] [blame]260 invalidateDataSource: Boolean = false,
Chris Craikb632de52017-11-30 16:09:04 -0800[diff] [blame]261 callbackInvoker: (callback: ItemKeyedDataSource.LoadInitialCallback<String>) -> Unit) {
262 val dataSource = object : ItemKeyedDataSource<String, String>() {
Chris Craikf174a1c2017-11-28 11:11:32 -0800[diff] [blame]263 override fun getKey(item: String): String {
264 return ""
265 }
266
267 override fun loadInitial(
Chris Craik694588d2017-11-28 16:19:46 -0800[diff] [blame]268 params: LoadInitialParams<String>,
269 callback: LoadInitialCallback<String>) {
Chris Craik7f66b3c2017-12-08 11:13:26 -0800[diff] [blame]270 if (invalidateDataSource) {
271 // invalidate data source so it's invalid when onResult() called
272 invalidate()
273 }
Chris Craikf174a1c2017-11-28 11:11:32 -0800[diff] [blame]274 callbackInvoker(callback)
275 }
276
Chris Craik694588d2017-11-28 16:19:46 -0800[diff] [blame]277 override fun loadAfter(params: LoadParams<String>, callback: LoadCallback<String>) {
278 fail("loadAfter not expected")
Chris Craikf174a1c2017-11-28 11:11:32 -0800[diff] [blame]279 }
280
Chris Craik694588d2017-11-28 16:19:46 -0800[diff] [blame]281 override fun loadBefore(params: LoadParams<String>, callback: LoadCallback<String>) {
282 fail("loadBefore not expected")
Chris Craikf174a1c2017-11-28 11:11:32 -0800[diff] [blame]283 }
284 }
285
286 ContiguousPagedList<String, String>(
287 dataSource, FailExecutor(), FailExecutor(), null,
288 PagedList.Config.Builder()
289 .setPageSize(10)
290 .build(),
Chris Craike4cede12018-02-23 10:06:39 -0800[diff] [blame]291 "",
292 ContiguousPagedList.LAST_LOAD_UNSPECIFIED)
Chris Craikf174a1c2017-11-28 11:11:32 -0800[diff] [blame]293 }
294
295 @Test
Chris Craikb632de52017-11-30 16:09:04 -0800[diff] [blame]296 fun loadInitialCallbackSuccess() = performLoadInitial {
Chris Craik694588d2017-11-28 16:19:46 -0800[diff] [blame]297 // LoadInitialCallback correct usage
Chris Craikf174a1c2017-11-28 11:11:32 -0800[diff] [blame]298 it.onResult(listOf("a", "b"), 0, 2)
299 }
300
301 @Test
Chris Craikb632de52017-11-30 16:09:04 -0800[diff] [blame]302 fun loadInitialCallbackNotPageSizeMultiple() = performLoadInitial {
Chris Craik694588d2017-11-28 16:19:46 -0800[diff] [blame]303 // Keyed LoadInitialCallback *can* accept result that's not a multiple of page size
Chris Craikf174a1c2017-11-28 11:11:32 -0800[diff] [blame]304 val elevenLetterList = List(11) { "" + 'a' + it }
305 it.onResult(elevenLetterList, 0, 12)
306 }
307
308 @Test(expected = IllegalArgumentException::class)
Chris Craikb632de52017-11-30 16:09:04 -0800[diff] [blame]309 fun loadInitialCallbackListTooBig() = performLoadInitial {
Chris Craik694588d2017-11-28 16:19:46 -0800[diff] [blame]310 // LoadInitialCallback can't accept pos + list > totalCount
Chris Craikf174a1c2017-11-28 11:11:32 -0800[diff] [blame]311 it.onResult(listOf("a", "b", "c"), 0, 2)
312 }
313
314 @Test(expected = IllegalArgumentException::class)
Chris Craikb632de52017-11-30 16:09:04 -0800[diff] [blame]315 fun loadInitialCallbackPositionTooLarge() = performLoadInitial {
Chris Craik694588d2017-11-28 16:19:46 -0800[diff] [blame]316 // LoadInitialCallback can't accept pos + list > totalCount
Chris Craikf174a1c2017-11-28 11:11:32 -0800[diff] [blame]317 it.onResult(listOf("a", "b"), 1, 2)
318 }
319
320 @Test(expected = IllegalArgumentException::class)
Chris Craikb632de52017-11-30 16:09:04 -0800[diff] [blame]321 fun loadInitialCallbackPositionNegative() = performLoadInitial {
Chris Craik694588d2017-11-28 16:19:46 -0800[diff] [blame]322 // LoadInitialCallback can't accept negative position
Chris Craikf174a1c2017-11-28 11:11:32 -0800[diff] [blame]323 it.onResult(listOf("a", "b", "c"), -1, 2)
324 }
325
326 @Test(expected = IllegalArgumentException::class)
Chris Craikb632de52017-11-30 16:09:04 -0800[diff] [blame]327 fun loadInitialCallbackEmptyCannotHavePlaceholders() = performLoadInitial {
Chris Craik694588d2017-11-28 16:19:46 -0800[diff] [blame]328 // LoadInitialCallback can't accept empty result unless data set is empty
Chris Craikf174a1c2017-11-28 11:11:32 -0800[diff] [blame]329 it.onResult(emptyList(), 0, 2)
330 }
331
Chris Craik7f66b3c2017-12-08 11:13:26 -0800[diff] [blame]332 @Test
333 fun initialLoadCallbackInvalidThreeArg() = performLoadInitial(invalidateDataSource = true) {
334 // LoadInitialCallback doesn't throw on invalid args if DataSource is invalid
335 it.onResult(emptyList(), 0, 1)
336 }
337
Chris Craik792ed302018-03-06 16:28:38 -0800[diff] [blame^]338 private abstract class WrapperDataSource<K, A, B>(private val source: ItemKeyedDataSource<K, A>)
339 : ItemKeyedDataSource<K, B>() {
340 private val invalidatedCallback = DataSource.InvalidatedCallback {
341 invalidate()
342 removeCallback()
343 }
344
345 init {
346 source.addInvalidatedCallback(invalidatedCallback)
347 }
348
349 private fun removeCallback() {
350 removeInvalidatedCallback(invalidatedCallback)
351 }
352
353 override fun loadInitial(params: LoadInitialParams<K>, callback: LoadInitialCallback<B>) {
354 source.loadInitial(params, object : LoadInitialCallback<A>() {
355 override fun onResult(data: List<A>, position: Int, totalCount: Int) {
356 callback.onResult(convert(data), position, totalCount)
357 }
358
359 override fun onResult(data: MutableList<A>) {
360 callback.onResult(convert(data))
361 }
362 })
363 }
364
365 override fun loadAfter(params: LoadParams<K>, callback: LoadCallback<B>) {
366 source.loadAfter(params, object : LoadCallback<A>() {
367 override fun onResult(data: MutableList<A>) {
368 callback.onResult(convert(data))
369 }
370 })
371 }
372
373 override fun loadBefore(params: LoadParams<K>, callback: LoadCallback<B>) {
374 source.loadBefore(params, object : LoadCallback<A>() {
375 override fun onResult(data: MutableList<A>) {
376 callback.onResult(convert(data))
377 }
378 })
379 }
380
381 protected abstract fun convert(source: List<A>): List<B>
382 }
383
384 private data class DecoratedItem(val item: Item)
385
386 private class DecoratedWrapperDataSource(private val source: ItemKeyedDataSource<Key, Item>)
387 : WrapperDataSource<Key, Item, DecoratedItem>(source) {
388 override fun convert(source: List<Item>): List<DecoratedItem> {
389 return source.map { DecoratedItem(it) }
390 }
391
392 override fun getKey(item: DecoratedItem): Key {
393 return source.getKey(item.item)
394 }
395 }
396
397 @Test
398 fun simpleWrappedDataSource() {
399 // verify that it's possible to wrap an ItemKeyedDataSource, and add info to its data
400
401 val orig = ItemDataSource(items = ITEMS_BY_NAME_ID)
402 val wrapper = DecoratedWrapperDataSource(orig)
403
404 // load initial
405 @Suppress("UNCHECKED_CAST")
406 val loadInitialCallback = mock(ItemKeyedDataSource.LoadInitialCallback::class.java)
407 as ItemKeyedDataSource.LoadInitialCallback<DecoratedItem>
408 val initKey = orig.getKey(ITEMS_BY_NAME_ID.first())
409 wrapper.loadInitial(ItemKeyedDataSource.LoadInitialParams(initKey, 10, false),
410 loadInitialCallback)
411 verify(loadInitialCallback).onResult(
412 ITEMS_BY_NAME_ID.subList(0, 10).map { DecoratedItem(it) })
413 verifyNoMoreInteractions(loadInitialCallback)
414
415 @Suppress("UNCHECKED_CAST")
416 val loadCallback = mock(ItemKeyedDataSource.LoadCallback::class.java)
417 as ItemKeyedDataSource.LoadCallback<DecoratedItem>
418 val key = orig.getKey(ITEMS_BY_NAME_ID[20])
419 // load after
420 wrapper.loadAfter(ItemKeyedDataSource.LoadParams(key, 10), loadCallback)
421 verify(loadCallback).onResult(ITEMS_BY_NAME_ID.subList(21, 31).map { DecoratedItem(it) })
422 verifyNoMoreInteractions(loadCallback)
423
424 // load before
425 wrapper.loadBefore(ItemKeyedDataSource.LoadParams(key, 10), loadCallback)
426 verify(loadCallback).onResult(ITEMS_BY_NAME_ID.subList(10, 20).map { DecoratedItem(it) })
427 verifyNoMoreInteractions(loadCallback)
428 }
429
Chris Craik2e9d5132017-08-24 18:10:23 -0700[diff] [blame]430 companion object {
Aurimas Liutikas6f1f5562017-11-17 10:05:57 -0800[diff] [blame]431 private val ITEM_COMPARATOR = compareBy<Item>({ it.name }).thenByDescending({ it.id })
432 private val KEY_COMPARATOR = compareBy<Key>({ it.name }).thenByDescending({ it.id })
Chris Craik2e9d5132017-08-24 18:10:23 -0700[diff] [blame]433
Chris Craikac809222017-10-17 15:40:21 -0700[diff] [blame]434 private val ITEMS_BY_NAME_ID = List(100) {
435 val names = Array(10) { "f" + ('a' + it) }
Chris Craik2e9d5132017-08-24 18:10:23 -0700[diff] [blame]436 Item(names[it % 10],
Aurimas Liutikas6f1f5562017-11-17 10:05:57 -0800[diff] [blame]437 it,
438 Math.random() * 1000,
439 (Math.random() * 200).toInt().toString() + " fake st.")
Chris Craikac809222017-10-17 15:40:21 -0700[diff] [blame]440 }.sortedWith(ITEM_COMPARATOR)
Chris Craik2e9d5132017-08-24 18:10:23 -0700[diff] [blame]441 }
442}