配置 Android 模拟器

配置项目

1. 打开 Eclipse, 选择 File>Import 到 Import 窗口。
2. 选择 Existing Android Code into Workspace，进入 Import Projects 窗口。
3. Root Directory 选择 SpinnerActivity 代码所在位置。 比如： /samples/android-18/legacy/Spinner。
4. 其他默认，点击 Finish。

1. 在 Package Explorer 里面右击 SpinnerActivity 项目，选择 Android Tools>New Test Project...， 会弹出 "New Android Test Project" 对话框。
2. Project Name 命名为 SpinnerActivityTest， 然后选择 Next
3. 在 Select Test Target 里面选择 SpinnerActivity，然后点击 Finish。
4. 这样一个测试项目就生成了。

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
          package="com.android.example.spinner.test"
          android:versionCode="1"
          android:versionName="1.0">
    <uses-sdk android:minSdkVersion="3" />
    <application  android:label="@string/app_name">
        <uses-library android:name="android.test.runner"/>
    </application>
    <instrumentation android:name="android.test.InstrumentationTestRunner"
                     android:targetPackage="com.android.example.spinner"
                     android:label="Tests for com.android.example.spinner"/>
</manifest>

创建测试用例类

1. 测试配置。 我们一般用 JUnit 的 setUp 方法来做一些准备工作，和在跑每个测试前需要运行的任务。
2. 初始条件测试。 这是一个很好的测试技术。通过 instrumentation，我们可以在没有启动 主Activity 前就可以观察这个应用。初始条件测试会检查被测应用的某些重要对象是否初始化。如果这个测试都失败了，那别的基于该被测应用的测试也是没有意义的。 > 注意：初始条件测试和 JUnit 的 setUp 方法是不一样的。JUnit 的 setUp 方法在每个测试用例运行前运行，它的主要目的是创建一个干净的环境。初始条件测试只运行一次，它的目的是检查被测程序是否可以被测试了。
3. UI 测试。我们会教你如何使用强大的 Android 自动化测试工具。
4. 状态管理测试。这里将会讲述一些 Android 如何保持状态的技术。从用户体验的角度来看，应用不应该丢失任何当前状态，无论是突然有电话进来或者内存不够导致崩溃。Android Activity 的生命周期提供了方法维护这些状态，我们的被测程序中也用到了。这里，我们会验证这些方法。

添加测试类文件

1. 展开前面生成的 SpinnerActivityTest 的 src 文件夹。
2. 在 com.android.example.spinner.test 这个package 创建一个类，这个类必须继承 ActivityInstrumentationTestCase2。 如：

public class SpinnerActivityTest extends ActivityInstrumentationTestCase2<SpinnerActivity> {
...
}

添加构造函数

    /*
     * Constructor for the test class. Required by Android test classes. The constructor
     * must call the super constructor, providing the Android package name of the app under test
     * and the Java class name of the activity in that application that handles the MAIN intent.
     */
    public SpinnerActivityTest() {
        super("com.android.example.spinner", SpinnerActivity.class);
    }

/**
     * Creates an {@link ActivityInstrumentationTestCase2}.
     *
     * @param pkg ignored - no longer in use.
     * @param activityClass The activity to test. This must be a class in the instrumentation
     * targetPackage specified in the AndroidManifest.xml
     *
     * @deprecated use {@link #ActivityInstrumentationTestCase2(Class)} instead
     */
    @Deprecated
    public ActivityInstrumentationTestCase2(String pkg, Class<T> activityClass) {
        this(activityClass);
    }
    /**
     * Creates an {@link ActivityInstrumentationTestCase2}.
     *
     * @param activityClass The activity to test. This must be a class in the instrumentation
     * targetPackage specified in the AndroidManifest.xml
     */
    public ActivityInstrumentationTestCase2(Class<T> activityClass) {
        mActivityClass = activityClass;
    }

添加 setUp 方法

 /* 里面涉及的实例变量，假设已经存在了。 */
    @Override
    protected void setUp() throws Exception {
        /*
         * Call the super constructor (required by JUnit)
         */
        super.setUp();
        /*
         * prepare to send key events to the app under test by turning off touch mode.
         * Must be done before the first call to getActivity()
         */
        setActivityInitialTouchMode(false);
        /*
         * Start the app under test by starting its main activity. The test runner already knows
         * which activity this is from the call to the super constructor, as mentioned
         * previously. The tests can now use instrumentation to directly access the main
         * activity through mActivity.
         */
        mActivity = getActivity();
        /*
         * Get references to objects in the application under test. These are
         * tested to ensure that the app under test has initialized correctly.
         */
        mSpinner = (Spinner)mActivity.findViewById(com.android.example.spinner.R.id.Spinner01);
        mPlanetData = mSpinner.getAdapter();
    }

/**
     * Call this method before the first call to {@link #getActivity} to set the initial touch
     * mode for the Activity under test.
     * 
     * 
If you do not call this, the touch mode will be false.  If you call this after
     * your Activity has been started, it will have no effect.
     * 
     * 
<b>NOTE:</b> Activities under test may not be started from within the UI thread.
     * If your test method is annotated with {@link android.test.UiThreadTest}, then you must call
     * {@link #setActivityInitialTouchMode(boolean)} from {@link #setUp()}.
     * 
     * @param initialTouchMode true if the Activity should be placed into "touch mode" when started
     */
    public void setActivityInitialTouchMode(boolean initialTouchMode) {
        mInitialTouchMode = initialTouchMode;
    }

添加初始条件测试

1. Spinner 里面的 item 的 listener 是否初始化成功。
2. 给 Spinner 提供数据的 adapter 是否初始化成功。
3. adapter 里面数据的个数正确。

 /*
     * Tests the initial values of key objects in the app under test, to ensure the initial
     * conditions make sense. If one of these is not initialized correctly, then subsequent
     * tests are suspect and should be ignored.
     */
    public void testPreconditions() {
        /*
         *  An example of an initialization test. Assert that the item select listener in
         *  the main Activity is not null (has been set to a valid callback)
         */
        assertTrue(mSpinner.getOnItemSelectedListener() != null);
        /*
         * Test that the spinner's backing mLocalAdapter was initialized correctly.
         */
        assertTrue(mPlanetData != null);
        /*
         *  Also ensure that the backing mLocalAdapter has the correct number of entries.
         */
        assertEquals(mPlanetData.getCount(), ADAPTER_COUNT);
    }

添加一个 UI 测试

/*
     * Tests the UI of the main activity. Sends key events (keystrokes) to the UI, then checks
     * if the resulting spinner state is consistent with the attempted selection.
     */
    public void testSpinnerUI() {
        /*
         * Request focus for the spinner widget in the application under test,
         * and set its initial position. This code interacts with the app's View
         *  so it has to run on the app's thread not the test's thread.
         *
         * To do this, pass the necessary code to the application with
         * runOnUiThread(). The parameter is an anonymous Runnable object that
         * contains the Java statements put in it by its run() method.
         */
         /* 这里需要注意， 主要是因为 mSpinner 是一个 View。*/
        mActivity.runOnUiThread(
            new Runnable() {
                public void run() {
                    mSpinner.requestFocus();
                    mSpinner.setSelection(INITIAL_POSITION);
                }
            }
        );
        // Activate the spinner by clicking the center keypad key
        this.sendKeys(KeyEvent.KEYCODE_DPAD_CENTER);
        // send 5 down arrow keys to the spinner
        for (int i = 1; i <= TEST_POSITION; i++) {
            this.sendKeys(KeyEvent.KEYCODE_DPAD_DOWN);
        }
        // select the item at the current spinner position
        this.sendKeys(KeyEvent.KEYCODE_DPAD_CENTER);
        // get the position of the selected item
        mPos = mSpinner.getSelectedItemPosition();
        /*
         * from the spinner's data mLocalAdapter, get the object at the selected position
         * (this is a String value)
         */
        mSelection = (String)mSpinner.getItemAtPosition(mPos);
        /*
         * Get the TextView widget that displays the result of selecting an item from the spinner
         */
        TextView resultView =
                (TextView) mActivity.findViewById(com.android.example.spinner.R.id.SpinnerResult);
        // Get the String value in the EditText object
        String resultText = (String) resultView.getText();
        /*
         * Confirm that the EditText contains the same value as the data in the mLocalAdapter
         */
        assertEquals(resultText,mSelection);
    }

添加状态管理测试

1. 用户可能为了接听电话从当前应用中切换出去，等接完电话再切换回来。
2. 在手机切换横竖屏时，Android 系统本身也可能会重启或者关闭一个 Activity。
3. 手机内存不够了，关闭一些暂时没用的 Activity 来释放资源。

1. Activity 隐藏。其他的界面出现，Spinner 隐藏的时候，它会把 Spinner 的当前位置和值存在一个临时表单里。只要 Spinner 应用运行着，这些值就会被保留着。
2. 应用被关闭。当 SpinnerActivity 被关闭的时候，它会把当前位置和值保存到一个永久的表单（其实就是 SharedPreferences）里去。当这个 Activity 重启的时候，会从这个表单里读取位置和值出来，恢复到关闭前的状态。
3. Activity 重现（或者是重绘？）当 Spinner 界面重新出现的时候，它应该恢复到隐藏之前的状态。
4. 应用重启。当用户再次启动 Spinner 的时候，它会恢复到关闭前的状态。

• onPaused()
• onResume()

1. 用 instrumentation 设置 Spinner 变量
2. 用 Activity.finish() 方法关闭 Activity
3. 用 instrumentation 的 getActivity() 方法重启
4. 验证当前的状态是否和关闭前的一致

/*
     *  Tests that the activity under test maintains the spinner state when the activity halts
     *  and then restarts (for example, if the device reboots). Sets the spinner to a
     *  certain state, calls finish() on the activity, restarts the activity, and then
     *  checks that the spinner has the same state.
     *
     */
    public void testStateDestroy() {
        /*
         * Set the position and value of the spinner in the Activity. The test runner's
         * instrumentation enables this by running the test app and the main app in the same
         * process.
         */

        mActivity.setSpinnerPosition(TEST_STATE_DESTROY_POSITION);
        mActivity.setSpinnerSelection(TEST_STATE_DESTROY_SELECTION);
        // Halt the Activity by calling Activity.finish() on it
        mActivity.finish();
        // Restart the activity by calling ActivityInstrumentationTestCase2.getActivity()
        mActivity = this.getActivity();
        /*
         * Get the current position and selection from the activity.
         */
        int currentPosition = mActivity.getSpinnerPosition();
        String currentSelection = mActivity.getSpinnerSelection();
        // test that they are the same.
        assertEquals(TEST_STATE_DESTROY_POSITION, currentPosition);
        assertEquals(TEST_STATE_DESTROY_SELECTION, currentSelection);
    }

1. 用 instrumentation 设置 Spinner 变量
2. 强行调用 onPaused() 和 onResume() 方法
3. 验证状态是否保持一致

/*
     * Tests that the activity under test maintains the spinner's state when the activity is
     * paused and then resumed.
     *
     * Calls the activity's onResume() method. Changes the spinner's state by
     * altering the activity's View. This means the test must run
     * on the UI Thread. All the statements in the test method may be run on
     * that thread, so instead of using the runOnUiThread() method, the
     * @UiThreadTest is used.
     */
    @UiThreadTest
    public void testStatePause() {
        /*
         * Get the instrumentation object for this application. This object
         * does all the instrumentation work for the test runner
         */
        Instrumentation instr = this.getInstrumentation();
        /*
         * Set the activity's fields for the position and value of the spinner
         */
        mActivity.setSpinnerPosition(TEST_STATE_PAUSE_POSITION);
        mActivity.setSpinnerSelection(TEST_STATE_PAUSE_SELECTION);
        /*
         *  Use the instrumentation to onPause() on the currently running Activity.
         *  This analogous to calling finish() in the testStateDestroy() method.
         *  This way demonstrates using the test class' instrumentation.
         */
        instr.callActivityOnPause(mActivity);
        /*
         * Set the spinner to a test position
         */
        mActivity.setSpinnerPosition(0);
        mActivity.setSpinnerSelection("");
        /*
         * Call the activity's onResume() method. This forces the activity
         * to restore its state.
         */
        instr.callActivityOnResume(mActivity);
        /*
         * Get the current state of the spinner
         */
        int currentPosition = mActivity.getSpinnerPosition();
        String currentSelection = mActivity.getSpinnerSelection();
        assertEquals(TEST_STATE_PAUSE_POSITION,currentPosition);
        assertEquals(TEST_STATE_PAUSE_SELECTION,currentSelection);
  }

 Spinner restoreSpinner = (Spinner)findViewById(R.id.Spinner01);
        restoreSpinner.setSelection(getSpinnerPosition());

总结

本文链接:https://www.it72.com/6025.htm