java單元測試之如何實現異步接口的測試案例

測試是軟件發布的重要環節，單元測試在實際開發中是一種常用的測試方法，java單元測試主要用junit，最新是junit5，本人開發一般用junit4。因為單元測試能夠在軟件模塊組合之前盡快發現問題，所以實際開發中投入產出比很高。實際使用難免會遇到異步操作的接口測試，最常用的情景是別人家的SDK封裝了異步處理，需要用測試用例來驗證SDK的流程，順便測試參數的處理情況。由於異步testcase的會在調用后立即返回，異步線程執行完之前test線程已經結束了，無法驗證測試最終結果。我們可以通過同步鎖方法把異步接口轉換為同步處理流程。
一、什么是單元測試？
單元測試是對軟件最小實現單元進行的一種測試，例如C語言的函數，C++的類，java的類等。java有一套單元測試框架junit，Android中有AndroidTestCase等等。我們可以用junit對java函數，類，模塊接口進行測試。

二、java單元測試教程
對於單元測試的教程網上有好多，這里就不再重復闡述了。
eclipse單元測試
http://tonl.iteye.com/blog/1948869
gradle構建junit單元測試教程
http://www.jianshu.com/p/e4e99b62a203

三、如何處理異步類型的單元測試

1. 能夠獲取Thread句柄的異步類型

對於 有java thread句柄的測試類型，我們使用使用 Thread.join函數等待線程執行完畢。

    @Test
    public void testExplicitThread() {
        System.out.println("testExplicitThread");
        Thread thread = new Thread() {
            @Override
            public void run() {
                System.out.println("thread start.");
                try {
                    for (int i = 0; i < 5; i++) {
                        System.out.println("progress: " + i);
                        sleep(1000);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println("thread finish.");
                }
            }
        };
        thread.start();
        try {
            thread.join(); // 等待線程執行完畢
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("testExplicitThread exit");
    }

測試用例輸出：
testExplicitThread
thread start.
progress: 0
progress: 1
progress: 2
progress: 3
progress: 4
thread finish.
testExplicitThread exit

 

2. 沒有thread句柄的異步單元測試
因為沒有thread句柄，所以無法使用 join 函數。只能手動操作同步鎖對異步接口進行同步
Object.wait 當前線程進入等待狀態，直到其他線程調用 notify 或者 notifyAll 函數喚醒。
具體實現如下：

    /**
     * 回調接口
     */
    interface Callback {
        void onStart();
        void onProgress(int progress);
        void onFinish();
    }
 
    /**
     * 異步方法
     */
    static class AsyncDemo {
        private int len = 0;
        private Callback callback = null;
        public AsyncDemo(int len, Callback cb) {
            this.len = len;
            this.callback = cb;
        }
 
        public void doJob() {
            new Thread() {
                @Override
                public void run() {
                    if (null != callback) {
                        callback.onStart();
                    }
                    try {
                        for (int i = 0; i < len; i++) {
                            if (null != callback) {
                                callback.onProgress(i);
                            }
                            sleep(1000);
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        if (null != callback) {
                            callback.onFinish();
                        }
                    }
                }
            }.start();
        }
    }
 
    private Object mLock = new Object(); // 同步鎖
    private int mCount = 0; // 加解鎖條件
 
    @Test
    public void testBlindCallback() {
        System.out.println("testBlindCallback");
        Callback cb = new Callback() {
 
            public void onStart() {
                System.out.println("onStart");
            }
 
            public void onProgress(int progress) {
                System.out.println("onProgress: " + progress);
            }
 
            public void onFinish() {
                System.out.println("onFinish");
                synchronized (mLock) {
                    mCount = 0;
                    mLock.notifyAll(); // 回調執行完畢，喚醒主線程
                }
            }
        };
        System.out.println("before AsyncDemo doJob");
        AsyncDemo demo = new AsyncDemo(5, cb);
        demo.doJob();
        synchronized (mLock) {
            mCount = 1;  // 設置鎖條件
            while (mCount > 0) {
                try {
                mLock.wait(); // 等待喚醒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println("after AsyncDemo doJob");
    }

測試輸出結果:
testBlindCallback
before AsyncDemo doJob
onStart
onProgress: 0
onProgress: 1
onProgress: 2
onProgress: 3
onProgress: 4
onFinish
after AsyncDemo doJob

處理方法就是在測試線程執行異步接口后進入wait，等待回調退出接口(onFinish)喚醒test線程。

 

原文地址：https://blog.csdn.net/sweettool/article/details/75948237