dependencies {
    testImplementation ‘junit:junit:4.12‘
    androidTestImplementation ‘com.android.support.test:runner:1.0.2‘
    androidTestImplementation ‘com.android.support.test.espresso:espresso-core:3.0.2‘
}

testImplementation ‘junit:junit:4.12‘

assertEquals(4, 2 + 2);
assertNull(null);

import static org.junit.Assert.*;

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Test {

    /**
     * Default empty exception
     */
    static class None extends Throwable {
        private static final long serialVersionUID = 1L;

        private None() {
        }
    }

    /**
     * Optionally specify <code>expected</code>, a Throwable, to cause a test method to succeed if
     * and only if an exception of the specified class is thrown by the method. If the Throwable‘s
     * message or one of its properties should be verified, the
     * {@link org.junit.rules.ExpectedException ExpectedException} rule can be used instead.
     */
    Class<? extends Throwable> expected() default None.class;

    /**
     * Optionally specify <code>timeout</code> in milliseconds to cause a test method to fail if it
     * takes longer than that number of milliseconds.
     * <p>
     * <b>THREAD SAFETY WARNING:</b> Test methods with a timeout parameter are run in a thread other than the
     * thread which runs the fixture‘s @Before and @After methods. This may yield different behavior for
     * code that is not thread safe when compared to the same test method without a timeout parameter.
     * <b>Consider using the {@link org.junit.rules.Timeout} rule instead</b>, which ensures a test method is run on the
     * same thread as the fixture‘s @Before and @After methods.
     * </p>
     */
    long timeout() default 0L;
}

@RunWith(Suite.class)
@Suite.SuiteClasses( { CalculaterTest.class, CalculaterTest2.class } )//被测试类
public class SuiteTest {
...
}

@RunWith(Parameterized.class)
public class CalculaterTest3 {
    private int expected;
    private int a;
    private int b;

    @Parameters//创建并返回测试数据
    public static Collection params() {
        return Arrays.asList(new Integer[][] { { 3, 1, 2 }, { 5, 2, 3 } });
}

    //接收并存储（实例化）测试数据
    public CalculaterTest3(int expected, int a, int b) {
        this.expected = expected;
        this.a = a;
        this.b = b;
    }

    @Test
    public void sum() throws Exception {
        Calculater calculater = new Calculater();
        System.out.println("parameters : " + a + " + " + b);
        int result = calculater.sum(a, b);
        assertEquals(expected, result);
    }
}

public class MyRule implements TestRule {

    @Override
    public Statement apply(final Statement base, final Description description) {

        return new Statement() {
            @Override
            public void evaluate() throws Throwable {
                // evaluate前执行方法相当于@Before
                String methodName = description.getMethodName(); // 获取测试方法的名字
                System.out.println(methodName + "测试开始！");

                base.evaluate();  // 运行的测试方法

                // evaluate后执行方法相当于@After
                System.out.println(methodName + "测试结束！");
            }
        };
    }
}

assertThat(String reason, T actual, Matcher<? super T> matcher)

public class IsMobilePhoneMatcher extends BaseMatcher<String> {

    /**
     * 进行断言判定，返回true则断言成功，否则断言失败
     */
    @Override
    public boolean matches(Object item) {
        if (item == null) {
            return false;
        }

        Pattern pattern = Pattern.compile("(1|861)(3|5|7|8)\\d{9}$*");
        Matcher matcher = pattern.matcher((String) item);

        return matcher.find();
    }

    /**
     * 给期待断言成功的对象增加描述
     */
    @Override
    public void describeTo(Description description) {
        description.appendText("预计此字符串是手机号码！");
    }

    /**
     * 给断言失败的对象增加描述
     */
    @Override
    public void describeMismatch(Object item, Description description) {
        description.appendText(item.toString() + "不是手机号码！");
    }
}

@RunWith(AndroidJUnit4.class)
public class ExampleInstrumentedTest {
    @Test
    public void useAppContext() throws Exception {
        // Context of the app under test.
        Context appContext = InstrumentationRegistry.getTargetContext();

        assertEquals("com.yangge.myapplication", appContext.getPackageName());
    }
}

    /**
     * Returns the instrumentation currently running. Use this to get an {@link Instrumentation}
     * into your test.
     *
     * @throws IllegalStateException if instrumentation hasn‘t been registered
     */
    public static Instrumentation getInstrumentation() {
        Instrumentation instance = sInstrumentationRef.get();
        if (null == instance) {
            throw new IllegalStateException("No instrumentation registered! "
                    + "Must run under a registering instrumentation.");
        }
        return instance;
    }
//使用时直接调用该静态方法即可：InstrumentationRegistry.getInstrumentation()

    /**
     * Return a Context for the target application being instrumented. Use this to get a
     * {@link Context} representing {@link Instrumentation#getTargetContext()} into your test.
     */
    public static Context getTargetContext() {
        return getInstrumentation().getTargetContext();
    }

@RunWith(AndroidJUnit4.class)
public class ExampleInstrumentedTest {
    @Before
    public void testBefore() throws Exception {
        LogUtil.e("JUnit","testBefore");
    }

    @Test
    public void useAppContext() throws Exception {
        // Context of the app under test.
        Context appContext = InstrumentationRegistry.getTargetContext();
        LogUtil.e("JUnit","testTest");
        assertEquals("com.yangge.myapplication", appContext.getPackageName());
    }

    @Test
    public void testTest() throws Exception {
        LogUtil.e("JUnit","testTest");
    }

    @Test
    @SmallTest
    public void testTestSmallTest() throws Exception {
        LogUtil.e("JUnit","testTestSmallTest");
    }

    @SmallTest
    public void testSmallTest() throws Exception {
        LogUtil.e("JUnit","testSmallTest");
    }

    @MediumTest
    public void testMediumTest() throws Exception {
        LogUtil.e("JUnit","testMediumTest");
    }

    @LargeTest
    public void testLargeTest() throws Exception {
        LogUtil.e("JUnit","testLargeTest");
    }

    @RequiresDevice
    public void testRequiresDevice() throws Exception {
        LogUtil.e("JUnit","testRequiresDevice");
    }

    @SdkSuppress(minSdkVersion = 19)
    public void testSdkSuppress() throws Exception {
        LogUtil.e("JUnit","testSdkSuppress");
    }

    @After
    public void testAfter() throws Exception {
        LogUtil.e("JUnit","testAfter");
    }
}