Junit | can’t write unit tests, like don’t wear long Johns bear children running in the winter

In my previous Android development career, barely used unit test, never seen anyone to introduce, as if this is not very important thing in the domestic developers eyes, there is no specific time or most of the development of students to use the unit test framework, perhaps more important reason is my personal informed.

background

What are unit tests?

Unit testing is writing test code for the smallest unit. In Java, the smallest unit of functionality is a method, so unit testing a Java program is testing a single Java method.

Why do unit tests

In foreign countries, the actual development process is often, write the test first, after the test is written, then start to write the implementation code. In the concrete implementation process, while writing while testing, when all the tests passed, it represents the completion of the development task. This is also known as TDD(Test Driven Development).

Introduction to the

Junit is an open source unit testing framework for the Java language, designed specifically for Java and most widely used. (Of course, Kotlin is also ok to use, just pay attention to some small details)

Depend on the way

Maven

<dependencies>
 	<dependency>
    	<groupId>junit</groupId>
    	<artifactId>junit</artifactId>
    	<version>4.12</version>
    	<scope>test</scope>
	</dependency>
</dependencies>
Copy the code

Gradle

dependencies {
	testImplementation 'junit: junit: 4.12'
}
Copy the code

The main method

The main methods in the Assert class are as follows:

Note that all of the above methods have their own overloaded methods, which can be preceded by a String parameter indicating that the assertion fails.

Commonly used annotations

Execution order: @beforeClass – > @before – > @test – > @after – > @AfterClass

use

Based on using

So let’s say we have an algorithm that’s equivalent to parentheses.

StackExample.kt

Equivalent braces / * * *, such as: given a string represented by the sequence of brackets, contain the following characters: '(',') ', '{','} ', '[' and'] ', to determine whether effective brackets sequence. * parentheses must be in accordance with the "()" order said, "() [] {}" is a valid brackets, but "([]" bracket is invalid. * * Solution idea: * Use stack storage to cut a string into char traversal, first storing symbols in the specified direction, such as '(','{','['). * return false * */ if the stack top symbol is equal to the current char and the stack is not null
fun isBrackets(str: String): Boolean {
    if (str.length < 2) return false
    val stack = Stack<Char>()
    str.forEach {
        if ("{([".contains(it)) {
            stack.push(it)
        } else {
            if (stack.isNotEmpty() && isBracketChart(stack.peek(), it)) {
                stack.pop()
            } else return false}}return stack.isEmpty()
}


private fun isBracketChart(str1: Char, str2: Char): Boolean =
    (str1 == '{' && str2 == '} ') ||
            (str1 == '[' && str2 == '] ') || (str1 == '(' && str2 == ') ')
Copy the code

Code testing (not using Junit)

If we were not using Junit, we might have written the following test code:

fun main(a) {
    println(isBrackets("{}"))
  	xxxx...
}
Copy the code

In contrast, if we added other methods, the main() method would have to be changed frequently, and the correctness of the test would not be intuitive.

Using Junit

We create a class like StackExampleKtTest under the corresponding test package, or we directly use the following shortcut, using MAC (Option + Enter) and Windows (CTRL + Enter) before the corresponding method, as shown in the figure

The following is an example:

StackExampleKtTest

class StackExampleKtTest {

    @Test
    fun testIsBrackets(a) {
        assertArrayEquals(
            booleanArrayOf(
                isBrackets(""),
                isBrackets("{"),
                isBrackets("{{}}"),
                isBrackets("{} ({})"),
                isBrackets("{{}"),
            ), booleanArrayOf(
                false.false.true.true.false))}}Copy the code

Parametric test

The above method of use, if we have to set the corresponding value every time we test a method, it is relatively tedious, then how to use successive different values to test the same method, so that we can avoid not to modify for many times, save some time. Use @runWith and @parameters.

Add a RunWith(paramterize.class) annotation to the test class, create a static method annotated by @paramters that returns a set of test data, and create a constructor whose parameters are in a sequence corresponding to the set of test data.

The following is an example:

@RunWith(Parameterized::class)
class StackExampleKtTest(private val str: Pair<String, Boolean>) {

    // TODO:In turn, this approach makes it hard to find errors
    companion object {
        @Parameterized.Parameters
        @JvmStatic
        fun primeStrings(a): Collection<Pair<String, Boolean>> =
            listOf(
                "" to false."{" to false."{}" to false."{[]}" to true."asd{()}" to false)}@Test
    fun testIsBrackets(a) {
      	// Notice the error message here
        assertEquals("Error - current \"${str.first}\" to ${str.second}",
            str.second, isBrackets(str.first))
    }
}
Copy the code

Note: The corresponding @parameterized. Parameters method used in Kotlin requires the addition of @jVMStatic. In the process of using this parameterized test, if we do not add an error message, it may not be easy to find which test case is wrong when looking for problems, so we need to pay attention to this.

AssertThat usage

Used to improve readability of output after assertion failures. By default, assertion failures only raise an AssertionError, and we have no way of knowing what went wrong, and assertThat is there to solve that problem.

Common matcher arrangement:

@Rule

During the test process, we can also add @before or @after to provide a prompt Before and After the test, but it may be a bit cumbersome to write this every time. So you can use @rule at this point.

The following is an example:

TestPrompt

 class TestPormpt : TestRule {
    override fun apply(statement: Statement, description: Description): Statement {

        // Get the test method name
        val methodName: String = description.methodName
        // equivalent to @before
        println(methodName + "Before the test begins!")

        // The test method to run
        statement.evaluate()

        // Run complete, equivalent to @after
        println(methodName + "Test over!")
        return statement
    }
}
Copy the code

class StackExampleKtTest {

    // TODO: 2020/11/15
    // Note: When used in Kotlin, you need to change @rule to @get:Rule
    //  或者 使用 @Rule @JvmField
    //@get:Rule
    @Rule @JvmField
    public val prompt = TestPormpt()
  
// @Before
// fun testStart(){
// println(" test open ")
/ /}
//
// @After
// fun testStop(){
//        println("测试关")
/ /}

    @Test
    fun testThat(a) {
        assertThat("123", equalTo("123"))}}Copy the code

reference

• Liao Xuefeng – Writing JUnit tests
• Android Unit Testing part 1: Use of the JUnit framework