Android AsyncTask testing with Android Test Framework

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);}

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.