Android单元测试

Android提供了上面的多个测试类，可以允许我们对于单个方法、Activity、Service、Application等多个对象进行测试，单元测试可以很方便的让我们对代码进行测试，并且方便对重构后的代码进行检查。本篇将简要的讲解如何对Android中的对象进行测试。

 

一、准备工作

首先在manifest.xml中添加权限和相关配置代码。

在Application外添加：

    <uses-permission android:name="android.permission.RUN_INSTRUMENTATION" />

    

    <instrumentation  

        android:name="android.test.InstrumentationTestRunner"  

        android:targetPackage="com.kale.androidtest" />  

com.kale.androidtest是包名，意思是被测类所在的包名。

在Application中添加：

 <uses-library android:name="android.test.runner" />

配置文件代码一览：

<?xml version="1.0" encoding="utf-8"?>

<manifest xmlns:android="http://schemas.android.com/apk/res/android"

    package="com.kale.androidtest"

    android:versionCode="1"

    android:versionName="1.0" >



    <uses-permission android:name="android.permission.RUN_INSTRUMENTATION" />

    

    <instrumentation  

        android:name="android.test.InstrumentationTestRunner"  

        android:targetPackage="com.kale.androidtest" />  

    

    <uses-sdk

        android:minSdkVersion="8"

        android:targetSdkVersion="21" />



    <application

        android:name="com.kale.androidtest.MyApplication"

        android:allowBackup="true"

        android:icon="@drawable/ic_launcher"

        android:label="@string/app_name"

        android:theme="@style/AppTheme" >

        

        <uses-library android:name="android.test.runner" />  

        

        <activity

            android:name=".MyActivity"

            android:label="@string/app_name" >

            <intent-filter>

                <action android:name="android.intent.action.MAIN" />



                <category android:name="android.intent.category.LAUNCHER" />

            </intent-filter>

        </activity>

        <service android:name="com.kale.androidtest.MyService"/>

    </application>



</manifest>

 

注意：下面写的测试的方法一定要是public的，不然会报错！

 

二、测试与Android运行环境无关的方法

2.1 InstrumentationTestCase

当你要测试与Android环境无关的方法时，推荐继承InstrumentationTestCase来进行测试。比如下面的比大小的方法就很适合做这样的测试。

    public static int getMax(int a, int b) {

        return a >= b ? a : b;

    }

得到版本号的代码因为涉及到了Context所以和android运行的环境有关，我们必须要传入一个上下文（context）对象，这时继承InstrumentationTestCase就没有办法进行测试了。

    /** 取得当前应用的版本号

     * @param context

     * @return

     */

    public static String getVersionName(Context context) {

        try {

            PackageInfo manager = context.getPackageManager().getPackageInfo(context.getPackageName(), 0);

            return manager.versionName;

        } catch (NameNotFoundException e) {

            return "Unknown";

        }

    }

那么是不是用它就不能对activity这样的东西进行测试了呢？也不是，我们仍旧可以用它来测试Activity，前题是要通过代码初始化对象，但因为它的子类可以针对Activity进行完善的测试，所以我们一般不用它来做测试activity的工作。第二节中，先给出了一个简单的demo，然后给出用它测试activity的demo。

 

2.2 举例

测试的目标类——MyUtils：

package com.kale.androidtest;



import android.content.Context;

import android.content.pm.PackageInfo;

import android.content.pm.PackageManager.NameNotFoundException;



public class MyUtils {



    public static int getMax(int a, int b) {

        return a >= b ? a : b;

    }

}

测试类——MySimpleTest：

package com.kale.androidtest.test;

import com.kale.androidtest.MyUtils;

import android.test.InstrumentationTestCase;





public class MySimpleTest extends InstrumentationTestCase  {

    public void testGetMax(){

        int max = MyUtils.getMax(1, 3);

        assertEquals(3, max);

    }

}

 

附：测试Activity

activity的代码就不贴了，里面有个editText，这里的测试也是简单的例子，表示它可以用来测试activity，例子没有任何实际意义。

package com.kale.androidtest.test;



import android.content.Intent;

import android.os.SystemClock;

import android.test.InstrumentationTestCase;

import android.widget.EditText;



import com.kale.androidtest.MyActivity;



/**

 * @author:Jack Tony

 * @description  :

 * @web: http://www.oschina.net/question/54100_27061

 * @date  :2015年2月19日

 */

public class MySampleTest2 extends InstrumentationTestCase {

    MyActivity mActivity;

    EditText mEditText;



    @Override

    protected void setUp() throws Exception {

        // 用intent启动一个activity

        Intent intent = new Intent();

        intent.setClassName("com.kale.androidtest", MyActivity.class.getName());

        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

        mActivity = (MyActivity) getInstrumentation().startActivitySync(intent);

    }



    /**

     * @description 测试是否初始化完成

     *

     */

    public void testInit() {

        mEditText = mActivity.getEditText();

        assertNotNull(mActivity);

        assertNotNull(mEditText);

    }



    /**

     * @description 测试得到activity中editText中的文字

     *

     */

    public void testGetText() {

        mEditText = mActivity.getEditText();

        String text = mEditText.getText().toString();

        assertEquals("", text);

    }



    /**

     * @description 测试设置文字的方法

     *

     */

    public void testSetText() {

        mEditText = mActivity.getEditText();

        // 在主线程中设置文字

        getInstrumentation().runOnMainSync(new Runnable() {



            @Override

            public void run() {

                mEditText.setText("kale");

            }

        });

        // 暂停1500ms

        SystemClock.sleep(1000);

        assertEquals("kale", mEditText.getText().toString());

    }



    /**

     * 垃圾清理与资源回收

     * 

     * @see android.test.InstrumentationTestCase#tearDown()

     */

    @Override

    protected void tearDown() {

        mActivity.finish();

        try {

            super.tearDown();

        } catch (Exception e) {

            e.printStackTrace();

        }

    }



}

 

三、测试Application

3.1 ApplicationTestCase

首先我们来看看如何测试一个application，application是全局的一个对象，android提供了一个ApplicationTestCase来测试application。继承这个类后可以调用它自身的方法来构造和初始化一个application，得到的这个application就是我们要测试的application，接着我们就能测试它的公有方法了。这里注意，测试的代码和application的代码运行在不同的线程中，所以如果涉及到必须主线程才能进行的操作，比如更新UI等，就需要把代码传递到主线程中进行测试了。

 

3.2 待测试的Application

package com.kale.androidtest;



import android.app.Application;



public class MyApplication extends Application{



    @Override

    public void onCreate() {

        // TODO 自动生成的方法存根

        super.onCreate();

    }

    

    public String getTestString() {

        return "kale";

    }

}

 

3.3 测试代码

测试的代码中有两个重要的方法：createApplication()和getApplication()，通过建立一个application的方法来初始化application，通过得到application的方法来获得要测试的application。

注意：测试类的构造方法，必须是无参数的

    /*

     * 注意：构造函数不能这么写，否则会找不到类

     * @web :http://www.educity.cn/wenda/164209.html

     * 

     * public MyApplicationTest(Class<MyApplication> applicationClass) {

     *     super(applicationClass); 

     * }

     */



    // 调用父类构造函数，且构造函中传递的参数为被测试的类

    public MyApplicationTest() {

        super(MyApplication.class);

    }

 

在测试的类中我们初始化了application，之后测试了application中的一个获取字符串的方法，代码如下：

package com.kale.androidtest.test;



import android.test.ApplicationTestCase;



import com.kale.androidtest.MyApplication;



/**

 * @author:Jack Tony

 * @description  :

 * @web: http://blog.csdn.net/stevenhu_223/article/details/8298858

 * @date  :2015年2月19日

 */

public class MyApplicationTest extends ApplicationTestCase<MyApplication> {



    private MyApplication application;



    /*

     * 注意：构造函数不能这么写，否则会找不到类

     * @web :http://www.educity.cn/wenda/164209.html

     * 

     * public MyApplicationTest(Class<MyApplication> applicationClass) {

     *     super(applicationClass); 

     * }

     */



    // 调用父类构造函数，且构造函中传递的参数为被测试的类

    public MyApplicationTest() {

        super(MyApplication.class);

    }



    /* 

     * 初始化application

     * @throws Exception

     */

    @Override

    protected void setUp() throws Exception {

        super.setUp();

        // 获取application之前必须调用的方法

        createApplication();

        // 获取待测试的FxAndroidApplication

        application = getApplication();

    }



    public void testGetString() {

        String realStr = application.getTestString();

        assertEquals("kale", realStr);

    }

}

 

四、测试Activity

4.1 要测试的activity

activity的布局文件很简单，有textview，edittext，button组成，相互独立，看效果就知道了。

布局文件的代码：

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:tools="http://schemas.android.com/tools"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    tools:context="${relativePackage}.${activityClass}" >



    <TextView

        android:id="@+id/test_textView"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:layout_centerHorizontal="true"

        android:layout_centerVertical="true"

        android:text="@string/hello_world" />



    <Button

        android:id="@+id/test_button"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:layout_alignParentBottom="true"

        android:layout_centerHorizontal="true"

        android:layout_marginBottom="90dp"

        android:text="Button" />



    <EditText

        android:id="@+id/test_editText"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:layout_above="@+id/test_textView"

        android:layout_centerHorizontal="true"

        android:layout_marginBottom="79dp"

        android:ems="10" >



        <requestFocus />

    </EditText>



</RelativeLayout>

View Code

 

Activity代码

activity在onCreat()中初始化了控件，给button添加了一个监听器，button按下后设置textview的文字。

package com.kale.androidtest;

public class MyActivity extends Activity {



    private TextView testTv;

    private EditText testEt;

    

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

        

        initView();

    }



    private void initView() {

        testEt = (EditText)findViewById(R.id.test_editText);

        testTv = (TextView)findViewById(R.id.test_textView);

        Button testBtn = (Button)findViewById(R.id.test_button);

        testBtn.setOnClickListener(new OnClickListener() {

            

            @Override

            public void onClick(View v) {

                testTv.setText("kale");

            }

        });

    }

    

    /**

     * @description 得到textview中的text

     *

     * @return

     */

    public String getText() {

        return testTv.getText().toString();

    }

    

    /**

     * @description 不想修改本例中的editText的可见范围，但有需要在测试时得到这个控件，所以就get一下

     *

     * @return

     */

    public EditText getEditText() {

        return testEt;

    }

    

    /**

     * @description 本例中的button仅仅用了一次，仅仅在initView()方法中出现

     * 这里为了测试它的点击事件，所以重新find了这个button

     *

     * @return

     */

    public Button getButton() {

        return (Button)findViewById(R.id.test_button);

    } 

    

}

 

4.2 测试activity的代码

测试activity需要继承ActivityInstrumentationTestCase2这个类，ActivityInstrumentationTestCase已经被废弃了，所以不用管它。这个类中提供了创建activity的方法，也提供了得到activity的方法，发送按键事件的方法，当然还有些别的方法。需要注意的是，类的构造函数必须是无参的，当传递按键前我们要屏蔽activity的touch事件，我个人建议不要去测试发送按键的事件，因为发送按键和当前输入法有很大关系，而且一般情况下我们完全没必要去测试用户输入不同数据的情况，直接用setText方法就好了。在测试任何view的方法前，我们都要让其获得焦点，然后给它一个按下的事件，这样我们就模拟了操作。

下面是测试类的代码，详细的解释都在注释里面了。

package com.kale.androidtest.test;



import android.app.Instrumentation;

import android.test.ActivityInstrumentationTestCase2;

import android.view.KeyEvent;



import com.kale.androidtest.MyActivity;



public class MyActivityTest extends ActivityInstrumentationTestCase2<MyActivity> {



    private Instrumentation mInstrumentation;

    private MyActivity mActivity;



    public MyActivityTest() {

        super(MyActivity.class);

    }



    @Override

    protected void setUp() throws Exception {

        super.setUp();

        

        /**这个程序中需要输入用户信息和密码，也就是说需要发送key事件， 

         * 所以，必须在调用getActivity之前，调用下面的方法来关闭 

         * touch模式，否则key事件会被忽略 

         */  

        //关闭touch模式  

        setActivityInitialTouchMode(false);  

        

        mInstrumentation = getInstrumentation();

        // 获取被测试的activity

        mActivity = getActivity();

    }



    /**

     * @description 该测试用例实现在测试其他用例之前，看edittext是否为空

     *

     */

    public void testPreConditions() {

        assertNotNull(mActivity.getEditText());

    }



    /**

     * @description 简单测试textview初始的字符串

     *

     */

    public void testGetText() {

        assertEquals("Hello world!", mActivity.getText());

    }



    /**

     * @description 测试button的点击事件，看看点击后textview的值有没有改变

     *

     */

    public void testClick() {

        // 开新线程，并通过该线程在实现在UI线程上执行操作，这里是在主线程中的操作

        mInstrumentation.runOnMainSync(new Runnable() {



            @Override

            public void run() {

                // 得到焦点

                mActivity.getButton().requestFocus();

                // 模拟点击事件

                mActivity.getButton().performClick();

            }

        });

        assertEquals("kale", mActivity.getText());

    }



    /**

     * 该方法实现在登录界面上输入相关的登录信息。由于UI组件的 

     * 相关处理（如此处的请求聚焦）需要在UI线程上实现， 

     * 所以需调用Activity的runOnUiThread方法实现。 

     */  

    public void testInput()  

    {  

        // 在UI线程中进行操作，让editText获取焦点

        mActivity.runOnUiThread(new Runnable()   

        {  

              

            @Override  

            public void run()   

            {  

                mActivity.getEditText().requestFocus();  

                mActivity.getEditText().performClick();  

            }  

        });  

        

        /*

         * 由于测试用例在单独的线程上执行，所以此处需要同步application， 

         * 调用waitForIdleSync等待测试线程和UI线程同步，才能进行输入操作。 

         * waitForIdleSync和sendKeys不允许在UI线程里运行 

         */ mInstrumentation.waitForIdleSync(); //调用sendKeys方法，输入字符传。这里输入的是TEST123

        sendKeys(KeyEvent.KEYCODE_SHIFT_LEFT,KeyEvent.KEYCODE_T, KeyEvent.KEYCODE_E,  

                KeyEvent.KEYCODE_S, KeyEvent.KEYCODE_S,  

                KeyEvent.KEYCODE_T, KeyEvent.KEYCODE_1,  

                KeyEvent.KEYCODE_2, KeyEvent.KEYCODE_3);  

          

       assertEquals("test123", mActivity.getEditText().toString());

    }  

}

 

4.3 ActivityUnitTestCase

ActivityUnitTestCase也是activity的单元测试类，而且在理论上说它才是真正的activity单元测试。运行它的测试类后不会产生一个activity的界面，它会用底层来做处理，正因为如此，它里面不能有数据存储和交互依赖关系。个人了解后发现用它仅仅能测试下按键事件，或者是得到启动当前activity的intent、code等，还可以得到activity传递的code。调用下面的方法时会抛出异常信息，不应该去使用。

createPendingResult(int, Intent, int)  

startActivityIfNeeded(Intent, int)  

startActivityFromChild(Activity, Intent, int)  

startNextMatchingActivity(Intent)  

getCallingActivity()  

getCallingPackage()  

createPendingResult(int, Intent, int)  

getTaskId()  

isTaskRoot()  

moveTaskToBack(boolean)  

下面的方法可以调用，但一般不起任何作用，你可以使用getStartedActivityIntent()和getStartedActivityRequest() 来检查参数值。

startActivity(Intent)

startActivityForResult(Intent, int)

下面的方法也可以调用，一般也无效果，可以使用isFinishCalled() 和getFinishedActivityRequest检查传入的参数。

finish()

finishFromChild(Activity)

finishActivity(int)

 

我个人认为当你测试activity的intent或者传递的code可以用这个类，否则直接用ActivityInstrumentationTestCase2就好了，如果想要继续了解ActivityUnitTestCase，请参考：

http://blog.csdn.net/mapdigit/article/details/7589430

http://myeyeofjava.iteye.com/blog/1972435

 

五、测试Service

本段文字参考自：http://blog.csdn.net/yan8024/article/details/6271715

　　由于Service是在后台运行的，所以测试Service不能用instrumentation框架，继承ServiceTestCase的测试类可以对service进行针对性测试。ServiceTestcase不会初始化测试环境直到你调用ServiceTestCase.startService()或者ServiceTestCase.bindService. 这样的话，你就可以在Service启动之前可以设置测试环境，创建你需要模拟的对象等等。比如你可以配置service的context和application对象。

setApplication()方法和setContext(Context)方法允许你在Service启动之前设置模拟的Context 和模拟的Application.关于这些模拟的对象。

需要注意的是ServiceTestCase .bindService() 方法和Service.bindService()方法的参数不同的。ServiceTestCase.bindService() 方法只提供了以个intent对象。返回值方面ServiceTestCase.bindService()方法返回的是一个IBinder对象的子类， 而Service.bindService ()返回的是布尔值。

ServiceTestCase 默认的执行testAndroidTestCaseSetupProperly()方法。用于验证该测试类是否在跑其他测试用例之前成功地设置了上下文。

 

例子：

待测service

public class MyService extends Service{



    @Override

    public IBinder onBind(Intent intent) {

        // TODO 自动生成的方法存根

        return null;

    }

    

    public int sum(int a, int b) {

        return a + b;

    }



}

 

测试代码：

package com.kale.androidtest.test;



import android.app.Service;

import android.content.Intent;

import android.os.IBinder;

import android.test.ServiceTestCase;

import android.test.suitebuilder.annotation.MediumTest;



import com.kale.androidtest.MyService;



/**

 * @author:Jack Tony

 * @description  :

 * 

 * ServiceTestCase 默认的执行testAndroidTestCaseSetupProperly()方法。用于验证该测试类是否在跑其他测试用例之前成功地设置了上下文。

 * 

 * @date  :2015年2月18日

 */

public class MyServiceTest extends ServiceTestCase<MyService> {



    private MyService mService;

    

    public MyServiceTest() {

        super(MyService.class);

    }



    @Override

    protected void setUp() throws Exception {

        super.setUp();

        getSystemContext();// A normal system context.

        // Sets the application that is used during the test. If you do not call this method, a new MockApplication object is used.

        setApplication(getApplication());

        startService(new Intent(getContext(), MyService.class));

        // 启动后才能得到一个service对象，如果测试时出现空指针异常，很可能是这里没有进行初始化。以防万一你可以在测试方法第一句用getService得到service对象

        mService = getService();

    }    

    

    @Override

    protected void setupService() {

        super.setupService();

    }

    

    @Override

    protected void shutdownService() {

        // TODO 自动生成的方法存根

        super.shutdownService();

    }

    

    @Override

    protected void tearDown() throws Exception {

        // TODO 自动生成的方法存根

        super.tearDown();

    }

    

    public void testPreConditions() {

        assertNotNull(mService);

    }



    public void testSum() {

        //mService = getService();        

        int sum = mService.sum(1, 2);

        assertEquals(3, sum);

    }

}

 

ServiceTestCase  方法说明：
getApplication() 　　返回被测试的Service所用的Application.
getSystemContext()　　返回在setUp()方法中被保存的真的系统Context.
setApplication (Applicaition application)　　 设置测试被测试Service 所用的Application.
setUp() 　　得到当前系统的上下文并存储它。若要重写该方法的话，第一句必须是
super.setUp()　　该方法在每个测试方法被执行前都执行一遍。
setupService()　　生成被测试的Service , 并向其中注入模拟的组件(Appliocation ,Context)。该方法会被StartService(Intent )或者bindService(Intent)自动调用。
shutdownService()　　调用相应的方法停止或者解除Service,然后调用ondestory()，通常该方法会被teardown()方法调用。    
startService(Intent intent)　　启动被测试的Service.如果用这个方法启动一个服务，那么该服务在最后回自动被teardown()方法关掉。
tearDown()　　关闭被测试的服务， 确认在执行下个用例前所有的资源被释放，所以的垃圾被回收。 这个方法在每个方法执行完后调用。重写该方法上的话， 必须将super.tearDown()作为最后一条语句。
                 
              

六、测试异步操作

异步任务可能是在activity中开始的，也可能是在service中开始的，运行环境根据实际情况而定，所以继承的测试类也不同。还得具体问题，具体分析。

6.1 思路

在测试方法中要将线程先wait，然后执行完成后调用notify去操作。如果是执行异步的操作，在测试方法中要将线程先wait，然后执行完成后调用notify去操作，比如：

    private final Integer LOCK = 1;



    public void test() throws Exception {

        // ……异步操作的回掉方法

        synchronized (LOCK) {

            LOCK.notify();

        }

        try {

            synchronized (LOCK) {

                LOCK.wait();

            }

        } catch (InterruptedException e) {

            Assert.assertNotNull(e);

        }

    }

上面的代码我没理解是什么意思，来自文章：http://blog.csdn.net/henry121212/article/details/7837074

 

6.2 例子

这个例子中我测试asyncTask，测试的代码来自stackoverflow，在百度上没有搜到任何有用的信息。下面的代码中我测试了asyncTask执行的结果。要点是重写onPostExecute()方法，在该方法中进行结果的判断，在最后调用countDown()来释放等待锁。代码执行时在UI线程中开启异步任务，然后执行等待命令，在异步任务的最后进行判断结果并停止等待。

    public void testLoginAsync2() 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 MyAsyncTask task = new MyAsyncTask() {

            @Override

            protected void onPostExecute(String result) {

                super.onPostExecute(result);

                assertEquals("kale", result);

                // notify the count down latch

                signal.countDown();



            }

        };



        // Execute the async task on the UI thread!

        runTestOnUiThread(new Runnable() {



            @Override

            public void run() {

                // 执行异步任务

                task.execute();

            }

        });

        signal.await();

        // signal.await(30, TimeUnit.SECONDS);

    }

 

 

源码下载：http://download.csdn.net/detail/shark0017/8451777

 

 

参考自：

http://blog.csdn.net/yan8024/article/details/6271715

http://blog.csdn.net/stevenhu_223/article/details/8298858

http://blog.csdn.net/henry121212/article/details/7837074

http://myeyeofjava.iteye.com/blog/1972435

http://blog.csdn.net/mapdigit/article/details/7589430