Android程序员如何写好Unit Test

最新推荐文章于 2024-05-04 19:50:18 发布
最新推荐文章于 2024-05-04 19:50:18 发布
阅读量2.4k 收藏 3
点赞数 1
分类专栏： 经验总结 文章标签： android java junit unittest 单元测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zeng280091932/article/details/111416210
版权

目录

 

什么是Unit Test

Android单元测试分类

构建有效的单元测试

本地测试

仪器化测试

Robolectric

自动执行界面测试

测试单个应用界面

Espresso 基本使用

使用 Espresso Intent 单独测试 Activity

其他

测试多个应用界面

官方资料

什么是Unit Test

Unit Test即单元测试，单元测试是应用测试策略中的基本测试。通过针对代码创建和运行单元测试，您可以轻松验证各个单元的逻辑是否正确。在每次构建后运行单元测试可帮助您快速捕捉和修复由应用的代码更改导致的软件回归。
测试应用是应用开发过程中不可或缺的一部分。通过持续对应用运行测试，您可以在公开发布应用之前验证其正确性、功能行为和易用性。


测试还会为您提供以下优势：

  • 快速获得故障反馈。
  • 在开发周期中尽早进行故障检测。
  • 更安全的代码重构，让您可以优化代码而不必担心回归。
  • 稳定的开发速度，帮助您最大限度地减轻技术负担。

Android单元测试分类

为了测试 Android 应用，您通常会创建下面这些类型的自动化单元测试：

  • 本地测试(Local tests): 只在本地机器JVM上运行，以最小化执行时间，这种单元测试不依赖于Android框架，或者即使有依赖，也很方便使用模拟框架来模拟依赖，以达到隔离Android依赖的目的，模拟框架如google推荐的Mockito；
  • 仪器化测试(Instrumented tests): 在真机或模拟器上运行的单元测试，由于需要跑到设备上，比较慢，这些测试可以访问仪器（Android系统）信息，比如被测应用程序的上下文，一般地，依赖不太方便通过模拟框架模拟时采用这种方式。

构建有效的单元测试

本地测试

根据单元有没有外部依赖（如Android依赖、其他单元的依赖），将本地测试分为两类，首先看看没有依赖的情况：

  • 添加依赖，google官方推荐
    dependencies {
        //Required--JUnit 4 framework
        testImplementation 'junit:junit:4.12'
    }
  • 单元测试代码存储位置

事实上，AS已经帮我们创建好了测试代码存储目录。

app/src

     ├── androidTestjava (仪器化单元测试、UI测试)

     ├── main/java (业务代码)

     └── test/java  (本地单元测试)

  • 创建测试类

可以自己手动在相应目录创建测试类，AS也提供了一种快捷方式：选择对应的类->将光标停留在类名上->按下ALT + ENTER->在弹出的弹窗中选择Create Test

 

Note: 勾选setUp/@Before会生成一个带@Before注解的setUp()空方法，tearDown/@After则会生成一个带@After的空方法。

package com.example.hellounittest;

import ...

public class EmailValidatorTest {

    @Test
    public void isValidEmail() {
        assertThat(EmailValidator.isValidEmail("name@email.com"), is(true));
    }
}

上面的写法已过时，如果您更愿意使用 junit.Assert 其他方法来比较预期结果与实际结果，也可以改用这些库，比如：

package com.example.hellounittest;

import ...

public class EmailValidatorTest {

    @Test
    public void isValidEmail() {
        assertTrue(EmailValidator.isValidEmail("name@email.com"));
    }
}
  • 运行测试用例
  1. 运行单个测试方法：选中@Test注解或者方法名，右键选择Run；
  2. 运行一个测试类中的所有测试方法：打开类文件，在类的范围内右键选择Run，或者直接选择类文件直接右键Run；
  3. 运行一个目录下的所有测试类：选择这个目录，右键Run。
  • 运行前面测试验证邮箱格式的例子，测试结果会在Run窗口展示，如下图：

 

从结果可以清晰的看出，测试的方法为 EmailValidatorTest 类中的 isValidEmail()方法，测试状态为passed，耗时12毫秒。

修改一下前面的例子，传入一个非法的邮箱地址：

@Test
public void isValidEmail() {
    assertTrue(EmailValidator.isValidEmail("#name@email.com"));
}

 

测试状态为failed，耗时19毫秒，同时也给出了详细的错误信息：在11行出现了断言错误。

  • 总结一些常用的JUnit注解

Annotation

描述

@Test public void method()

定义所在方法为单元测试方法

@Test (expected = Exception.class) public void method()

测试方法若没有抛出Annotation中的Exception类型(子类也可以)->失败

@Test(timeout=100) public void method()

性能测试，如果方法耗时超过100毫秒->失败

@Before public void method()

 

这个方法在每个测试之前执行，用于准备测试环境(如: 初始化类，读输入流等)，在一个测试类中，每个@Test方法的执行都会触发一次调用。

@After public void method()

这个方法在每个测试之后执行，用于清理测试环境数据，在一个测试类中，每个@Test方法的执行都会触发一次调用。

@BeforeClass public static void method()

这个方法在所有测试开始之前执行一次，用于做一些耗时的初始化工作(如: 连接数据库)，方法必须是static

@AfterClass public static void method()

这个方法在所有测试结束之后执行一次，用于清理数据(如: 断开数据连接)，方法必须是static

@Ignore或者@Ignore("太耗时") public void method()

忽略当前测试方法，一般用于测试方法还没有准备好，或者太耗时之类的

@FixMethodOrder(MethodSorters.NAME_ASCENDING) public class TestClass{}

使得该测试类中的所有测试方法都按照方法名的字母顺序执行，可以指定3个值，分别是DEFAULT、JVM、NAME_ASCENDING

  • 通过模拟框架模拟依赖，隔离依赖

前面验证邮件格式的例子，本地JVM虚拟机就能提供足够的运行环境，但如果要测试的单元依赖了Android框架，比如用到了Android中的Context类的一些方法，本地JVM将无法提供这样的环境，这时候模拟框架Mockito就派上用场了。

添加依赖

//Optional--Mockito framework（可选，用于模拟一些依赖对象，以达到隔离依赖的效果）
testImplementation 'org.mockito:mockito-core:2.19.0'

一个Context.getString(int)的测试用例

package com.example.hellounittest;

import ...

@RunWith(MockitoJUnitRunner.class)
public class MockUnitTest {
    private static final String FAKE_STRING = "AndroidUnitTest";

    @Mock
    private Context mMockContext;

    @Test
    public void readStringFromContext() {
        //模拟方法调用的返回值，隔离对Android系统的依赖
        when(mMockContext.getString(R.string.app_name)).thenReturn(FAKE_STRING);
        Assert.assertEquals(mMockContext.getString(R.string.app_name), FAKE_STRING);

        when(mMockContext.getPackageName()).thenReturn("com.example.hellounittest");
        System.out.println(mMockContext.getPackageName());
    }
}

 

通过模拟框架Mockito，指定调用context.getString(int)方法的返回值，达到了隔离依赖的目的。

仪器化测试

在某些情况下，虽然可以通过模拟的手段来隔离Android依赖，但代价很大，这种情况下可以考虑仪器化的单元测试，有助于减少编写和维护模拟代码所需的工作量。

仪器化测试是在真机或模拟器上运行的测试，它们可以利用Android framework APIs 和 supporting APIs。如果测试用例需要访问仪器(instrumentation)信息(如应用程序的Context)，或者需要Android框架组件的真正实现(如Parcelable或SharedPreferences对象)，那么应该创建仪器化单元测试，由于要跑到真机或模拟器上，所以会慢一些。

  • 配置
dependencies {

    androidTestImplementation 'androidx.test.ext:junit:1.1.2'
    androidTestImplementation 'androidx.test:runner:1.3.0'
    androidTestImplementation 'androidx.test:rules:1.3.0'

}

android {
    ...

    defaultConfig {
        ...
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"

    }
}
  • Example

这里举一个操作SharedPreference的例子，这个例子需要访问Context类以及SharedPreference的具体实现，采用模拟隔离依赖的话代价会比较大，所以采用仪器化测试比较合适。

这是业务代码中操作SharedPreference的实现

package com.example.hellounittest;


import ...


public class SharedPreferenceDao {
    private SharedPreferences mSharedPreferences;

    public SharedPreferenceDao(SharedPreferences sp) {
        this.mSharedPreferences = sp;
    }

    public SharedPreferenceDao(Context context) {
        this(context.getSharedPreferences("config", Context.MODE_PRIVATE));
    }

    public void put(String key, String value) {
        SharedPreferences.Editor editor = mSharedPreferences.edit();
        editor.putString(key, value);
        editor.apply();
    }

    public String get(String key) {
        return mSharedPreferences.getString(key, null);
    }
}

创建仪器化测试类（app/src/androidTest/java）

package com.example.hellounittest;

import ...

public class SharedPreferenceDaoTest {
    private static final String TEST_KEY = "instrumentedTest";
    private static final String TEST_VALUE = "仪器化测试";

    private SharedPreferenceDao mSpDao;

    @Before
    public void setUp() throws Exception {
        mSpDao = new SharedPreferenceDao(App.getContext());
    }

    @Test
    public void sharedPreferenceDaoWriteRead(){
        mSpDao.put(TEST_KEY, TEST_VALUE);
        Assert.assertEquals(TEST_VALUE, mSpDao.get(TEST_KEY));
    }
}

运行方式和本地单元测试一样，这个过程会向连接的设备安装apk，测试结果将在Run窗口展示，如下图：

 

通过测试结果可以清晰看到状态passed，通过am instrument命令运行instrumented测试用例，该命令的一般格式：

am instrument [flags] <test_package>/<runner_class>

例如本例子中的实际执行命令：

    adb shell am instrument -w -r    -e debug false -e class 'com.example.hellounittest.SharedPreferenceDaoTest' com.example.hellounittest.test/androidx.test.runner.AndroidJUnitRunner

    -w: 强制 am instrument 命令等待仪器化测试结束才结束自己(wait)，保证命令行窗口在测试期间不关闭，方便查看测试过程的log
    -r: 以原始格式输出结果(raw format)
    -e: 以键值对的形式提供测试选项，例如 -e debug false

    关于这个命令的更多信息请参考
    https://developer.android.com/studio/test/command-line?hl=zh-cn

 

这里可以看出，这个过程向模拟器安装了两个apk文件，分别是HelloUnitTest和com.example.hellounittest.test，instrumented测试相关的逻辑在com.example.hellounittest.test中。最新版中，google对仪器化测试进行了很大的优化。从命令上来看是直接通过am instrument命令运行instrumented测试用例，感受不到两个apk的安装过程，速度上有了大大的提升。如果业务逻辑足够复杂，那么仪器化测试仍然会非常耗时。如果你实在没法忍受instrumented test的耗时问题，业界也提供了一个现成的方案Robolectric。

Robolectric

主要是解决仪器化测试中耗时的缺陷，仪器化测试需要安装以及跑在Android系统上，也就是需要在Android虚拟机或真机上面，所以十分的耗时，基本上每次来来回回都需要几分钟时间。针对这类问题，业界其实已经有了一个现成的解决方案: Pivotal实验室推出的Robolectric，通过使用Robolectrict模拟Android系统核心库的Shadow Classes的方式，我们可以像写本地测试一样写这类测试，并且直接运行在工作环境的JVM上，十分方便。

  • 添加配置
    testImplementation 'org.robolectric:robolectric:4.2.1'
    android {
      ...
      testOptions {
        unitTests {
          includeAndroidResources = true
        }
      }
    }
  • Example

模拟打开MainActivity，点击界面上面的Button，读取TextView的文本信息。

以下是MainAcitivity代码

    package com.example.hellounittest;

    import ...

    public class MainActivity extends AppCompatActivity {

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);

            final TextView textView = findViewById(R.id.textView);
            Button button = findViewById(R.id.button);
            button.setOnClickListener(v -> textView.setText("Robolectric Rocks!"));
        }
    }

测试类MainActivityTest(注意这个测试类是放在app/src/test/java/目录下的，因为这是一段本地测试代码)

    package com.example.hellounittest;

    import ...

    @RunWith(RobolectricTestRunner.class)
    public class MainActivityTest {
        @Test
        public void clickingButtonTest() throws Exception {
            MainActivity activity = Robolectric.setupActivity(MainActivity.class);
            Button button =  activity.findViewById(R.id.button);
            TextView results = activity.findViewById(R.id.textView);

            //模拟点击按钮，调用OnClickListener#onClick
            button.performClick();
            Assert.assertEquals("Robolectric Rocks!", results.getText().toString());
        }
    }

运行本段代码，发现它很本地化测试一样，无需运行模拟器或真机，测试结果如下：

 

前面的小节介绍了通过仪器化测试的方式跑到真机上进行测试SharedPreferences操作，可能吐槽的点都在于耗时太长，现在通过Robolectric改写为本地测试来尝试减少一些耗时。

在实际的项目中，Application可能创建时可能会初始化一些其他的依赖库，不太方便单元测试，这里额外创建一个Application类，不需要在清单文件注册，直接写在本地测试目录即可。 

public class RoboApp extends Application {}

在编写测试类的时候需要通过@Config(application = RoboApp.class)来配置Application，当需要传入Context的时候调用RuntimeEnvironment.application来获取：

    package com.example.hellounittest;

    import ...

    @RunWith(RobolectricTestRunner.class)
    @Config(application = RoboApp.class)
    public class RobolectricSharedPreferenceDaoTest {
        public static final String TEST_KEY = "instrumentedTest";
        public static final String TEST_VALUE = "仪器化测试";

        SharedPreferenceDao spDao;

        @Before
        public void setUp() {
            //这里的Context采用RuntimeEnvironment.application来替代应用的Context
            spDao = new SharedPreferenceDao(RuntimeEnvironment.application);
        }

        @Test
        public void sharedPreferenceDaoWriteRead() {
            spDao.put(TEST_KEY, TEST_VALUE);
            Assert.assertEquals(TEST_VALUE, spDao.get(TEST_KEY));
        }
    }

运行上面的代码，会发现它想本地化测试一样跑起来了

自动执行界面测试

通过界面测试，您可以确保应用满足其功能要求并达到较高的质量标准，从而更有可能成功地被用户采用。

界面测试的一种方法是直接让测试人员对目标应用执行一系列用户操作，并验证其行为是否正常。不过，这种人工方法会非常耗时、繁琐且容易出错。一种更高效的方法是编写界面测试用例，以便以自动化方式执行用户操作。自动化方法可让您以可重复的方式快速可靠地运行测试。

测试单个应用界面

测试单个应用内的用户交互有助于确保用户在与应用交互时不会遇到意外结果或体验不佳的情况。如果您需要验证应用的界面是否正常运行，应养成创建界面测试的习惯。      

Espresso 基本使用

由 AndroidX Test 提供的 Espresso 测试框架提供了一些 API，用于编写界面测试以模拟单个目标应用内的用户交互。Espresso 测试可以在搭载 Android 2.3.3（API 级别 10）及更高版本的设备上运行。使用 Espresso 的主要好处在于，它可以自动同步测试操作与您正在测试的应用的界面。Espresso 会检测主线程何时处于空闲状态，以便可以在适当的时间运行测试命令，从而提高测试的可靠性。此外，借助该功能，您不必在测试代码中添加任何计时解决方法，如 Thread.sleep()。       

Espresso 测试框架是基于插桩的 API，可与 AndroidJUnitRunner 测试运行程序一起使用。

配置 Espresso

androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'

在测试设备上关闭动画 - 如果让系统动画在测试设备上保持开启状态，可能会导致意外结果或导致测试失败。通过以下方式关闭动画：在“设置”中打开“开发者选项”，然后关闭以下所有选项：   

  1. 窗口动画缩放       
  2. 过渡动画缩放       
  3. Animator 时长缩放      

Example

针对上文的MainActivity，我们再写一个Espresso框架的界面测试用例

    package com.example.hellounittest;

    import ...

    @RunWith(AndroidJUnit4.class)
    public class MainActivityTest {
        @Rule
        public ActivityTestRule<MainActivity> activityRule
                = new ActivityTestRule<>(MainActivity.class);

        @Test
        public void clickingButtonTest() throws Exception {
            onView(withId(R.id.button)).perform(click());
            onView(withId(R.id.textView)).check(matches(withText("Robolectric Rocks!")));
        }
    }

通过使用 ActivityTestRule，测试框架会在带有 @Test 注释的每个测试方法运行之前以及带有 @Before 注释的所有方法运行之前启动被测 Activity。该框架将在测试完成并且带有 @After 注释的所有方法都运行后关闭该 Activity。

运行上面的测试用例，会在模拟器中启动app，并自动执行用例中的操作。最终得到如下测试结果。

 

执行操作

调用 onView() 方法并传入用于指定目标视图的视图匹配器，onView() 方法将返回一个 ViewInteraction 对象。调用 ViewInteraction.perform() 或 DataInteraction.perform() 方法，以模拟界面组件上的用户交互。您必须将一个或多个 ViewAction 对象作为参数传入。Espresso 将按照给定的顺序依次触发每项操作，并在主线程中执行这些操作。

ViewActions 类提供了用于指定常见操作的辅助程序方法的列表。您可以将这些方法用作方便的快捷方式，而不是创建和配置单个 ViewAction 对象。您可以指定以下操作：

      如果目标视图位于 ScrollView 内，请先执行 ViewActions.scrollTo() 操作以在屏幕中显示该视图，然后再继续执行其他操作。如果已显示该视图，则 ViewActions.scrollTo() 操作将不起作用。

使用 Espresso Intent 单独测试 Activity

Espresso Intent 支持对应用发出的 intent 进行验证和打桩。使用 Espresso Intent，您可以通过以下方式单独测试应用、Activity 或服务：拦截传出 intent，对结果进行打桩，然后将其发送回被测组件。

  • 配置Espresso Intent
  1. androidTestImplementation 'androidx.test.espresso:espresso-intents:3.3.0'

如需测试 intent，您需要创建 IntentsTestRule 类（与 ActivityTestRule 类非常相似）的实例。IntentsTestRule 类会在每次测试前初始化 Espresso Intent，终止托管 Activity，并在每次测试后释放 Espresso Intent。

  • Example

现在有两个Activity，FirstActivity可以输入一个字符串并点击按钮将字符串发送大SecondActivity，SecondActivity接收到字符串后，将字符串显示到界面上。

以下是FirstActivity代码：

    package com.example.hellounittest;

    import ...

    public class FirstActivity extends AppCompatActivity {
        public static final String EXTRA_MESSAGE = "com.example.myfirstapp.MESSAGE";

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_first);
        }

        public void sendMessage(View view) {
            Intent intent = new Intent(this, SecondActivity.class);
            EditText editText = (EditText) findViewById(R.id.edit_message);
            String message = editText.getText().toString();
            intent.putExtra(EXTRA_MESSAGE, message);
            startActivity(intent);
        }
    }

以下是SecondActivity代码：

    package com.example.hellounittest;

    import ...

    public class SecondActivity extends AppCompatActivity {

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_second);

            Intent intent = getIntent();
            String message = intent.getStringExtra(FirstActivity.EXTRA_MESSAGE);

            TextView textView = findViewById(R.id.textView);
            textView.setText(message);
        }

    }

现在新建一个测试类SimpleIntentTest用于验证两个Activity直接传递的Intent是否正确，代码如下：

    package com.example.hellounittest;

    import ...

    @RunWith(AndroidJUnit4.class)
    public class SimpleIntentTest {
        private static final String MESSAGE = "This is a test";
        private static final String PACKAGE_NAME = "com.example.hellounittest";

        /* Instantiate an IntentsTestRule object. */
        @Rule
        public IntentsTestRule<FirstActivity> intentsRule =
                new IntentsTestRule<>(FirstActivity.class);

        @Test
        public void verifyMessageSentToMessageActivity() {
            // 在EditText控件中输入一个字符串
            onView(withId(R.id.edit_message))
                    .perform(typeText(MESSAGE), closeSoftKeyboard());

            // 点击按钮，发送一个消息到第二个Activity
            onView(withId(R.id.send_message)).perform(click());
            
            //验证SecondActivity接收到了一个包含正确报名和消息的intent
            intended(allOf(
                    hasComponent(hasShortClassName(".SecondActivity")),
                    toPackage(PACKAGE_NAME),
                    hasExtra(FirstActivity.EXTRA_MESSAGE, MESSAGE)));
        }
    }

运行结果如下：

 

测试结果通过，耗时954ms

其他

Espresso还可以测试WebView，可以参考官方示例。

测试多个应用界面

通过涉及多个应用中的用户交互的界面测试，您可以验证当用户流跨入其他应用或系统界面时，您的应用是否能够正常运行。 

UI Automator 测试框架来编写此类界面测试。通过 UI Automator API，您可以与设备上的可见元素进行交互，而不管焦点在哪个 Activity 上。您的测试可以使用方便的描述符（如显示在相应组件中的文本或其内容描述）来查找界面组件。 

I Automator 测试框架是基于插桩的 API，可与 AndroidJUnitRunner 测试运行程序一起使用。 

配置 UI Automator

androidTestImplementation 'androidx.test.uiautomator:uiautomator:2.2.0'

Example

下面的例子演示在App和Launcher之间切换。在测试App功能之前会先回到Launcher，然后再从Launcher启动App，然后测试App首页的功能。测试代码如下：

    package com.example.hellounittest;

    import ...

    @RunWith(AndroidJUnit4.class)
    public class ChangeTextBehaviorTest {
        private static final String BASIC_SAMPLE_PACKAGE = "com.example.hellounittest";
        private static final int LAUNCH_TIMEOUT = 5000;
        private static final String STRING_TO_BE_TYPED = "Robolectric Rocks!";

        private UiDevice mDevice;

        @Before
        public void startMainActivityFromHomeScreen() {
            // 初始化UiDevice对象
            mDevice = UiDevice.getInstance(getInstrumentation());

            // 模拟按下home键回到桌面
            mDevice.pressHome();

            // 等待回到桌面
            final String launcherPackage = getLauncherPackageName();
            assertThat(launcherPackage, notNullValue());
            mDevice.wait(Until.hasObject(By.pkg(launcherPackage).depth(0)), LAUNCH_TIMEOUT);

            // 启动自己的测试app
            Context context = getApplicationContext();
            final Intent intent = context.getPackageManager()
                    .getLaunchIntentForPackage(BASIC_SAMPLE_PACKAGE);
            intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);    // Clear out any previous instances
            context.startActivity(intent);

            // 等待自己的测试app启动
            mDevice.wait(Until.hasObject(By.pkg(BASIC_SAMPLE_PACKAGE).depth(0)), LAUNCH_TIMEOUT);
        }

        @Test
        public void testChangeText_sameActivity() {
            // Type text and then press the button.
            mDevice.findObject(By.res(BASIC_SAMPLE_PACKAGE, "button"))
                    .click();

            // Verify the test is displayed in the Ui
            UiObject2 changedText = mDevice
                    .wait(Until.findObject(By.res(BASIC_SAMPLE_PACKAGE, "textView")), 500);
            assertThat(changedText.getText(), is(equalTo(STRING_TO_BE_TYPED)));
        }


        private String getLauncherPackageName() {
            // Create launcher Intent
            final Intent intent = new Intent(Intent.ACTION_MAIN);
            intent.addCategory(Intent.CATEGORY_HOME);

            // Use PackageManager to get the launcher package name
            PackageManager pm = getApplicationContext().getPackageManager();
            ResolveInfo resolveInfo = pm.resolveActivity(intent, PackageManager.MATCH_DEFAULT_ONLY);
            return resolveInfo.activityInfo.packageName;
        }
    }

运行上面的代码，会看到模拟器先回到桌面，然后再启动App,然会点击App首页的按钮，最后验证字符串是否改变。最后测试结果如下：

 

UiDevice 对象是您访问和操纵设备状态的主要方式。在测试中，您可以调用 UiDevice 方法检查各种属性的状态，如当前屏幕方向或显示屏尺寸。您的测试可以使用 UiDevice 对象执行设备级操作，如强制设备进行特定旋转、按方向键硬件按钮，以及按主屏幕和菜单按钮。

UI Automator 测试类的编写方式应与 JUnit 4 测试类相同。在测试类定义的开头添加 @RunWith(AndroidJUnit4.class) 注释。

在 UI Automator 测试类中实现以下编程模型：

  1. 通过调用 getInstance() 方法并将 Instrumentation 对象作为参数传递给该方法，获取 UiDevice 对象以访问要测试的设备。
  2. 通过调用 findObject() 方法，获取 UiObject 对象以访问设备上显示的界面组件（例如，前台的当前视图）。   
  3. 通过调用 UiObject 方法，模拟需要在该界面组件上执行的特定用户交互；例如，调用 performMultiPointerGesture() 以模拟多点触控手势，以及调用 setText() 以修改文本字段。您可以根据需要反复调用第 2 步和第 3 步中的 API，以测试涉及多个界面组件或用户操作序列的更复杂的用户交互。
  4. 执行这些用户交互后，检查界面是否反映了预期的状态或行为。
  5. 启动更多操作请参考官方文档

官方资料

针对Android的测试还有很多，比如针对Service的测试，比如针对ContentProvider的测试等。这些测试同上面的针对Activity的测试差异不大。详细的测试资料可参考官方资料：

https://developer.android.com/training/testing/unit-testing/


 

JT·Zeng
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Android-UnitTest
最美的路百转千回
04-14 1195
Android单元测试概述现在国内很多开发人员都没有写单元测试的习惯，但写单元测试能减少很多不必要的麻烦。现在我们就从以下来介绍下单元测试。 一、什么是单元测试 单元测试是开发者编写的一小段代码，用于检验被测代码中的一个很明确的功能是否正确，其中，单元指的是测试的最小模块。通常而言，一个单元测试是用于判断某个特定条件(或者场景)下某个特定函数的行为。单元测试的代码不会被编译进入APK中。 二、单元测试目标函数
AndroidUnitTest:Android单元测试
04-30
AndroidUnitTest 单元测试是应用程序测试策略中的基本测试，通过对代码进行单元测试，可以轻松地验证单个单元的逻辑是否正确，在每次构建之后运行单元测试，可以帮助您快速捕获和修复因代码更改（重构、优化等）带来的回归问题。本文主要聊聊Android中的单元测试，主要内容如下： 单元测试的目的以及测试内容 Android中的单元测试分类 JUnit注解 本地单元测试 仪器化单元测试 常用的单元测试开源库 实践经验 其他 一、单元测试的目的以及测试内容 为什么要进行单元测试？ 提高稳定性，能够明确地了解是否正确的完成开发； 快速反馈bug，跑一遍单元测试用例，定位bug； 在开发周期中尽早通过单元测试检查bug，最小化技术债，越往后可能修复bug的代价会越大，严重的情况下会影响项目进度； 为代码重构提供安全保障，在优化代码时不用担心回归问题，在重构后跑一遍测试用例，没通过说明重构可能是有
2024年Android最全Android Unit Test 入门，BAT大厂面试基础题集合
最新发布
2401_84545862的博客
05-04 821
在此为大家准备了四节优质的Android高级进阶视频：架构师项目实战——全球首批Android开发者对Android架构的见解。
Android测试-unitTest
moxiouhao的专栏
07-19 1742
1 概述去年的一个电商的项目做完了，已经上线了，客户回来找我们做单元测试，性能测试，安全性测试，一堆测试项。我的内心是崩溃的，项目都上线了，隔了几个月了，项目组都换了两批了。没办法，客户是上帝，于是研究了一下Android目前的一些测试规范，记录一下吧。2 为什么要做测试理清代码逻辑，让程序更加健壮，方法变更后跑一遍测试，若结果正确则证明没有影响到别的方法，更快的排查错误。测试分类： 单元测试 测试
Android 单元测试，从小白到入门开始
热门推荐
走一段令人留恋的路，做一个不负自己的人
10-14 1万+
1 引言 1.1 背景 随着 Android 应用越来越壮大，对应代码量显著增加，代码逻辑也日趋复杂，此时需要采取一定的行动去保证代码质量，减少逻辑漏洞等，于是严格地执行单元测试编写任务，将单元测试落实到平常开发和维护任务当中去，就是很重要的一环，不可忽视。 然而，很多应用开发者之前并未编写过单元测试代码，那么如果有一篇通俗易懂并带有操作步骤的文章，能帮助应用开发者完成从单元测试小白到入门的过渡，就再好不过了，于是本文就是在此情况写就的，如有不好之处，请多多包涵，谢谢...
Android unitTest 按键单元测试项目
10-08
关于Android 单元测试的一个案例，按键点击事件测试
作为程序员写好软件的诀窍
03-23
作为程序员写好软件的诀窍。程序员身上的一个好笑的事情是，我们在毕生的职业生涯中都相信：我们的工作是告诉计算机如何去做。真实情况 　程序员身上的一个好笑的事情是，我们在毕生的职业生涯中都相信：我们的工作...
Android程序员简历最新版
06-25
Android程序员简历最新版
Android程序员转正工作总结.doc
12-18
【Android程序员转正工作总结】 这份工作总结是一位Android程序员在试用期结束后对自己工作的全面回顾和反思。他在xxxx年9月11日加入公司，作为一名.NET程序员，经历了三个月的试用期。在这段时间里，他不仅在专业...
android程序员简历08.doc
02-06
Android 程序员简历模板 Android 程序员简历模板是一份完整的简历模板，涵盖了 Android 程序员的个人信息、工作经历、项目经验、职业技能等方面的信息。本简历模板旨在帮助 Android 程序员快速构建自己的简历，提高...
在Android中同时使用unit test和instrument test作为单元测试
测试蜗牛，一步一个脚印
05-15 2447
转载：http://www.jianshu.com/p/4b03123b4f81 前言 作为开发人员，我们需要编写必要的单元测试以验证程序的稳定性，而且单元测试也可以用来验证重构的结果。 Android官方现在提供了两种测试途径Android Unit Test 和Android Instrument Test。本篇主要介绍他们各自的运行方式，测试结果和测试覆盖率结果生成
AndroidUT：Android开发中必要的一环---单元测试（Unit Test）
02-04
AndroidUT 当前分支为androidx ， support在master分支。 具体说明（已完结） 更新说明 2020.01.16 1.完善jacoco配置。 2.dagger 使用`@Component.Factory` 替换 `@Component.Builder` 。 2019.10.21 1.适配AndroidX。（support部分暂停维护） 2019.10.15 1.更新依赖库至最新。 2.修改Robolectric配置写法。
android unit test
weixin_33747129的博客
03-10 93
2019独角兽企业重金招聘Python工程师标准>>> ...
Android单元测试之Local unit tests（下）
Monster-L的专栏
04-10 703
Android单元测试之Local unit tests（下） 前言 Robolectric 添加依赖 测试例子-Robolectric基本使用 无处不在的 shadowXXX 是什么？ 测试例子-Robolectric使用进阶 @Config(qualifiers =”“) 配置 测试例子-Activity的生命周期 自定义Shdow类 附加模块 JUnit 4 &amp; Mocki...
java unit test怎么写_Java J Unit Test
weixin_34234884的博客
02-24 468
来test三角形area和perimeter(周长)的method。三角形的class如下packageedu.susqu.CSCI471.Test01;importjava.util.Date;publicclassTriangle{publicTriangle(Pointp1,Pointp2,Poin...来test三角形area 和perimeter(周长)的method。三角形的class...
Python3 代码测试--unittest 写法
Victordas的技术笔记
09-08 466
省略类和方法 测试写法 import unittest class TestConvert(unittest.TestCase): def test_equal(self): func = Solution().twoSum #调用方法主题 self.assertEqual(func([3, 2, 4], 6), [1, 2]) ...
Android单元测试-对Activity的测试
许佳佳的博客
08-15 9937
前提概要 上一篇文章已经介绍了单元测试的作用和简单示例，如果不了解的读者可以先阅读上一篇 Android单元测试-作用以及简单示例。 这篇文章主要介绍常见的Activity中的测试。 对Acitivity的测试 对于Activity，我们大致有两种测试需求： 1、在Activity正常启动后，查看界面布局是否正确，包括View的点击事件等是否正确。 2、需要在Activity启动前...
Android Studio系列-Activity单元测试
巫山老妖
02-22 9259
前言上一篇讲的是如何在Android Studio中进行Junit单元测试，这篇来简单记录一下如何针对Activity进行单元测试。新建一个项目我这里新建一个UnitTestDemo项目新建LoginActivity、IndexActivtypackage com.devilwwj.unittestdemo;import android.app.Activity; import android.co
用android studio写程序员计算器
06-08
好的，我可以为你提供一些基本的步骤和思路。 1. 创建一个新的 Android Studio 项目，并选择空白 Activity 模板。 2. 在布局文件中添加所需的 UI 元素，例如 TextView、EditText、Button 等。你需要创建一个界面，让用户输入要计算的数据和选择计算的进制。 3. 在 Activity 中添加代码来处理用户的输入和计算逻辑。你需要编写代码来将用户输入的字符串转换为相应的数字，并进行计算。可以使用 Java 或 Kotlin 编程语言来编写代码。 4. 实现各种程序员运算符和函数。你需要编写代码来处理各种程序员运算符和函数，例如位运算符（&、|、^、~、<<、>>）、逻辑运算符（&&、||、!）、移位运算符（>>>）、取反运算符（~）、以及其他一些常用的函数（例如计算一个数的二进制位数）。 5. 调试和测试应用程序。你需要使用 Android Studio 提供的调试工具来调试代码，并使用模拟器或真实设备进行测试。 这些只是一些基本的步骤和思路，实际开发过程中可能会涉及到更多的细节和具体实现方式。希望这些信息能对你有所帮助！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值