Android unit testing framework JUnit 4

The JUnit 4 testing framework, which is one of the widely used unit testing frameworks in Java, enables developers to write repeatable, maintainable and verifiable tests.

Meaning of unit testing

Unit testing is testing individual units or components in the code and can include the following:

Functional testing: Tests that a unit of code performs its function as expected.
Boundary testing: Tests whether a unit of code responds correctly to different boundary conditions.
Exception testing: Test whether a code unit throws an appropriate exception when it encounters an unexpected situation.
Performance testing: Test whether performance indicators such as code unit performance, response time, and memory usage meet expectations.
Compatibility testing: Test whether the code unit behaves consistently in different environments (such as different operating systems, different models).
Security testing: Test code units for potential security vulnerabilities.
Maintainability test: Test whether the code unit is easy to maintain, such as code readability, scalability, etc.

The purpose of unit testing is to cover various situations of the code unit as comprehensively as possible, thereby improving the quality and stability of the code.

Detailed usage of JUnit 4 test framework

Download and configure the JUnit 4 library

Add the following dependencies to Gradle:

testImplementation 'junit:junit:4.13.2'

Write basic tests

The test class needs to meet the following requirements:

Class name ending with Test (or declared as a JUnit 4 test class with @RunWith(JUnit4.class) annotation)
Each test method is marked with @Testan annotation
Adding @Before, @After, @BeforeClass, @AfterClass annotations in front of each test method can define some operations performed before or after the test method respectively.

In your Java project, create a test package and add a test class. In this class, you can write test methods to test various aspects of your Java class methods. For example, here is a simple example:

import org.junit.Test;
import static org.junit.Assert.assertEquals;
 
public class MyTest {
    
    
   
   @Test
   public void testAdd() {
    
    
      int sum = 1 + 2;
      assertEquals(3, sum);
   }
}

In the example above, we tested a simple addition operation using assertEquals()the method .

run test

You can use various tools of JUnit to run your tests. The simplest of these is the JUnit Runnerclass . You can add @RunWithannotations and set their values JUnit4.classto to tell the JUnit runner which methods to test in that test class. For example:

import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
 
@RunWith(JUnit4.class)
public class MyTest {
    
    
   @Test
   public void testAdd() {
    
    
      int sum = 1 + 2;
      assertEquals(3, sum);
   }
}

run multiple tests

When you define multiple test methods, you can use a test suite (Test Suite) to combine them and run them. @SuiteClassesYou can tell JUnit the names of these test classes by creating a test suite class, adding test classes to it, and using JUnit annotations. For example:

import org.junit.runner.RunWith;
import org.junit.runners.Suite;
 
@RunWith(Suite.class)
@Suite.SuiteClasses({
    
     MyTest.class, AnotherTest.class })
public class AllTests {
    
    
}

What is shown here is MyTestto AnotherTestorganize and run the test methods of the test class together in a suite.

Use other annotations

JUnit 4 provides various annotations to control the behavior of tests. These annotations include @Before, @After, @BeforeClass, @AfterClass, and@Ignore . @Test(expected=…)For example, in the following example we use @BeforeClassthe annotation setUp()to open the database connection and other initialization operations in the method that is executed only once when the test class runs.

import org.junit.BeforeClass;
import org.junit.Test;
 
public class MyTest {
    
    
   private static DatabaseConnection connection;
 
   @BeforeClass
   public static void setUp() {
    
    
      // Open database connection and other initialization
   }
   
   @Test
   public void testAdd() {
    
    
      // Test addition
   }
   
   @Test
   public void testSubtract() {
    
    
      // Test subtraction
   }
}

In conclusion, JUnit 4 is a powerful Java testing framework that makes writing and running test cases easier and more convenient. Through the elaboration of the above usage methods, I hope you have a deeper understanding of the JUnit 4 testing framework.

JUnit 4 annotations and methods

JUnit 4 provides many useful methods and annotations, all of which can assist developers in writing more reliable and robust test cases.

@Test- Indicates a test method, methods using this annotation will be considered as test cases
@Before- Indicates a method that should be run before each test method
@After- Indicates the method that should be run after each test method
@BeforeClass- Indicates a method that is run only once before all test methods
@AfterClass- Indicates a method that is run only once after all test methods
@Ignore- Indicates to skip this test method in the test suite
@Test(expected = exception.class)- Indicates that the test method should throw an exception, which helps to test whether the abnormal situation is caught and handled

JUnit 4 provides Assertclasses for verifying expected behavior during testing. AssertA class has multiple methods such as:

assertEquals()- checks if two values are equal
assertTrue()/ assertFalse()- checks if a condition is true or false
assertNotNull()/ assertNull()- check if the object is null
assertSame()/assertNotSame()- Used to verify whether two object references are equal or not
assertThat()- method is used to verify whether an expression satisfies certain conditions, such as greater than, less than, etc.