使用 Android 测试框架进行 Android AsyncTask 测试

我有一个非常简单的 AsyncTask 实现示例，在使用 Android JUnit 框架进行测试时遇到了问题。

当我在正常应用程序中实例化和执行它时，它工作得很好。 然而，当它从任何 Android 测试框架类(如 < em > AndroidTestCase 、 < em > ActivityUnitTestCase 、 < em > ActivityInstrumentationTestCase2 等)执行时，它的行为很奇怪:

  • 它正确地执行 doInBackground()方法
  • 但是它不调用任何通知方法(onPostExecute()、 onProgressUpdate()等)——只是默默地忽略它们，而不显示任何错误。

这是一个非常简单的 AsyncTask 示例:

package kroz.andcookbook.threads.asynctask;


import android.os.AsyncTask;
import android.util.Log;
import android.widget.ProgressBar;
import android.widget.Toast;


public class AsyncTaskDemo extends AsyncTask<Integer, Integer, String> {


AsyncTaskDemoActivity _parentActivity;
int _counter;
int _maxCount;


public AsyncTaskDemo(AsyncTaskDemoActivity asyncTaskDemoActivity) {
_parentActivity = asyncTaskDemoActivity;
}


@Override
protected void onPreExecute() {
super.onPreExecute();
_parentActivity._progressBar.setVisibility(ProgressBar.VISIBLE);
_parentActivity._progressBar.invalidate();
}


@Override
protected String doInBackground(Integer... params) {
_maxCount = params[0];
for (_counter = 0; _counter <= _maxCount; _counter++) {
try {
Thread.sleep(1000);
publishProgress(_counter);
} catch (InterruptedException e) {
// Ignore
}
}
}


@Override
protected void onProgressUpdate(Integer... values) {
super.onProgressUpdate(values);
int progress = values[0];
String progressStr = "Counting " + progress + " out of " + _maxCount;
_parentActivity._textView.setText(progressStr);
_parentActivity._textView.invalidate();
}


@Override
protected void onPostExecute(String result) {
super.onPostExecute(result);
_parentActivity._progressBar.setVisibility(ProgressBar.INVISIBLE);
_parentActivity._progressBar.invalidate();
}


@Override
protected void onCancelled() {
super.onCancelled();
_parentActivity._textView.setText("Request to cancel AsyncTask");
}


}

这是一个测试用例，在这里 AsyncTaskDemoActivity是一个非常简单的活动，提供 UI 在模式中测试 AsyncTask:

package kroz.andcookbook.test.threads.asynctask;
import java.util.concurrent.ExecutionException;
import kroz.andcookbook.R;
import kroz.andcookbook.threads.asynctask.AsyncTaskDemo;
import kroz.andcookbook.threads.asynctask.AsyncTaskDemoActivity;
import android.content.Intent;
import android.test.ActivityUnitTestCase;
import android.widget.Button;


public class AsyncTaskDemoTest2 extends ActivityUnitTestCase<AsyncTaskDemoActivity> {
AsyncTaskDemo _atask;
private Intent _startIntent;


public AsyncTaskDemoTest2() {
super(AsyncTaskDemoActivity.class);
}


protected void setUp() throws Exception {
super.setUp();
_startIntent = new Intent(Intent.ACTION_MAIN);
}


protected void tearDown() throws Exception {
super.tearDown();
}


public final void testExecute() {
startActivity(_startIntent, null, null);
Button btnStart = (Button) getActivity().findViewById(R.id.Button01);
btnStart.performClick();
assertNotNull(getActivity());
}


}

除了 AsyncTask 在 Android 测试框架内执行时不调用它的通知方法这一事实之外，所有这些代码都运行得很好。有什么想法吗？

61757 次浏览
小开

The way to deal with this is to run any code that invokes an AsyncTask in runTestOnUiThread():

public final void testExecute() {
startActivity(_startIntent, null, null);
runTestOnUiThread(new Runnable() {
public void run() {
Button btnStart = (Button) getActivity().findViewById(R.id.Button01);
btnStart.performClick();
}
});
assertNotNull(getActivity());
// To wait for the AsyncTask to complete, you can safely call get() from the test thread
getActivity()._myAsyncTask.get();
assertTrue(asyncTaskRanCorrectly());
}

By default junit runs tests in a separate thread than the main application UI. AsyncTask's documentation says that the task instance and the call to execute() must be on the main UI thread; this is because AsyncTask depends on the main thread's Looper and MessageQueue for its internal handler to work properly.

NOTE:

I previously recommended using @UiThreadTest as a decorator on the test method to force the test to run on the main thread, but this isn't quite right for testing an AsyncTask because while your test method is running on the main thread no messages are processed on the main MessageQueue — including the messages the AsyncTask sends about its progress, causing your test to hang.

小开
最佳答案

I met a similar problem while implementing some unit-test. I had to test some service which worked with Executors, and I needed to have my service callbacks sync-ed with the test methods from my ApplicationTestCase classes. Usually the test method itself finished before the callback would be accessed, so the data sent via the callbacks would not be tested. Tried applying the @UiThreadTest bust still didn't work.

I found the following method, which worked, and I still use it. I simply use CountDownLatch signal objects to implement the wait-notify (you can use synchronized(lock){... lock.notify();}, however this results in ugly code) mechanism.

public void testSomething(){
final CountDownLatch signal = new CountDownLatch(1);
Service.doSomething(new Callback() {


@Override
public void onResponse(){
// test response data
// assertEquals(..
// assertTrue(..
// etc
signal.countDown();// notify the count down latch
}


});
signal.await();// wait for callback
}
小开

I found a lot of close answers but none of them put all the parts together correctly. So this is one correct implementation when using an android.os.AsyncTask in your JUnit tests cases.

 /**
* This demonstrates how to test AsyncTasks in android JUnit. Below I used
* an in line implementation of a asyncTask, but in real life you would want
* to replace that with some task in your application.
* @throws Throwable
*/
public void testSomeAsynTask () throws Throwable {
// create  a signal to let us know when our task is done.
final CountDownLatch signal = new CountDownLatch(1);


/* Just create an in line implementation of an asynctask. Note this
* would normally not be done, and is just here for completeness.
* You would just use the task you want to unit test in your project.
*/
final AsyncTask<String, Void, String> myTask = new AsyncTask<String, Void, String>() {


@Override
protected String doInBackground(String... arg0) {
//Do something meaningful.
return "something happened!";
}


@Override
protected void onPostExecute(String result) {
super.onPostExecute(result);


/* This is the key, normally you would use some type of listener
* to notify your activity that the async call was finished.
*
* In your test method you would subscribe to that and signal
* from there instead.
*/
signal.countDown();
}
};


// Execute the async task on the UI thread! THIS IS KEY!
runTestOnUiThread(new Runnable() {


@Override
public void run() {
myTask.execute("Do something");
}
});


/* The testing thread will wait here until the UI thread releases it
* above with the countDown() or 30 seconds passes and it times out.
*/
signal.await(30, TimeUnit.SECONDS);


// The task is done, and now you can assert some things!
assertTrue("Happiness", true);
}
小开

If you don't mind executing the AsyncTask in the caller thread (should be fine in case of Unit testing), you can use an Executor in the current thread as described in https://stackoverflow.com/a/6583868/1266123

public class CurrentThreadExecutor implements Executor {
public void execute(Runnable r) {
r.run();
}
}

And then you run your AsyncTask in your unit test like this

myAsyncTask.executeOnExecutor(new CurrentThreadExecutor(), testParam);

This is only working for HoneyComb and higher.

小开

I wrote enough unitests for Android and just want to share how to do that.

First off, here is helper class that responsible to wait and release waiter. Nothing special:

SyncronizeTalker

public class SyncronizeTalker {
public void doWait(long l){
synchronized(this){
try {
this.wait(l);
} catch(InterruptedException e) {
}
}
}






public void doNotify() {
synchronized(this) {
this.notify();
}
}




public void doWait() {
synchronized(this){
try {
this.wait();
} catch(InterruptedException e) {
}
}
}
}

Next, lets create interface with one method that should be called from AsyncTask when work is done. Sure we also want to test our results:

TestTaskItf

public interface TestTaskItf {
public void onDone(ArrayList<Integer> list); // dummy data
}

Next lets create some skeleton of our Task that we gonna test:

public class SomeTask extends AsyncTask<Void, Void, SomeItem> {


private ArrayList<Integer> data = new ArrayList<Integer>();
private WmTestTaskItf mInter = null;// for tests only


public WmBuildGroupsTask(Context context, WmTestTaskItf inter) {
super();
this.mContext = context;
this.mInter = inter;
}


@Override
protected SomeItem doInBackground(Void... params) { /* .... job ... */}


@Override
protected void onPostExecute(SomeItem item) {
// ....


if(this.mInter != null){ // aka test mode
this.mInter.onDone(data); // tell to unitest that we finished
}
}
}

At last - our unitest class:

TestBuildGroupTask

public class TestBuildGroupTask extends AndroidTestCase  implements WmTestTaskItf{




private SyncronizeTalker async = null;


public void setUP() throws Exception{
super.setUp();
}


public void tearDown() throws Exception{
super.tearDown();
}


public void test____Run(){


mContext = getContext();
assertNotNull(mContext);


async = new SyncronizeTalker();


WmTestTaskItf me = this;
SomeTask task = new SomeTask(mContext, me);
task.execute();


async.doWait(); // <--- wait till "async.doNotify()" is called
}


@Override
public void onDone(ArrayList<Integer> list) {
assertNotNull(list);


// run other validations here


async.doNotify(); // release "async.doWait()" (on this step the unitest is finished)
}
}

That's all.

Hope it will help to someone.

小开

Most of those solutions require a lot of code to be written for every test or to change your class structure. Which I find very difficult to use if you have many situations under test or many AsyncTasks on your project.

There is a library which eases the process of testing AsyncTask. Example:

@Test
public void makeGETRequest(){
...
myAsyncTaskInstance.execute(...);
AsyncTaskTest.build(myAsyncTaskInstance).
run(new AsyncTest() {
@Override
public void test(Object result) {
Assert.assertEquals(200, (Integer)result);
}
});
}
}

Basically, it runs your AsyncTask and test the result it returns after the postComplete() has been called.

小开

This can be used if you want to test the result from the doInBackground method. Override the onPostExecute method and perform the tests there. To wait for the AsyncTask to complete use CountDownLatch. The latch.await() waits till the countdown runs from 1 (which is set during initialization) to 0 (which is done by the countdown() method).

@RunWith(AndroidJUnit4.class)
public class EndpointsAsyncTaskTest {


Context context;


@Test
public void testVerifyJoke() throws InterruptedException {
assertTrue(true);
final CountDownLatch latch = new CountDownLatch(1);
context = InstrumentationRegistry.getContext();
EndpointsAsyncTask testTask = new EndpointsAsyncTask() {
@Override
protected void onPostExecute(String result) {
assertNotNull(result);
if (result != null){
assertTrue(result.length() > 0);
latch.countDown();
}
}
};
testTask.execute(context);
latch.await();
}
小开

How about using join?

fun myTest() = runBlocking {
CoroutineScope(Dispatchers.IO).launch {
// test something here
}.join()
}
小开

Use this simple solution

runBlocking{
//Your code here
}

提交答案