异步无处不在，特别是网络请求，必须在子线程中执行。异步一般用来处理比较耗时的操作，除了网络请求外还有数据库操作、文件读写等等。一个典型的异步方法如下：

public class DataManager {

    public interface OnDataListener {

        public void onSuccess(List<String> dataList);

        public void onFail();
    }

    public void loadData(final OnDataListener listener) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);

                    List<String> dataList = new ArrayList<String>();
                    dataList.add("11");
                    dataList.add("22");
                    dataList.add("33");

                    if(listener != null) {
                        listener.onSuccess(dataList);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    if(listener != null) {
                        listener.onFail();
                    }
                }
            }
        }).start();
    }
}

上面代码里开启了一个异步线程，等待1秒之后在回调函数里成功返回数据。通常情况下，我们针对loadData()方法写如下单元测试：

    @Test
    public void testGetData() {
        final List<String> list = new ArrayList<String>();
        DataManager dataManager = new DataManager();
        dataManager.loadData(new DataManager.OnDataListener() {
            @Override
            public void onSuccess(List<String> dataList) {
                if(dataList != null) {
                    list.addAll(dataList);
                }
            }

            @Override
            public void onFail() {
            }
        });
        Assert.assertEquals(3, list.size());
    }

执行这段测试代码，你会发现永远都不会通过。因为loadData()是一个异步方法，当我们在执行Assert.assertEquals()方法时，loadData()异步方法里的代码还没执行，所以list.size()返回永远是0。
这只是一个最简单的例子，我们代码里肯定充斥着各种各样的异步代码，那么对于这些异步该怎么测试呢？

要解决这个问题，主要有2个思路：一是等待异步操作完成，然后在进行assert断言；二是将异步操作变成同步操作。

1. 等待异步完成：使用CountDownLatch

前面的例子，等待异步完成实际上就是等待callback函数执行完毕，使用CountDownLatch可以达到这个目标，不熟悉该类的可自行搜索学习。修改原来的测试用例代码如下：

    @Test
    public void testGetData() {
        final List<String> list = new ArrayList<String>();
        DataManager dataManager = new DataManager();
        final CountDownLatch latch = new CountDownLatch(1);
        dataManager.loadData(new DataManager.OnDataListener() {
            @Override
            public void onSuccess(List<String> dataList) {
                if(dataList != null) {
                    list.addAll(dataList);
                }
                //callback方法执行完毕侯，唤醒测试方法执行线程
                latch.countDown();
            }

            @Override
            public void onFail() {
            }
        });
        try {
            //测试方法线程会在这里暂停, 直到loadData()方法执行完毕, 才会被唤醒继续执行
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Assert.assertEquals(3, list.size());
    }

CountDownLatch适用场景：
1.方法里有callback函数调用的异步方法，如前面所介绍的这个例子。
2.RxJava实现的异步，RxJava里的subscribe方法实际上与callback类似，所以同样适用。

CountDownLatch同样有它的局限性，就是必须能够在测试代码里调用countDown()方法，这就要求被测的异步方法必须有类似callback的调用，也就是说异步方法的调用结果必须是通过callback调用通知出去的，如果我们采用其他通知方式，例如EventBus、Broadcast将结果通知出去，CountDownLatch则不能实现这种异步方法的测试了。

实际上，可以使用synchronized的wait/notify机制实现同样的功能。我们将测试代码稍微改改如下：

    @Test
    public void testGetData() {
        final List<String> list = new ArrayList<String>();
        DataManager dataManager = new DataManager();
        final Object lock = new Object();
        dataManager.loadData(new DataManager.OnDataListener() {
            @Override
            public void onSuccess(List<String> dataList) {
                if(dataList != null) {
                    list.addAll(dataList);
                }
                synchronized (lock) {
                    lock.notify();
                }
            }

            @Override
            public void onFail() {
            }
        });
        try {
            synchronized (lock) {
                lock.wait();
            }

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Assert.assertEquals(3, list.size());
    }

CountDownLatch与wait/notify相比而言，语义更简单，使用起来方便很多。

2. 将异步变成同步

下面介绍几种不同的异步实现。

2.1 使用RxJava

RxJava现在已经被广泛运用于Android开发中了，特别是结合了Rotrofit框架之后，简直是异步网络请求的神器。RxJava发展到现在最新的版本是RxJava2，相比RxJava1做了很多改进，这里我们直接采用RxJava2来讲述，RxJava1与之类似。对于前面的异步请求，我们采用RxJava2来改造之后，代码如下：

    public Observable<List<String>> loadData() {
        return Observable.create(new ObservableOnSubscribe<List<String>>() {
            @Override
            public void subscribe(ObservableEmitter<List<String>> e) throws Exception {
                Thread.sleep(1000);
                List<String> dataList = new ArrayList<String>();
                dataList.add("11");
                dataList.add("22");
                dataList.add("33");
                e.onNext(dataList);
                e.onComplete();
            }
        }).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread());
    }

RxJava2都是通过subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread())来实现异步的，这段代码表示所有操作都在IO线程里执行，最后的结果是在主线程实现回调的。这里要将异步变成同步的关键是改变subscribeOn()的执行线程，有2种方式可以实现：

• 将subscribeOn()以及observeOn()的参数通过依赖注入的方式注入进来，正常运行时跑在IO线程中，测试时跑在测试方法运行所在的线程中，这样就实现了异步变同步。
• 使用RxJava2提供的RxJavaPlugins工具类，让Schedulers.io()返回当前测试方法运行所在的线程。

    @Before
    public void setup() {
        RxJavaPlugins.reset();
        //设置Schedulers.io()返回的线程
        RxJavaPlugins.setIoSchedulerHandler(new Function<Scheduler, Scheduler>() {
            @Override
            public Scheduler apply(Scheduler scheduler) throws Exception {
                //返回当前的工作线程，这样测试方法与之都是运行在同一个线程了，从而实现异步变同步。
                return Schedulers.trampoline();
            }
        });
    }

    @Test
    public void testGetDataAsync() {    
        final List<String> list = new ArrayList<String>();
        DataManager dataManager = new DataManager();
        dataManager.loadData().subscribe(new Consumer<List<String>>() {
            @Override
            public void accept(List<String> dataList) throws Exception {
                if(dataList != null) {
                    list.addAll(dataList);
                }
            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {

            }
        });
        Assert.assertEquals(3, list.size());
    }

2.2 new Thread()方式做异步操作

如果你的代码里还有直接new Thread()实现异步的方式，唯一的建议是赶紧去使用其他的异步框架吧。

2.3 使用Executor

如果我们使用Executor来实现异步，可以使用依赖注入的方式，在测试环境中将一个同步的Executor注入进去。实现一个同步的Executor很简单。

    Executor executor = new Executor() {
        @Override
        public void execute(Runnable command) {
            command.run();
        }
    };

2.4 AsyncTask

现在已经不推荐使用AsyncTask了，如果一定要使用，建议使用AsyncTask.executeOnExecutor(Executor exec, Params... params)方法，然后通过依赖注入的方式，在测试环境中将同步的Executor注入进去。

小结

本文主要介绍了针对异步代码进行单元测试的2种方法：一是等待异步完成，二是将异步变成同步。前者需要写很多侵入性代码，通过加锁等机制来实现，并且必须符合callback机制。其他还有很多实现异步的方式，例如IntentService、HandlerThread、Loader等，综合比较下来，使用RxJava2来实现异步是一个不错的方案，它不仅功能强大，并且在单元测试中能毫无侵入性的将异步变成同步，在这里强烈推荐！

系列文章：
Android单元测试（一）：前言
Android单元测试（二）：什么是单元测试
Android单元测试（三）：测试难点及方案选择
Android单元测试（四）：JUnit介绍
Android单元测试（五）：JUnit进阶
Android单元测试（六）：Mockito学习
Android单元测试（七）：Robolectric介绍
Android单元测试（八）：怎样测试异步代码