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 17 package android.test; 18 19 import android.content.Loader; 20 import android.content.Loader.OnLoadCompleteListener; 21 import android.os.AsyncTask; 22 import android.os.Handler; 23 import android.os.Looper; 24 import android.os.Message; 25 26 import 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 */ 33 public 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. AsyncTask()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 */ getLoaderResultSynchronously(final Loader<T> loader)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