1/*
2 * Copyright (C) 2010 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
17package android.test;
18
19import android.content.Loader;
20import android.content.Loader.OnLoadCompleteListener;
21import android.os.AsyncTask;
22import android.os.Handler;
23import android.os.Looper;
24import android.os.Message;
25
26import java.util.concurrent.ArrayBlockingQueue;
27
28/**
29 * A convenience class for testing {@link Loader}s. This test case
30 * provides a simple way to synchronously get the result from a Loader making
31 * it easy to assert that the Loader returns the expected result.
32 */
33public class LoaderTestCase extends AndroidTestCase {
34    static {
35        // Force class loading of AsyncTask on the main thread so that it's handlers are tied to
36        // the main thread and responses from the worker thread get delivered on the main thread.
37        // The tests are run on another thread, allowing them to block waiting on a response from
38        // the code running on the main thread. The main thread can't block since the AysncTask
39        // results come in via the event loop.
40        new AsyncTask<Void, Void, Void>() {
41            @Override
42            protected Void doInBackground(Void... args) {return null;}
43            @Override
44            protected void onPostExecute(Void result) {}
45        };
46    }
47
48    /**
49     * Runs a Loader synchronously and returns the result of the load. The loader will
50     * be started, stopped, and destroyed by this method so it cannot be reused.
51     *
52     * @param loader The loader to run synchronously
53     * @return The result from the loader
54     */
55    public <T> T getLoaderResultSynchronously(final Loader<T> loader) {
56        // The test thread blocks on this queue until the loader puts it's result in
57        final ArrayBlockingQueue<T> queue = new ArrayBlockingQueue<T>(1);
58
59        // This callback runs on the "main" thread and unblocks the test thread
60        // when it puts the result into the blocking queue
61        final OnLoadCompleteListener<T> listener = new OnLoadCompleteListener<T>() {
62            @Override
63            public void onLoadComplete(Loader<T> completedLoader, T data) {
64                // Shut the loader down
65                completedLoader.unregisterListener(this);
66                completedLoader.stopLoading();
67                completedLoader.reset();
68
69                // Store the result, unblocking the test thread
70                queue.add(data);
71            }
72        };
73
74        // This handler runs on the "main" thread of the process since AsyncTask
75        // is documented as needing to run on the main thread and many Loaders use
76        // AsyncTask
77        final Handler mainThreadHandler = new Handler(Looper.getMainLooper()) {
78            @Override
79            public void handleMessage(Message msg) {
80                loader.registerListener(0, listener);
81                loader.startLoading();
82            }
83        };
84
85        // Ask the main thread to start the loading process
86        mainThreadHandler.sendEmptyMessage(0);
87
88        // Block on the queue waiting for the result of the load to be inserted
89        T result;
90        while (true) {
91            try {
92                result = queue.take();
93                break;
94            } catch (InterruptedException e) {
95                throw new RuntimeException("waiting thread interrupted", e);
96            }
97        }
98
99        return result;
100    }
101}
102