| /* |
| * 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.contentpager.content; |
| |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertNotNull; |
| import static org.junit.Assert.assertTrue; |
| |
| import android.database.Cursor; |
| import android.database.MatrixCursor; |
| import android.net.Uri; |
| import android.os.Bundle; |
| |
| import androidx.annotation.Nullable; |
| import androidx.core.util.Pair; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.concurrent.CountDownLatch; |
| import java.util.concurrent.TimeUnit; |
| |
| final class TestQueryCallback implements ContentPager.QueryRunner.Callback { |
| |
| private static final String URI_KEY = "testUri"; |
| private static final String URI_PAGE_ID = "testPageId"; |
| |
| private CollectorLatch<Query> mQueryLatch; |
| private CollectorLatch<Pair<Integer, Cursor>> mReplyLatch; |
| |
| @Override |
| public @Nullable Cursor runQueryInBackground(Query query) { |
| mQueryLatch.accept(query); |
| Bundle extras = new Bundle(); |
| extras.putParcelable(URI_KEY, query.getUri()); |
| extras.putInt(URI_PAGE_ID, query.getId()); |
| MatrixCursor cursor = new MatrixCursor(new String[]{"id"}, 0); |
| cursor.setExtras(extras); |
| return cursor; |
| } |
| |
| @Override |
| public void onQueryFinished(Query query, Cursor cursor) { |
| mReplyLatch.accept(new Pair<>(query.getId(), cursor)); |
| } |
| |
| public void reset(int expectedCount) throws InterruptedException { |
| mQueryLatch = new CollectorLatch<>(expectedCount); |
| mReplyLatch = new CollectorLatch<>(expectedCount); |
| } |
| |
| public void waitFor(int seconds) throws InterruptedException { |
| assertTrue(mQueryLatch.await(seconds, TimeUnit.SECONDS)); |
| assertTrue(mReplyLatch.await(seconds, TimeUnit.SECONDS)); |
| } |
| |
| public void assertQueried(final int expectedPageId) { |
| mQueryLatch.assertHasItem(new Matcher<Query>() { |
| @Override |
| public boolean matches(Query query) { |
| return expectedPageId == query.getId(); |
| } |
| }); |
| } |
| |
| public void assertReceivedContent(Uri expectedUri, final int expectedPageId) { |
| mReplyLatch.assertHasItem(new Matcher<Pair<Integer, Cursor>>() { |
| @Override |
| public boolean matches(Pair<Integer, Cursor> value) { |
| return expectedPageId == value.first; |
| } |
| }); |
| List<Pair<Integer, Cursor>> collected = mReplyLatch.getCollected(); |
| Cursor cursor = null; |
| |
| for (Pair<Integer, Cursor> pair : collected) { |
| if (expectedPageId == pair.first) { |
| cursor = pair.second; |
| } |
| } |
| |
| assertEquals(0, cursor.getCount()); // we don't add any records to our test cursor. |
| Bundle extras = cursor.getExtras(); |
| assertNotNull(extras); |
| assertTrue(extras.containsKey(URI_KEY)); |
| assertEquals(extras.getParcelable(URI_KEY), expectedUri); |
| assertTrue(extras.containsKey(URI_PAGE_ID)); |
| assertEquals(extras.getInt(URI_PAGE_ID), expectedPageId); |
| } |
| |
| private static final class CollectorLatch<T> extends CountDownLatch { |
| |
| private final List<T> mCollected = new ArrayList<>(); |
| |
| CollectorLatch(int count) { |
| super(count); |
| } |
| |
| void accept(@Nullable T value) { |
| onReceived(value); |
| super.countDown(); |
| } |
| |
| @Override |
| public void countDown() { |
| throw new UnsupportedOperationException("Count is incremented by calls to accept."); |
| } |
| |
| void onReceived(@Nullable T value) { |
| mCollected.add(value); |
| } |
| |
| List<T> getCollected() { |
| return mCollected; |
| } |
| |
| public void assertHasItem(Matcher<T> matcher) { |
| T item = null; |
| for (T val : mCollected) { |
| if (matcher.matches(val)) { |
| item = val; |
| } |
| } |
| assertNotNull(item); |
| } |
| |
| public @Nullable T get(int index) { |
| return mCollected.get(index); |
| } |
| } |
| |
| interface Matcher<T> { |
| boolean matches(T value); |
| } |
| } |