What should be the unit test coverage of Java functions?

Java function unit test coverage is an indicator of test effectiveness. The recommended goals are: line coverage 80-90%, method coverage 100%, and branch coverage 50-75%. Use JaCoCo tools to measure coverage and identify uncovered parts based on coverage reports. Improve coverage by adding test cases, using stub and mock objects, introducing test data generators and other techniques to ensure that the test suite covers all possible branches and paths. .

Unit Test Coverage for Java Functions: Metrics and Practical Examples

Introduction

Unit test coverage is a key metric for measuring the effectiveness of a test suite. This article explores unit test coverage for Java functions and provides a practical example of how to measure and improve coverage.

Measuring Coverage

There are various tools in Java that can be used to measure unit test coverage. One of the most commonly used tools is JaCoCo, which provides coverage reports and shows which lines, methods, and branches are covered by tests.

To use JaCoCo, you can add the following dependencies in Maven or Gradle:

<dependency>
  <groupId>org.jacoco</groupId>
  <artifactId>jacoco-maven-plugin</artifactId>
  <version>0.8.7</version>
</dependency>

After running the test and installing the JaCoCo plug-in, you can add it in the target/jacoco.exec file Find the coverage report.

Coverage Criteria

Ideal unit test coverage varies by project and language. For Java functions, generally recommended coverage goals:

• Line coverage: 80-90%
• Method coverage: 100%
• Branch coverage: 50-75%

Practical case

Consider the following Java function:

public int sum(int a, int b) {
  return a + b;
}

Uncovered tests:

@Test
public void testSumPositive() {
  assertEquals(5, sum(2, 3));
}

This test only covers the path a >= 0 && b >= 0. Other paths (a and <code>a >= 0 && b ) are not covered.

Full Coverage Tests:

@Test
public void testSumPositive() {
  assertEquals(5, sum(2, 3));
}

@Test
public void testSumNegative() {
  assertEquals(-5, sum(-2, -3));
}

@Test
public void testSumMixed() {
  assertEquals(0, sum(2, -2));
}

This test suite covers all possible branches, thus achieving 100% line, method and branch coverage.

Tips for Improving Coverage

Some Tips for Improving Unit Test Coverage:

• Use Coverage Reports to Identify Uncovered Sections .
• Write test cases to cover specific branches and paths.
• Use stub and mock objects to isolate function dependencies.
• Write tests for key methods.
• Introducing a test data generator to expand the scope of testing.

The above is the detailed content of What should be the unit test coverage of Java functions?. For more information, please follow other related articles on the PHP Chinese website!