Android单元测试

最新推荐文章于 2021-12-05 09:27:49 发布
最新推荐文章于 2021-12-05 09:27:49 发布
阅读量3.5k 收藏 1
点赞数
分类专栏： android日常积累 文章标签： android junit 单元测试 button 测试 java

关键字: camera unit test

android源代码中每个app下中都自带了一个test用例，下面主要介绍下camra单元测试用例

在AndroidManifest.xml中标明了测试用例instrumentation函数入口

Java代码
  1. <?xml version="1.0"  encoding="utf-8" ?>  
  2. <!-- Copyright (C) 2008  The Android Open Source Project  
  3.   
  4.      Licensed under the Apache License, Version 2.0  (the "License" );  
  5.      you may not use this  file except in compliance with the License.  
  6.      You may obtain a copy of the License at  
  7.     
  8.           http://www.apache.org/licenses/LICENSE-2.0   
  9.     
  10.      Unless required by applicable law or agreed to in writing, software  
  11.      distributed under the License is distributed on an "AS IS"  BASIS,  
  12.      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  
  13.      See the License for  the specific language governing permissions and  
  14.      limitations under the License.  
  15. -->  
  16.   
  17. <manifest xmlns:android="http://schemas.android.com/apk/res/android"   
  18.     package ="com.android.camera.tests" >  
  19.   
  20.     <application>  
  21.         <uses-library android:name="android.test.runner"  />  
  22.     </application>  
  23.   
  24.     <instrumentation android:name="CameraLaunchPerformance"   
  25.             android:targetPackage="com.android.camera"   
  26.             android:label="Camera Launch Performance" >  
  27.     </instrumentation>  
  28.       
  29.     <instrumentation android:name="com.android.camera.CameraStressTestRunner"   
  30.              android:targetPackage="com.android.camera"   
  31.              android:label="Camera Stress Test InstrumentationRunner" >  
  32.     </instrumentation>  
  33.   
  34.     <instrumentation android:name="android.test.InstrumentationTestRunner"   
  35.              android:targetPackage="com.android.camera"   
  36.              android:label="Tests for Camera application." />  
  37. </manifest>    
<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 2008 The Android Open Source Project

     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
     You may obtain a copy of the License at
  
          http://www.apache.org/licenses/LICENSE-2.0
  
     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
-->

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.android.camera.tests">

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

    <instrumentation android:name="CameraLaunchPerformance"
            android:targetPackage="com.android.camera"
            android:label="Camera Launch Performance">
    </instrumentation>
    
    <instrumentation android:name="com.android.camera.CameraStressTestRunner"
             android:targetPackage="com.android.camera"
             android:label="Camera Stress Test InstrumentationRunner">
    </instrumentation>

    <instrumentation android:name="android.test.InstrumentationTestRunner"
             android:targetPackage="com.android.camera"
             android:label="Tests for Camera application."/>
</manifest>



camera启动性能测试

Java代码
  1. package  com.android.camera;  
  2.   
  3. import  android.app.Activity;  
  4. import  android.os.Bundle;  
  5. import  android.test.LaunchPerformanceBase;  
  6.   
  7. /**  
  8.  * Instrumentation class for Camera launch performance testing.  
  9.  */   
  10. public  class  CameraLaunchPerformance extends  LaunchPerformanceBase {  
  11.   
  12.     public  static  final  String LOG_TAG = "CameraLaunchPerformance" ;  
  13.   
  14.     public  CameraLaunchPerformance() {  
  15.         super ();  
  16.     }  
  17.   
  18.     @Override   
  19.     public  void  onCreate(Bundle arguments) {  
  20.         super .onCreate(arguments);  
  21.   
  22.         mIntent.setClassName(getTargetContext(), "com.android.camera.Camera" );  
  23.         start();  
  24.     }  
  25.   
  26.     /**  
  27.      * Calls LaunchApp and finish.  
  28.      */   
  29.     @Override   
  30.     public  void  onStart() {  
  31.         super .onStart();  
  32.         LaunchApp();  
  33.         finish(Activity.RESULT_OK, mResults);  
  34.     }  
  35. }   
package com.android.camera;

import android.app.Activity;
import android.os.Bundle;
import android.test.LaunchPerformanceBase;

/**
 * Instrumentation class for Camera launch performance testing.
 */
public class CameraLaunchPerformance extends LaunchPerformanceBase {

    public static final String LOG_TAG = "CameraLaunchPerformance";

    public CameraLaunchPerformance() {
        super();
    }

    @Override
    public void onCreate(Bundle arguments) {
        super.onCreate(arguments);

        mIntent.setClassName(getTargetContext(), "com.android.camera.Camera");
        start();
    }

    /**
     * Calls LaunchApp and finish.
     */
    @Override
    public void onStart() {
        super.onStart();
        LaunchApp();
        finish(Activity.RESULT_OK, mResults);
    }
}



camera拍照压力测试，参数设定为反复拍照100次

Java代码
  1. package  com.android.camera.stress;  
  2.   
  3. import  com.android.camera.Camera;  
  4.   
  5. import  android.app.Instrumentation;  
  6. import  android.test.ActivityInstrumentationTestCase2;  
  7. import  android.test.suitebuilder.annotation.LargeTest;  
  8. import  android.util.Log;  
  9. import  android.view.KeyEvent;  
  10.   
  11. /**  
  12.  * Junit / Instrumentation test case for camera test  
  13.  *  
  14.  * Running the test suite:  
  15.  *  
  16.  * adb shell am instrument /  
  17.  *    -e class com.android.camera.stress.ImageCapture /  
  18.  *    -w com.android.camera.tests/com.android.camera.CameraStressTestRunner  
  19.  *  
  20.  */   
  21.   
  22. public  class  ImageCapture extends  ActivityInstrumentationTestCase2 <Camera> {  
  23.     private  String TAG = "ImageCapture" ;  
  24.     private  static  final  int  TOTAL_NUMBER_OF_IMAGECAPTURE = 100 ;  
  25.     private  static  final  int  TOTAL_NUMBER_OF_VIDEOCAPTURE = 100 ;  
  26.     private  static  final  long  WAIT_FOR_IMAGE_CAPTURE_TO_BE_TAKEN = 1000 ;  
  27.     private  static  final  long  WAIT_FOR_VIDEO_CAPTURE_TO_BE_TAKEN = 50000 ; //50seconds   
  28.     private  static  final  long  WAIT_FOR_PREVIEW = 1000 ; //1 seconds   
  29.   
  30.     public  ImageCapture() {  
  31.         super ("com.android.camera" , Camera.class );  
  32.     }  
  33.   
  34.     @Override   
  35.     protected  void  setUp() throws  Exception {  
  36.         getActivity();  
  37.         super .setUp();  
  38.     }  
  39.   
  40.     @Override   
  41.     protected  void  tearDown() throws  Exception {  
  42.         super .tearDown();  
  43.     }  
  44.   
  45.     @LargeTest   
  46.     public  void  testImageCapture() {  
  47.         Instrumentation inst = getInstrumentation();  
  48.         try  {  
  49.             for  (int  i = 0 ; i < TOTAL_NUMBER_OF_IMAGECAPTURE; i++) {  
  50.                 Thread.sleep(WAIT_FOR_IMAGE_CAPTURE_TO_BE_TAKEN);  
  51.                 inst.sendKeyDownUpSync(KeyEvent.KEYCODE_DPAD_UP);  
  52.                 inst.sendKeyDownUpSync(KeyEvent.KEYCODE_DPAD_CENTER);  
  53.                 Thread.sleep(WAIT_FOR_IMAGE_CAPTURE_TO_BE_TAKEN);  
  54.             }  
  55.         } catch  (Exception e) {  
  56.             Log.v(TAG, e.toString());  
  57.         }  
  58.             assertTrue("testImageCapture" , true );  
  59.     }  
  60.   
  61.     @LargeTest   
  62.     public  void  testVideoCapture() {  
  63.         Instrumentation inst = getInstrumentation();  
  64.         //Switch to the video mode   
  65.         inst.sendKeyDownUpSync(KeyEvent.KEYCODE_MENU);  
  66.         inst.sendKeyDownUpSync(KeyEvent.KEYCODE_DPAD_CENTER);  
  67.         try  {  
  68.             for  (int  i = 0 ; i < TOTAL_NUMBER_OF_VIDEOCAPTURE; i++) {  
  69.                 Thread.sleep(WAIT_FOR_PREVIEW);  
  70.                 inst.sendKeyDownUpSync(KeyEvent.KEYCODE_DPAD_UP);  
  71.                 //record an video   
  72.                 inst.sendKeyDownUpSync(KeyEvent.KEYCODE_DPAD_CENTER);  
  73.                 Thread.sleep(WAIT_FOR_VIDEO_CAPTURE_TO_BE_TAKEN);  
  74.                 inst.sendKeyDownUpSync(KeyEvent.KEYCODE_DPAD_CENTER);  
  75.                 Thread.sleep(WAIT_FOR_PREVIEW);  
  76.                 inst.sendKeyDownUpSync(KeyEvent.KEYCODE_DPAD_CENTER);  
  77.             }  
  78.         } catch  (Exception e) {  
  79.             Log.v(TAG, e.toString());  
  80.         }  
  81.             assertTrue("testVideoCapture" , true );  
  82.     }  
  83.   
  84. }   
package com.android.camera.stress;

import com.android.camera.Camera;

import android.app.Instrumentation;
import android.test.ActivityInstrumentationTestCase2;
import android.test.suitebuilder.annotation.LargeTest;
import android.util.Log;
import android.view.KeyEvent;

/**
 * Junit / Instrumentation test case for camera test
 *
 * Running the test suite:
 *
 * adb shell am instrument /
 *    -e class com.android.camera.stress.ImageCapture /
 *    -w com.android.camera.tests/com.android.camera.CameraStressTestRunner
 *
 */

public class ImageCapture extends ActivityInstrumentationTestCase2 <Camera> {
    private String TAG = "ImageCapture";
    private static final int TOTAL_NUMBER_OF_IMAGECAPTURE = 100;
    private static final int TOTAL_NUMBER_OF_VIDEOCAPTURE = 100;
    private static final long WAIT_FOR_IMAGE_CAPTURE_TO_BE_TAKEN = 1000;
    private static final long WAIT_FOR_VIDEO_CAPTURE_TO_BE_TAKEN = 50000; //50seconds
    private static final long WAIT_FOR_PREVIEW = 1000; //1 seconds

    public ImageCapture() {
        super("com.android.camera", Camera.class);
    }

    @Override
    protected void setUp() throws Exception {
        getActivity();
        super.setUp();
    }

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

    @LargeTest
    public void testImageCapture() {
        Instrumentation inst = getInstrumentation();
        try {
            for (int i = 0; i < TOTAL_NUMBER_OF_IMAGECAPTURE; i++) {
                Thread.sleep(WAIT_FOR_IMAGE_CAPTURE_TO_BE_TAKEN);
                inst.sendKeyDownUpSync(KeyEvent.KEYCODE_DPAD_UP);
                inst.sendKeyDownUpSync(KeyEvent.KEYCODE_DPAD_CENTER);
                Thread.sleep(WAIT_FOR_IMAGE_CAPTURE_TO_BE_TAKEN);
            }
        } catch (Exception e) {
            Log.v(TAG, e.toString());
        }
            assertTrue("testImageCapture", true);
    }

    @LargeTest
    public void testVideoCapture() {
        Instrumentation inst = getInstrumentation();
        //Switch to the video mode
        inst.sendKeyDownUpSync(KeyEvent.KEYCODE_MENU);
        inst.sendKeyDownUpSync(KeyEvent.KEYCODE_DPAD_CENTER);
        try {
            for (int i = 0; i < TOTAL_NUMBER_OF_VIDEOCAPTURE; i++) {
                Thread.sleep(WAIT_FOR_PREVIEW);
                inst.sendKeyDownUpSync(KeyEvent.KEYCODE_DPAD_UP);
                //record an video
                inst.sendKeyDownUpSync(KeyEvent.KEYCODE_DPAD_CENTER);
                Thread.sleep(WAIT_FOR_VIDEO_CAPTURE_TO_BE_TAKEN);
                inst.sendKeyDownUpSync(KeyEvent.KEYCODE_DPAD_CENTER);
                Thread.sleep(WAIT_FOR_PREVIEW);
                inst.sendKeyDownUpSync(KeyEvent.KEYCODE_DPAD_CENTER);
            }
        } catch (Exception e) {
            Log.v(TAG, e.toString());
        }
            assertTrue("testVideoCapture", true);
    }

}



camera拍照视频录制切换测试

Java代码
  1. package  com.android.camera.stress;  
  2.   
  3. import  com.android.camera.VideoCamera;  
  4.   
  5. import  android.app.Instrumentation;  
  6. import  android.test.ActivityInstrumentationTestCase2;  
  7. import  android.test.suitebuilder.annotation.LargeTest;  
  8. import  android.util.Log;  
  9. import  android.view.KeyEvent;  
  10.   
  11. /**  
  12.  * Junit / Instrumentation test case for camera test  
  13.  *  
  14.  * Running the test suite:  
  15.  *  
  16.  * adb shell am instrument /  
  17.  *    -e class com.android.camera.stress.SwitchPreview /  
  18.  *    -w com.android.camera.tests/com.android.camera.CameraStressTestRunner  
  19.  *  
  20.  */   
  21. public  class  SwitchPreview extends  ActivityInstrumentationTestCase2 <VideoCamera>{  
  22.     private  String TAG = "SwitchPreview" ;  
  23.     private  static  final  int  TOTAL_NUMBER_OF_SWITCHING = 200 ;  
  24.     private  static  final  long  WAIT_FOR_PREVIEW = 2000 ;  
  25.   
  26.   
  27.     public  SwitchPreview() {  
  28.         super ("com.android.camera" , VideoCamera.class );  
  29.     }  
  30.   
  31.     @Override   
  32.     protected  void  setUp() throws  Exception {  
  33.         getActivity();  
  34.         super .setUp();  
  35.     }  
  36.   
  37.     @Override   
  38.     protected  void  tearDown() throws  Exception {  
  39.         getActivity().finish();  
  40.         super .tearDown();  
  41.     }  
  42.   
  43.     @LargeTest   
  44.     public  void  testSwitchMode() {  
  45.         //Switching the video and the video recorder mode   
  46.         Instrumentation inst = getInstrumentation();  
  47.         try {  
  48.             for  (int  i=0 ; i< TOTAL_NUMBER_OF_SWITCHING; i++) {  
  49.                 Thread.sleep(WAIT_FOR_PREVIEW);  
  50.                 inst.sendKeyDownUpSync(KeyEvent.KEYCODE_MENU);  
  51.                 inst.sendKeyDownUpSync(KeyEvent.KEYCODE_DPAD_LEFT);  
  52.                 inst.sendKeyDownUpSync(KeyEvent.KEYCODE_DPAD_CENTER);  
  53.                 Thread.sleep(WAIT_FOR_PREVIEW);  
  54.             }  
  55.         } catch  (Exception e){  
  56.             Log.v(TAG, e.toString());  
  57.         }  
  58.             assertTrue("testSwitchMode" ,true );  
  59.     }  
  60. }   
package com.android.camera.stress;

import com.android.camera.VideoCamera;

import android.app.Instrumentation;
import android.test.ActivityInstrumentationTestCase2;
import android.test.suitebuilder.annotation.LargeTest;
import android.util.Log;
import android.view.KeyEvent;

/**
 * Junit / Instrumentation test case for camera test
 *
 * Running the test suite:
 *
 * adb shell am instrument /
 *    -e class com.android.camera.stress.SwitchPreview /
 *    -w com.android.camera.tests/com.android.camera.CameraStressTestRunner
 *
 */
public class SwitchPreview extends ActivityInstrumentationTestCase2 <VideoCamera>{
    private String TAG = "SwitchPreview";
    private static final int TOTAL_NUMBER_OF_SWITCHING = 200;
    private static final long WAIT_FOR_PREVIEW = 2000;


    public SwitchPreview() {
        super("com.android.camera", VideoCamera.class);
    }

    @Override
    protected void setUp() throws Exception {
        getActivity();
        super.setUp();
    }

    @Override
    protected void tearDown() throws Exception {
        getActivity().finish();
        super.tearDown();
    }

    @LargeTest
    public void testSwitchMode() {
        //Switching the video and the video recorder mode
        Instrumentation inst = getInstrumentation();
        try{
            for (int i=0; i< TOTAL_NUMBER_OF_SWITCHING; i++) {
                Thread.sleep(WAIT_FOR_PREVIEW);
                inst.sendKeyDownUpSync(KeyEvent.KEYCODE_MENU);
                inst.sendKeyDownUpSync(KeyEvent.KEYCODE_DPAD_LEFT);
                inst.sendKeyDownUpSync(KeyEvent.KEYCODE_DPAD_CENTER);
                Thread.sleep(WAIT_FOR_PREVIEW);
            }
        } catch (Exception e){
            Log.v(TAG, e.toString());
        }
            assertTrue("testSwitchMode",true);
    }
}





如果想在android里面做单元测试，有两条基本的路子可行。

　　第一， 就是java程序员最为熟悉和常用的JUnit, 但是由于目前android sdk (version 1.1)中只是提供了stubbed methods/classes，没有具体的实现代码，所以如果用JUnit的话，我们需要在运行单元测试时，一定要用JDK来运行，利用java命令来 启动JUnit的某个Runner。如果是用Eclipse的话，可以在Run Configuration里新建一个JUnit。但是一定要记得在Classpath选项卡里将Bootstrap Entries中的Android Library改成JRE，并且添加junit.jar。具体的设置可以参考：http://developer.android.com/guide /appendix/faq/troubleshooting.html#addjunit。而且，更为遗憾的是，这种方法运行的JUnit运行在JDK 之上的，而不是android，所以，只能测试一些和android无关的东西，比如业务逻辑，数据封装，数值计算等等。并不能测试android api。

　　第二， 采用Instrumentation. Android单元测试的主入口是InstrumentationTestRunner。它相当于JUnit当中TestRunner的作用。你可以将 Instrumentation理解为一种没有图形界面的，具有启动能力的，用于监控其他类（用Target Package声明）的工具类。任何想成为Instrumentation的类必须继承android.app.Instrumentation。

　　下面通过一个实例来看一下如何通过Instrumentation来做单元测试。

　　Step 1.首先编写需要测试的activity:

Java代码
  1. import  android.app.Activity;  
  2. import  android.os.Bundle;  
  3.   
  4. public  class  AndroidUT extends  Activity {  
  5.     /** Called when the activity is first created. */   
  6.     @Override   
  7.     public  void  onCreate(Bundle savedInstanceState) {  
  8.         super .onCreate(savedInstanceState);  
  9.         setContentView(R.layout.main);  
  10.     }  
  11.      
  12.     public  int  add(int  a, int  b)  
  13.     {  
  14.         return  a + b;  
  15.     }  
  16. }   
import android.app.Activity;
import android.os.Bundle;

public class AndroidUT extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
   
    public int add(int a, int b)
    {
        return a + b;
    }
}



　　Step 2.

　　接下来编写测试类，其中主要来测试add()方法。我们在当前代码目录下，在新建一个文件夹，命名为test，并在里面新建了包com.android.ut.test。然后往里面新增加一个class.具体如下：

Java代码
  1. import  com.android.ut.AndroidUT;  
  2.   
  3. import  android.test.ActivityInstrumentationTestCase;  
  4.   
  5. public  class  TestApp extends  ActivityInstrumentationTestCase<AndroidUT> {  
  6.      
  7.     public  TestApp()  
  8.     {  
  9.         super ("com.android.ut" , AndroidUT.class );  
  10.     }  
  11.      
  12.     public  void  testSum()  
  13.     {  
  14.         assertEquals(5 , getActivity().add(2 , 3 ));  
  15.     }     
  16. }   
import com.android.ut.AndroidUT;

import android.test.ActivityInstrumentationTestCase;

public class TestApp extends ActivityInstrumentationTestCase<AndroidUT> {
   
    public TestApp()
    {
        super("com.android.ut", AndroidUT.class);
    }
   
    public void testSum()
    {
        assertEquals(5, getActivity().add(2, 3));
    }   
}


　　Step 3.最后一步就是要改一下Manifest文件。

Java代码
  1. <?xml version="1.0"  encoding="utf-8" ?>  
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"   
  3.       package ="com.android.ut"   
  4.       android:versionCode="1"   
  5.       android:versionName="1.0.0" >  
  6.     <application android:icon="@drawable/icon"  android:label="@string/app_name" >  
  7.         <activity android:name=".AndroidUT"   
  8.                   android:label="@string/app_name" >  
  9.             <intent-filter>  
  10.                 <action android:name="android.intent.action.MAIN"  />  
  11.                 <category android:name="android.intent.category.LAUNCHER"  />  
  12.             </intent-filter>  
  13.         </activity>  
  14.     <uses-library android:name="android.test.runner"  />  
  15.     </application>  
  16.     <instrumentation android:targetPackage="com.android.ut"  android:name="android.test.InstrumentationTestRunner"  android:label="Test Unit Tests" ></instrumentation>  
  17. </manifest>   
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="com.android.ut"
      android:versionCode="1"
      android:versionName="1.0.0">
    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <activity android:name=".AndroidUT"
                  android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    <uses-library android:name="android.test.runner" />
    </application>
    <instrumentation android:targetPackage="com.android.ut" android:name="android.test.InstrumentationTestRunner" android:label="Test Unit Tests"></instrumentation>
</manifest>


　　需要注意的是，在这里面我加上了：

　　

Java代码
  1. <uses-library android:name="android.test.runner"  />   
<uses-library android:name="android.test.runner" />



　　以及：

　　

Java代码
  1. <instrumentation android:targetPackage="com.android.ut"  android:name="android.test.InstrumentationTestRunner"  android:label="Test Unit Tests" ></instrumentation>   
<instrumentation android:targetPackage="com.android.ut" android:name="android.test.InstrumentationTestRunner" android:label="Test Unit Tests"></instrumentation>


　　Step 4.运行

　　首先通过模拟器运行一下AndroidUT，然后在命令行终端中运行

Java代码
  1. adb shell am instrument -e class  com.android.ut.test.TestApp -wcom.android.ut/android.test.InstrumentationTestRunner   
　　adb shell am instrument -e class com.android.ut.test.TestApp -wcom.android.ut/android.test.InstrumentationTestRunner



　　这样你就可以看到测试结果了。

Java代码
  1. # am instrument -e class  com.cn.test.TestApp -w com.cn/android.test.InstrumentationTestRunner  
  2.   
  3. com.cn.test.TestApp:..  
  4. Test results for  InstrumentationTestRunner=..  
  5. Time: 2.866   
  6.   
  7. OK (2  tests)   
# am instrument -e class com.cn.test.TestApp -w com.cn/android.test.InstrumentationTestRunner

com.cn.test.TestApp:..
Test results for InstrumentationTestRunner=..
Time: 2.866

OK (2 tests)



后台测试log日志信息

Java代码
  1. D/AndroidRuntime(  941 ): >>>>>>>>>>>>>> AndroidRuntime START <<<<<<<<<<<<<<  
  2. D/AndroidRuntime(  941 ): CheckJNI is ON  
  3. D/AndroidRuntime(  941 ): --- registering native  functions ---  
  4. D/FileBackupHelper_native(  941 ): register_android_backup_FileBackupHelper  
  5. D/ActivityManager(  581 ): Uninstalling process com.cn  
  6. I/ActivityManager(  581 ): Start proc com.cn for  added application com.cn: pid=948  uid=10013  gids={}  
  7. I/TestRunner(  948 ): started: testSum(com.cn.test.TestApp)      //启动add()测试方法   
  8. I/ActivityManager(  581 ): Starting activity: Intent { act=android.intent.action.MAIN flg=0x10000000  cmp=com.cn/.AndroidUT }  
  9. I/ActivityManager(  581 ): Displayed activity com.cn/.AndroidUT: 645  ms (total 645  ms)  
  10. I/TestRunner(  948 ): finished: testSum(com.cn.test.TestApp)  
  11. I/TestRunner(  948 ): passed: testSum(com.cn.test.TestApp)  
  12. I/TestRunner(  948 ): started: testActivityTestCaseSetUpProperly(com.cn.test.TestApp)  
  13. I/ActivityManager(  581 ): Starting activity: Intent { act=android.intent.action.MAIN flg=0x10000000  cmp=com.cn/.AndroidUT }  
  14. I/ActivityManager(  581 ): Displayed activity com.cn/.AndroidUT: 412  ms (total 412  ms)  
  15. I/TestRunner(  948 ): finished: testActivityTestCaseSetUpProperly(com.cn.test.TestApp)  
  16. I/TestRunner(  948 ): passed: testActivityTestCaseSetUpProperly(com.cn.test.TestApp)  
  17. D/ActivityManager(  581 ): Uninstalling process com.cn  
  18. D/ActivityManager(  581 ): Force removing process ProcessRecord{43851fa0 948 :com.cn/10013 } (com.cn/10013 )  
  19. D/AndroidRuntime(  941 ): Shutting down VM   
D/AndroidRuntime(  941): >>>>>>>>>>>>>> AndroidRuntime START <<<<<<<<<<<<<<
D/AndroidRuntime(  941): CheckJNI is ON
D/AndroidRuntime(  941): --- registering native functions ---
D/FileBackupHelper_native(  941): register_android_backup_FileBackupHelper
D/ActivityManager(  581): Uninstalling process com.cn
I/ActivityManager(  581): Start proc com.cn for added application com.cn: pid=948 uid=10013 gids={}
I/TestRunner(  948): started: testSum(com.cn.test.TestApp)      //启动add()测试方法
I/ActivityManager(  581): Starting activity: Intent { act=android.intent.action.MAIN flg=0x10000000 cmp=com.cn/.AndroidUT }
I/ActivityManager(  581): Displayed activity com.cn/.AndroidUT: 645 ms (total 645 ms)
I/TestRunner(  948): finished: testSum(com.cn.test.TestApp)
I/TestRunner(  948): passed: testSum(com.cn.test.TestApp)
I/TestRunner(  948): started: testActivityTestCaseSetUpProperly(com.cn.test.TestApp)
I/ActivityManager(  581): Starting activity: Intent { act=android.intent.action.MAIN flg=0x10000000 cmp=com.cn/.AndroidUT }
I/ActivityManager(  581): Displayed activity com.cn/.AndroidUT: 412 ms (total 412 ms)
I/TestRunner(  948): finished: testActivityTestCaseSetUpProperly(com.cn.test.TestApp)
I/TestRunner(  948): passed: testActivityTestCaseSetUpProperly(com.cn.test.TestApp)
D/ActivityManager(  581): Uninstalling process com.cn
D/ActivityManager(  581): Force removing process ProcessRecord{43851fa0 948:com.cn/10013} (com.cn/10013)
D/AndroidRuntime(  941): Shutting down VM



(二） 转

任何程序的开发都离不开单元测试来保证其健壮和稳定。Android的程序自然也不例外。从Android SDK 0.9开始，就有了比较成熟的测试框架，但是直到目前最新的1.1版本，也没有详细的文档介绍这个内容，只是简单的给了一个Api Demos里的几个单元测试代码。因此，我在这里对此内容做一下梳理和总结： JUnit还能用么？

在Java下做单元测试必然用到JUnit。这里说的JUnit是指从Apache基金会下载的junit.jar里提供的一系列单元测试功能。 这些功能显然是运行在JDK之上的。在Android下已经没有了JDK，自然也无法运行JUnit。但是这并不妨碍我们利用JUnit编写单元测试。只 不过在运行单元测试时，一定要用JDK来运行，利用java命令来启动JUnit的某个Runner。如果是用Eclipse的话，可以在Run Configuration里新建一个JUnit。但是一定要记得在Classpath选项卡里将Bootstrap Entries中的Android Library改成JRE，并且添加junit.jar。


很明显的，这种测试就是正规的Java单元测试，和Android没有任何关系。你无法测试任何关于Android系统中的API，你写的 Activity，人机界面等等。所以，如果你想测试仅仅是一些封装数据的对象，或者是纯粹的数值计算，还是可以用这种方法的。 Android里面的junit.framework包是怎么回事？

很多人看到这个包的时候，第一反应是Android是不是已经完整集成了JUnit。很遗憾这不是事实。如果你按照JUnit的运行方法，却不像上面那样改用JDK，就一定会得到一个异常：

Java代码
  1. #  
  2. # An unexpected error has been detected by Java Runtime Environment:  
  3. #  
  4. # Internal Error (classFileParser.cpp:2924 ), pid=4900 , tid=4476   
  5. #Error: ShouldNotReachHere()  
  6. #  
  7. # Java VM: Java HotSpot(TM) Client VM (10.0 -b19 mixed mode windows-x86)  
  8. # An error report file with more information is saved as:  
  9. # E:/Mydoc/EclipseWorkspace/TestAndroid/hs_err_pid4900.log  
  10. #  
  11. # If you would like to submit a bug report, please visit:  
  12. # http://java.sun.com/webapps/bugreport/crash.jsp   
  13. #   
#
# An unexpected error has been detected by Java Runtime Environment:
#
# Internal Error (classFileParser.cpp:2924), pid=4900, tid=4476
#Error: ShouldNotReachHere()
#
# Java VM: Java HotSpot(TM) Client VM (10.0-b19 mixed mode windows-x86)
# An error report file with more information is saved as:
# E:/Mydoc/EclipseWorkspace/TestAndroid/hs_err_pid4900.log
#
# If you would like to submit a bug report, please visit:
# http://java.sun.com/webapps/bugreport/crash.jsp
#



实际上，TestCase这个类用于在Android担当所有独特的TestCase的基类的作用，它是一个Abstract Class。Android单元测试类继承关系图如下所示：


之所以有那么多XXXTestCase主要是为了简化工作。例如当你想对一个访问数据库的功能进行测试时，首先需要自己启动并初始化数据库。在这 里是类似的，如果你想测试一个Activity，首先要启动它。而ActivityTestCase就会自动帮你做完这些事情。而 ActivityUnitTestCase会更注重测试的独立性，它会让测试与Android底层的联系降到最低。其余的类可以查看相关的Javadoc 来按需挑选。要编写测试，就是找到合适的XXXTestCase作为基类来继承，并且编写自己的测试方法。

很明显的，最简单的编写测试的方法就是继承AndroidTestCase写一个自己的TestCase。然后为自己的一组 TestCase写一个Activity界面，由界面控制TestCase的启动，运行和结果报告。但是，你很快会发现，为何要给测试写一个界面呢？这太 诡异了。这时就需要一种技术，它可以利用命令行（Shell）来启动一组测试，并且通过命令行的形式给出结果。这就是所谓的 Instrumentation。 什么是Instrumentation？

一般在开发Android程序的时候，需要写一个manifest文件，其结构是：

Java代码
  1. <application android:icon="@drawable/icon"  android:label="@string/app_name" >  
  2.   
  3. <activity android:name=".TestApp"  android:label="@string/app_name" >  
  4.   
  5. ……  
  6.   
  7. </activity>  
  8.   
  9. </application>   
<application android:icon="@drawable/icon" android:label="@string/app_name">

<activity android:name=".TestApp" android:label="@string/app_name">

……

</activity>

</application>



这样，在启动程序的时候就会先启动一个Application，然后在此Application运行过程中根据情况加载相应的 Activity，而Activity是需要一个界面的。但是Instrumentation并不是这样的。你可以将Instrumentation理解 为一种没有图形界面的，具有启动能力的，用于监控其他类（用Target Package声明）的工具类。任何想成为Instrumentation的类必须继承android.app.Instrumentation。下面是 这个类的解释：

Base class for implementing application instrumentation code. When running with instrumentation turned on, this class will be instantiated for you before any of the application code, allowing you to monitor all of the interaction the system has with the application. An Instrumentation implementation is described to the system through an AndroidManifest.xml's <instrumentation> tag.

对于单元测试，我们需要认真了解的就是android.test.InstrumentationTestRunner类。这是Android单元测试的主入口。它相当于JUnit当中TestRunner的作用。

那么如何加载它呢，首先要在manifest文件中加入一行关于Instrumentation的声明。比如Android Api Demos中的测试里的manifest是这么写的（我滤掉了所有的注释）：

Java代码
  1. <manifest xmlns:android="http://schemas.android.com/apk/res/android"   
  2.   
  3. package ="com.example.android.apis.tests" >  
  4.   
  5. <application>  
  6.   
  7. <uses-library android:name="android.test.runner"  />  
  8.   
  9. </application>  
  10.   
  11. <instrumentation android:name="android.test.InstrumentationTestRunner"   
  12.   
  13. android:targetPackage="com.example.android.apis"   
  14.   
  15. android:label="Tests for Api Demos." />  
  16.   
  17. </manifest>   
<manifest xmlns:android="http://schemas.android.com/apk/res/android"

package="com.example.android.apis.tests">

<application>

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

</application>

<instrumentation android:name="android.test.InstrumentationTestRunner"

android:targetPackage="com.example.android.apis"

android:label="Tests for Api Demos."/>

</manifest>



如果用Eclipse的ADT插件（0.8版本以上），也可以用图形界面来添加，如下图：


编辑好manifest，就可以打包（build，可以用Eclipse ADT来做，也可以用aapt命令手工完成），然后安装到虚拟机上（用adb install命令）。之后就可以利用命令行的方式来加载你的单元测试了。在Android Shell中加载一个Instrumentation的方法是利用以下命令：

Java代码
  1. adb shell am instrument –w XXXXXX   
adb shell am instrument –w XXXXXX



其中-w是指定Instrumentation类的参数标志。一个简单的例子是：

Java代码
  1. adb shell am instrument -w com.android.foo/android.test.InstrumentationTestRunner   
adb shell am instrument -w com.android.foo/android.test.InstrumentationTestRunner



当然，也可以利用adb shell先进入android命令行模式，再直接写am instrument –w XXXXXXX。下面将具体介绍如何将根据需要加载一组单元测试。 如何在Android中利用Instrumentation来进行测试？

在介绍具体的命令之前，我们先理解一下单元测试的层次。一组单元测试可以被组织成若干个TestSuite。每个TestSuite包含若干 TestCase（某个继承android.jar的junit.framework.TestCase的类）。每个TestCase又包含若干个 Test（具体的test方法）。

如果假设com.android.foo是你的测试代码的包的根。当执行以下命令时，会执行所有的TestCase的所有Test。测试的对象就是在Target Package中指定的包中的代码：

Java代码
  1. adb shell am instrument -w com.android.foo/android.test.InstrumentationTestRunner   
adb shell am instrument -w com.android.foo/android.test.InstrumentationTestRunner


如果你想运行一个TestSuite，首先继承android.jar的junit.framework.TestSuite类，实现一个TestSuite（比如叫com.android.foo.MyTestSuite），然后执行以下命令执行此TestSuite

Java代码
  1. adb shell am instrument -e class  com.android.foo.MyTestSuite -w com.android.foo/android.test.InstrumentationTestRunner   
adb shell am instrument -e class com.android.foo.MyTestSuite -w com.android.foo/android.test.InstrumentationTestRunner



其中的-e表示额外的参数，语法为-e [arg1] [value1] [arg2] [value2] …这里用到了class参数。

如果仅仅想运行一个TestCase（比如叫com.android.foo.MyTestCase），则用以下命令：

Java代码
  1. adb shell am instrument -e class  com.android.foo.MyTestCase -w com.android.foo/android.test.InstrumentationTestRunner   
adb shell am instrument -e class com.android.foo.MyTestCase -w com.android.foo/android.test.InstrumentationTestRunner


如果仅仅想运行一个Test（比如就是上面MyTestCase的testFoo方法），很类似的，就这样写：

Java代码
  1. adb shell am instrument -e class  com.android.foo.MyTestCase#testFoo -w com.android.foo/android.test.InstrumentationTestRunner   
adb shell am instrument -e class com.android.foo.MyTestCase#testFoo -w com.android.foo/android.test.InstrumentationTestRunner


然后，所有的测试结果会输出到控制台，并会做一系列统计，如标记为E的是Error，标记为F的是Failure，Success的测试则会标记 为一个点。这和JUnit的语义一致。如果希望断点调试你的测试，只需要直接在代码上加上断点，然后将运行命令参数的-e后边附加上debug true后运行即可。更加详细的内容可以看InstrumentationTestRunner的Javadoc。我希望Android能尽快有正式的文 档来介绍这个内容。 如何在Android的单元测试中做标记？

在android.test.annotation包里定义了几个annotation，包括 @LargeTest，@MediumTest，@SmallTest，@Smoke，和@Suppress。你可以根据自己的需要用这些 annotation来对自己的测试分类。在执行单元测试命令时，可以在-e参数后设置“size large”/ “size medium”/ “size small”来执行具有相应标记的测试。特别的@Supperss可以取消被标记的Test的执行。 完整的操作过程

总结以上所有的内容，编写并运行完整的测试需要以下的步骤：


以上步骤中，在Android自带的例子中，我发现它有两个manifest.xml。也就是说在步骤3中源代码和测试代码分别生成了两个不同的 包。然后步骤4利用adb install命令安装到了虚拟机上。由于我没有找到Eclipse ADT有办法可以为一个只有Instrumentation，没有Activity的Application打包并安装，于是采用了略微不同的办法完成了 这个工作。下面将一一详细介绍整个过程。 1. 编写程序

我新建了一个项目TestApp，参数为：

Java代码
  1. Package Name: com.android.testapp  
  2.   
  3. Activity Name: MainActivity  
  4.   
  5. Application Name: TestApp  
  6.   
  7. 以下是MainActivity的源代码：  
  8.   
  9. package  com.android.testapp;  
  10.   
  11. import  android.app.Activity;  
  12.   
  13. import  android.os.Bundle;  
  14.   
  15. public  class  MainActivity extends  Activity {  
  16.   
  17. /** Called when the activity is first created. */   
  18.   
  19. @Override   
  20.   
  21. public  void  onCreate(Bundle savedInstanceState) {  
  22.   
  23. super .onCreate(savedInstanceState);  
  24.   
  25. setContentView(R.layout.main);  
  26.   
  27. }  
  28.   
  29. public  int  sum(int  a, int  b) {  
  30.   
  31. return  a + b;  
  32.   
  33. }  
  34.   
  35. public  int  substract(int  a, int  b) {  
  36.   
  37. return  b - a;  
  38.   
  39. }  
  40.   
  41. }   
Package Name: com.android.testapp

Activity Name: MainActivity

Application Name: TestApp

以下是MainActivity的源代码：

package com.android.testapp;

import android.app.Activity;

import android.os.Bundle;

public class MainActivity extends Activity {

/** Called when the activity is first created. */

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

}

public int sum(int a, int b) {

return a + b;

}

public int substract(int a, int b) {

return b - a;

}

}



其中，我故意将减法的a – b写成了b – a。 2. 编写测试程序

然后，我新建了一个Source Folder，名为test，并在里面新建了包com.android.testapp.test。并定义了一个TestCase，名为TestMainActivity，源代码如下：

Java代码
  1. package  com.android.testapp.test;  
  2.   
  3. import  com.android.testapp.MainActivity;  
  4.   
  5. import  android.test.ActivityInstrumentationTestCase;  
  6.   
  7. import  android.test.suitebuilder.annotation.MediumTest;  
  8.   
  9. public  class  TestMainActivity extends  ActivityInstrumentationTestCase<MainActivity> {  
  10.   
  11. public  TestMainActivity() {  
  12.   
  13. super ("com.android.testapp" , MainActivity.class );  
  14.   
  15. }  
  16.   
  17. public  TestMainActivity(String pkg, Class<MainActivity> activityClass) {  
  18.   
  19. super (pkg, activityClass);  
  20.   
  21. }  
  22.   
  23. @MediumTest   
  24.   
  25. public  void  testSum() {  
  26.   
  27. assertEquals(3 , getActivity().sum(1 , 2 ));  
  28.   
  29. }  
  30.   
  31. @MediumTest   
  32.   
  33. public  void  testSubstract() {  
  34.   
  35. assertEquals(-1 , getActivity().substract(1 , 2 ));  
  36.   
  37. }  
  38.   
  39. }   
package com.android.testapp.test;

import com.android.testapp.MainActivity;

import android.test.ActivityInstrumentationTestCase;

import android.test.suitebuilder.annotation.MediumTest;

public class TestMainActivity extends ActivityInstrumentationTestCase<MainActivity> {

public TestMainActivity() {

super("com.android.testapp", MainActivity.class);

}

public TestMainActivity(String pkg, Class<MainActivity> activityClass) {

super(pkg, activityClass);

}

@MediumTest

public void testSum() {

assertEquals(3, getActivity().sum(1, 2));

}

@MediumTest

public void testSubstract() {

assertEquals(-1, getActivity().substract(1, 2));

}

}



我继承了ActivityInstrumentationTestCase。这个TestCase在执行时会自动帮我启动相应的Activity。

接下来就是程序的Manifest：

Java代码
  1. <?xml version="1.0"  encoding="utf-8" ?>  
  2.   
  3. <manifest xmlns:android="http://schemas.android.com/apk/res/android"   
  4.   
  5. package ="com.android.testapp"   
  6.   
  7. android:versionCode="1"   
  8.   
  9. android:versionName="1.0.0" >  
  10.   
  11. <application android:icon="@drawable/icon"  android:label="@string/app_name" >  
  12.   
  13. <activity android:name=".MainActivity"   
  14.   
  15. android:label="@string/app_name" >  
  16.   
  17. <intent-filter>  
  18.   
  19. <action android:name="android.intent.action.MAIN"  />  
  20.   
  21. <category android:name="android.intent.category.LAUNCHER"  />  
  22.   
  23. </intent-filter>  
  24.   
  25. </activity>  
  26.   
  27. <uses-library android:name="android.test.runner"  />  
  28.   
  29. </application>  
  30.   
  31. <instrumentation android:targetPackage="com.android.testapp"  android:name="android.test.InstrumentationTestRunner"  android:label="Test Unit Tests" ></instrumentation>  
  32.   
  33. </manifest>   
<?xml version="1.0" encoding="utf-8"?>

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

package="com.android.testapp"

android:versionCode="1"

android:versionName="1.0.0">

<application android:icon="@drawable/icon" android:label="@string/app_name">

<activity android:name=".MainActivity"

android:label="@string/app_name">

<intent-filter>

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

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

</intent-filter>

</activity>

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

</application>

<instrumentation android:targetPackage="com.android.testapp" android:name="android.test.InstrumentationTestRunner" android:label="Test Unit Tests"></instrumentation>

</manifest>


在这个文件中，我将Activity和Instrumentation的声明写到了一起，而没有像Apis Demo那样分开。请注意里面的<uses-library>标签。如果没有那句，在运行测试时会报告找不到TestRunner。这是由于 Android在build的时候只把需要的东西打包，所以你必须明确的告诉Android Builder这一点。 3. Build和Install

在Eclipse上，这两个步骤是一起完成的。只要点一下Run即可。只不过如果你不在Run Configuration里将安装后的Launch Action设为“Do Nothing”，就会自动运行一下你的MainActivity。对于我们，设为Do Nothing即可。如下图：


完成后，利用命令

Java代码
  1. adb shell pm list packages   
adb shell pm list packages



可以在已经安装的pkg列表里看到com.android.testapp。 4. 运行测试，查看结果

之后就打开命令行，运行以下命令

Java代码
  1. adb shell am instrument –e class  com.android.testapp.test.TestMainActivity –w com.android.testapp/android.test.InstrumentationTestRunner   
adb shell am instrument –e class com.android.testapp.test.TestMainActivity –w com.android.testapp/android.test.InstrumentationTestRunner



即可看到如下的结果：

可以看到，单元测试正确的找到了减法中的错误。结果中的成功的测试显示为”.”，一个失败的显示为”F”。只不过我还是不太理解为什么我只写了两个测试方法，Tests run却显示了3。


(三) 转
Android下使用JUnit
Andorid下使用Junit测试框架，是步入正规的Androdid开发的必经之路，在Junit中可以得到组件，可以模拟发送事件，检测程序处理的正确性，下面就开始我们的教程：
工具：
1、Android1.5 SDK
2、ADT  0.9
3、Eclipse
需要的知识：
1、 Android开发的基础
2、Junit的基础
一、
首先建立工程：
目录：
选中的test source folder是测试类的包，包名随便，但是在配置Manifest.xml要注意
二、配置/layout/main.xml文件，加入两个button组件，代码如下：

  

Java代码
  1. * <?xml version="1.0"  encoding="utf-8" ?>  
  2.    * <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"   
  3.    * android:orientation="vertical"  android:layout_width="fill_parent"   
  4.    * android:layout_height="fill_parent" >  
  5.    * <Button android:text="Button01"  android:id="@+id/Button01"   
  6.    *   android:layout_width="wrap_content"  android:layout_height="wrap_content" ></Button>  
  7.    * <Button android:text="Button02"  android:id="@+id/Button02"   
  8.    *   android:layout_width="wrap_content"  android:layout_height="wrap_content" ></Button>  
  9.    * </LinearLayout>   
 * <?xml version="1.0" encoding="utf-8"?>
    * <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    * android:orientation="vertical" android:layout_width="fill_parent"
    * android:layout_height="fill_parent">
    * <Button android:text="Button01" android:id="@+id/Button01"
    *   android:layout_width="wrap_content" android:layout_height="wrap_content"></Button>
    * <Button android:text="Button02" android:id="@+id/Button02"
    *   android:layout_width="wrap_content" android:layout_height="wrap_content"></Button>
    * </LinearLayout>



三、被测试的Activity代码

Java代码
  1. # package  cc.androidos.activity;  
  2. # import  android.app.Activity;  
  3. # import  android.os.Bundle;  
  4. # import  android.widget.Button;  
  5. # public  class  NewActivity extends  Activity {  
  6. #     /** Called when the activity is first created. */   
  7. #     @Override   
  8. #     public  void  onCreate(Bundle savedInstanceState) {  
  9. #         super .onCreate(savedInstanceState);  
  10. #         setContentView(R.layout.main);  
  11. #     }  
  12. #     public  int  add(int  a , int  b){  
  13. #      return  a+b;  
  14. #     }  
  15. # }   
# package cc.androidos.activity;
# import android.app.Activity;
# import android.os.Bundle;
# import android.widget.Button;
# public class NewActivity extends Activity {
#     /** Called when the activity is first created. */
#     @Override
#     public void onCreate(Bundle savedInstanceState) {
#         super.onCreate(savedInstanceState);
#         setContentView(R.layout.main);
#     }
#     public int add(int a , int b){
#      return a+b;
#     }
# }



四、测试NewActivity代码，这里要继承ActivityInstrumentationTestCase2，ActivityInstrumentationTestCase2是TestCase的子类

   

Java代码
  1. * package  cc.andoridos.activity.test;  
  2.     * import  cc.androidos.activity.NewActivity;  
  3.     * import  cc.androidos.activity.R;  
  4.     * import  android.test.ActivityInstrumentationTestCase2;  
  5.     * import  android.util.Log;  
  6.     * import  android.view.KeyEvent;  
  7.     * import  android.widget.Button;  
  8.     * public  class  TestNewActivity extends   
  9.     *   ActivityInstrumentationTestCase2<NewActivity> {  
  10.     * private  Button button1 = null ;  
  11.     * private  Button button2 = null ;  
  12.     * private  NewActivity newActivity = null ;  
  13.     * public  TestNewActivity() {  
  14.     *   super ("cc.androidos.activity" , NewActivity.class );  
  15.     *   //This first parameter should the Activity package   
  16.     *   //if other , the junit give us the exception: unable resolve the activity   
  17.     * }  
  18.     *  
  19.     * @Override   
  20.     * protected  void  setUp() throws  Exception {  
  21.     *   String tag = "setUp" ;  
  22.     *   Log.e(tag, "init all var...." );  
  23.     *   newActivity = getActivity();  
  24.     *   button1 = (Button) newActivity.findViewById(R.id.Button01);  
  25.     *   button2 = (Button) newActivity.findViewById(R.id.Button02);  
  26.     * }  
  27.     * /**  
  28.     *   * Testing the button is focused or not  
  29.     *   */   
  30.     * public   void  testButtonFocus() {  
  31.     *   String tag = "testButtonFocus" ;  
  32.     *   Log.e(tag, "start the button focus..." );  
  33.     *   assertTrue("Button1 is focused" , button1.isFocused());  
  34.     *   Log.e(tag, "send the down key event..." );  
  35.     *   sendKeys(KeyEvent.KEYCODE_DPAD_DOWN);  
  36.     *   assertTrue("Button2 is focused" , button2.isFocused());  
  37.     * }  
  38.     *  
  39.     * /**  
  40.     *   * Testing the add method in actvity  
  41.     *   */   
  42.     * public  void  testAdd(){  
  43.     *   String tag ="testAdd" ;  
  44.     *   Log.e(tag, "Test the add method in NewActivity..." );  
  45.     *   int  i  = newActivity.add(2 , 5 );  
  46.     *   assertEquals(7 , i);  
  47.     * }  
  48.     *  
  49.     * }   
* package cc.andoridos.activity.test;
    * import cc.androidos.activity.NewActivity;
    * import cc.androidos.activity.R;
    * import android.test.ActivityInstrumentationTestCase2;
    * import android.util.Log;
    * import android.view.KeyEvent;
    * import android.widget.Button;
    * public class TestNewActivity extends
    *   ActivityInstrumentationTestCase2<NewActivity> {
    * private Button button1 = null;
    * private Button button2 = null;
    * private NewActivity newActivity = null;
    * public TestNewActivity() {
    *   super("cc.androidos.activity", NewActivity.class);
    *   //This first parameter should the Activity package
    *   //if other , the junit give us the exception: unable resolve the activity
    * }
    *
    * @Override
    * protected void setUp() throws Exception {
    *   String tag = "setUp";
    *   Log.e(tag, "init all var....");
    *   newActivity = getActivity();
    *   button1 = (Button) newActivity.findViewById(R.id.Button01);
    *   button2 = (Button) newActivity.findViewById(R.id.Button02);
    * }
    * /**
    *   * Testing the button is focused or not
    *   */
    * public  void testButtonFocus() {
    *   String tag = "testButtonFocus";
    *   Log.e(tag, "start the button focus...");
    *   assertTrue("Button1 is focused", button1.isFocused());
    *   Log.e(tag, "send the down key event...");
    *   sendKeys(KeyEvent.KEYCODE_DPAD_DOWN);
    *   assertTrue("Button2 is focused", button2.isFocused());
    * }
    *
    * /**
    *   * Testing the add method in actvity
    *   */
    * public void testAdd(){
    *   String tag ="testAdd";
    *   Log.e(tag, "Test the add method in NewActivity...");
    *   int i  = newActivity.add(2, 5);
    *   assertEquals(7, i);
    * }
    *
    * }




五、配置Manifest.xml文件

   

Java代码
  1. * <?xml version="1.0"  encoding="utf-8" ?>  
  2.     * <manifest xmlns:android="http://schemas.android.com/apk/res/android"   
  3.     * package ="cc.androidos.activity"  android:versionCode="1"   
  4.     * android:versionName="1.0" >  
  5.     * <application android:icon="@drawable/icon"  android:label="@string/app_name" >  
  6.     *   <activity android:name=".NewActivity"  android:label="@string/app_name" >  
  7.     *    <intent-filter>  
  8.     *     <action android:name="android.intent.action.MAIN"  />  
  9.     *     <category android:name="android.intent.category.LAUNCHER"  />  
  10.     *    </intent-filter>  
  11.     *   </activity>  
  12.     *   <activity android:name=".NewActivity2"  android:label="@string/app_name" >  
  13.     *   </activity>  
  14.     *   <uses-library android:name="android.test.runner"  />  
  15.     *   <!-- Loading test library -->  
  16.     * </application>  
  17.     * <uses-sdk android:minSdkVersion="3"  />  
  18.     *  
  19.     * <!-- 这个是关键，android:targetPackage="cc.androidos.activity" 要测试的包，android:name="android.test.InstrumentationTestRunner"  用于跑TestCase的类-->  
  20.     * <instrumentation android:targetPackage="cc.androidos.activity"   
  21.     *   android:label="Test New Activty"  android:name="android.test.InstrumentationTestRunner" ></instrumentation>  
  22.     * </manifest>   
* <?xml version="1.0" encoding="utf-8"?>
    * <manifest xmlns:android="http://schemas.android.com/apk/res/android"
    * package="cc.androidos.activity" android:versionCode="1"
    * android:versionName="1.0">
    * <application android:icon="@drawable/icon" android:label="@string/app_name">
    *   <activity android:name=".NewActivity" android:label="@string/app_name">
    *    <intent-filter>
    *     <action android:name="android.intent.action.MAIN" />
    *     <category android:name="android.intent.category.LAUNCHER" />
    *    </intent-filter>
    *   </activity>
    *   <activity android:name=".NewActivity2" android:label="@string/app_name">
    *   </activity>
    *   <uses-library android:name="android.test.runner" />
    *   <!-- Loading test library -->
    * </application>
    * <uses-sdk android:minSdkVersion="3" />
    *
    * <!-- 这个是关键，android:targetPackage="cc.androidos.activity"要测试的包，android:name="android.test.InstrumentationTestRunner" 用于跑TestCase的类-->
    * <instrumentation android:targetPackage="cc.androidos.activity"
    *   android:label="Test New Activty" android:name="android.test.InstrumentationTestRunner"></instrumentation>
    * </manifest>



Java代码
  1. # E:/android/android-sdk-windows-1 .5_pre/tools>adb shell am instrument -w cc.andro  
  2. # idos.activity/android.test.InstrumentationTestRunner  
  3. # 如果你配置了Android环境变量，直接使用：  
  4. # adb shell am instrument -w cc.androidos.activity/android.test.InstrumentationTestRunner  
  5. # 语法：adb shell am instrument -w <被测试的类的包名>/android.test.InstrumentationTestRunner 
stress testing（压力测试）
joy_cz的专栏
03-24 2974
在web application的开发上，memory management相当重要，而session management对memory management的影响最为明显。而stress testing（压力测试）就是用在这方面的，用于模拟多用户同时在线的情景，甚至可以模拟黑客的DoS Attack 。而grinder就提供了这样的功能。（http://grinder.sourceforge.
Android Instrumentation基础使用
streamtown的博客
02-21 1211
    这两天准备研究Robotium的源码，不过由于Robotium是以Instrumentation为基础的，因此就先补习了一下Instrumentation的基础。     Instrumentation是Android自带一个单元测试框架，不过虽然这么说，其对于大部分应用开发人员来讲，最大的作用反而是用于功能或UI测试。       整个框架继承自JUnit框架，使用方法也类似，...
安卓开发单元测试demo
01-22
简单的可执行的安卓单元测试 /TestLogin /TestLogin/src zy.zh.logindemo.test /TestLogin/src/zy/zh/logindemo/test/FxLoginActivityTest.java /TestLogin/src/zy/zh/logindemo/test/FxResultActivityTest.java
android Test(硬件)
satiling的专栏
03-05 2582
android源代码中每个app下中都自带了一个test用例，下面主要介绍下camra单元测试用例  在AndroidManifest.xml中标明了测试用例instrumentation函数入口    Java代码  "1.0"  encoding="utf-8" ?>   2008  The Android Open Source Project
android应用的单元测试
yehui18sui的专栏
05-15 705
首先配置AndroidManifest.xml xml version="1.0" encoding="utf-8"?> manifest xmlns:android="http://schemas.android.com/apk/res/android"     package="com.zhy.test"     android:versionCode="1"     andro
android下 C++单元测试 及 代码覆盖率
u013366022的专栏
07-23 3366
一、简单介绍 gtest是一款google提供的强大的测试框架，测试案例的编写也比较简单，gtest案例的编写可以参考系列博文:http://www.cnblogs.com/coderzh/archive/2009/03/31/1426758.html。 Gcov是进行代码运行的覆盖率统计的工具，它随着gcc的发布一起发布的，它的使用也很简单，需要在编译和链接的时候加上-fprofile-ar...
详解Android单元测试方法与步骤
08-27
"Android单元测试方法与步骤详解" Android单元测试是Android应用程序开发中非常重要的一步，它可以帮助开发者快速检测和修复应用程序中的错误。下面将详细介绍Android单元测试方法与步骤。 一、修改配置文件...
android单元测试
07-22
这篇内容将深入探讨Android单元测试的相关知识点。 首先，我们要了解什么是单元测试。单元测试是指针对软件中的最小可测试单元进行检查和验证，对于Android应用来说，这通常是单个函数或类。通过编写自动化测试用例...
Android单元测试初探——Instrumentation
03-04
学习Android有一段时间了，虽然前段时间对软件测试有了一些了解，不过接触android的单元测试却是头一次。这几天在物流大赛上也用了不少时间，所以对于android的单元测试没有太深入的研究，所以先写个基本入门吧！...
Android模拟屏幕鼠标
欢迎加入Android老司机学院 482266514（技术交流群）密码CSDN
06-16 7635
在Android系统下模拟鼠标键盘等输入设备，网络上资料非常多。但不少是人云亦云，甚至测试都不愿测试一下就抄上来了。这次写一点体会，当作抛砖引玉。 0. 背景知识： 众所周知，Android是将Framework架在Linux之上的系统。Linux层和硬件打交道，Framework通过JNI等途径得到底层信息。 消息的传递是：Linux -> Framework ->
Android 单元测试，从小白到入门开始
热门推荐
让学习编程变得生动有趣~
10-14 1万+
1 引言 1.1 背景 随着 Android 应用越来越壮大，对应代码量显著增加，代码逻辑也日趋复杂，此时需要采取一定的行动去保证代码质量，减少逻辑漏洞等，于是严格地执行单元测试编写任务，将单元测试落实到平常开发和维护任务当中去，就是很重要的一环，不可忽视。 然而，很多应用开发者之前并未编写过单元测试代码，那么如果有一篇通俗易懂并带有操作步骤的文章，能帮助应用开发者完成从单元测试小白到入门的过渡，就再好不过了，于是本文就是在此情况写就的，如有不好之处，请多多包涵，谢谢...
Android单元测试调研
王温暖的博客
12-05 311
（一）Java JUnit Tests 1、JUnit androidstudio创建工程自带 JUnit 在 Android 官网上出现的频率相当高，是 Android 单元测试的基础框架之一，后面提到的 mock 框架都相当于是在丰富这些基础框架的功能。 要做单元测试的开发者们通常都会在 JUnit 和 TestNG 之间选择一个，个人感觉还是选 JUnit 好一些。（理由在 TestNG 的介绍中） 这种测试运行在本地开发环境的Java虚拟机上，不需要连接Android设备或者模拟器，因
android send key event
阳光玻璃杯
07-15 6007
1.input 命令 用法： Usage: input [] [...] 其中，source有:       mouse             keyboard         joystick       touchnavigation        touchpad       trackball       stylus       dpad
Android单元测试 - 如何开始？
SolarLove的博客
09-03 222
回顾： 《谈谈为什么写单元测试》 基本单元测试框架 Java单元测试框架：Junit、Mockito、Powermockito等；Android：Robolectric、AndroidJUnitRunner、Espresso等。 最开始建议先学习Junit & Mockito。这两款框架是java领域应用非常普及，使用简单，网上文...
Android Instrumentation 模拟点击、拖拽、发送keycode、焦点异常丢失。
liudi0307的博客
01-30 4356
Instrumentation模拟点击，拖拽，向系统发送keycode。 需要注意的几点： Android系统坐标系，X轴正方向为右，Y轴正方向为下（与数学坐标系相反) 所有事件在发送时均需要在Thread中执行，否则会报异常。 模拟输入法种特殊符号时，需要带上shift，同正常键盘操作。 public void simulateClick() { final
深入浅出Android单元测试
资源摘要信息: "Android单元测试" Android单元测试是针对Android平台的应用程序开发中的重要环节。它涉及编写测试用例来验证应用程序中的单个组件或模块的功能是否符合预期。单元测试通常在开发过程中进行，目的是...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值