Understanding Code Coverage in Java: A Comprehensive Guide

Anon from Bulgaria introduces the tutorial on code coverage in Java, outlining the topics to be covered, including theory, advantages, code demos, configuring plugins, types of code coverage, and end-to-end system testing for backend code coverage.

Anon explains the creation of a simple code coverage report by demonstrating a sample Java project with a 'calculator' class for mathematical operations like addition, subtraction, multiplication, division, square, factorial, and power. The project uses Maven and JUnit for unit testing.

Anon delves into the concept of code coverage as a metric to measure the extent to which an application's code is exercised by its test suite. He illustrates that achieving high code coverage, such as 88%, indicates thorough testing and ensures the quality and functionality of the code.

Code coverage is crucial in software development as it helps identify untested parts of the code, ensuring high testing standards as software evolves with new features and bug fixes. A higher percentage of code coverage leads to early bug detection, minimizing production issues. It also aids in evaluating code scalability, maintaining quality, and guiding developers towards comprehensive testing for a better software product.

Code coverage provides clear and quantifiable metrics for developers to assess code health effectively. It helps pinpoint areas lacking sufficient testing, encourages writing modular testable code, and identifies and removes redundant or dead code. Code coverage acts as a tool for building robust, high-quality software, guiding developers and testers towards fewer bugs and ultimately a better software product.

While backend and frontend developers primarily write unit tests, software test automation engineers or QA professionals use unit tests in various forms for API tests, end-to-end tests, system tests, and integration tests. Educating developers about the benefits of unit testing and code coverage is crucial. It is essential to ensure developers write modular, testable code and use code coverage reports to measure the effectiveness of their testing efforts.

JaCoCo operates by instrumenting Java code through a runtime agent attached to the Java Virtual Machine, known as JaCoCo agent. It tracks how lines of code are called during testing, collecting coverage data on the fly. Post-testing, JaCoCo generates code coverage reports either at JVM termination or on demand in server mode. Integrating JaCoCo with Maven involves configuring the JaCoCo Maven plugin in the pom.xml file, specifying goals like prepare agent and report to record and create code coverage reports.

Specific goals can be added in code coverage by defining new check goals that verify specified rules. These rules are specified in the rule tag, allowing flexibility to specify multiple rules. The goal is to use these checks to monitor code coverage percentages.

Rules in code coverage are applied to specific elements, such as at the package level. Limits like counter value minimum are used to restrict code coverage percentages. Commands like 'maven clean verify' can validate if rules are followed.

Running a higher number of tests, such as 14 in total, can lead to achieving almost 100% code coverage. However, reducing the number of tests significantly lowers the code coverage percentage.

Code coverage calculates the lines covered by tests executed. By focusing on specific methods with more lines of code, even a few tests can significantly increase code coverage percentages.

There are different types of code coverage beyond statement coverage, including branch coverage, path coverage, condition coverage, and decision coverage. These types are crucial for certifications in critical software industries like medical or military.

Statement coverage measures the percentage of executed statements or lines of code, aiming to execute all statements at least once. It helps identify untested sections of the code. The formula for statement coverage is the number of executed statements divided by the total number of statements multiplied by 100.

Branch coverage, also known as decision coverage, ensures that each branch (true and false) in the code is executed. It evaluates both true and false conditions of decision points, including if-else statements, switch cases, and others. The formula for branch coverage is the number of branches executed divided by the total number of branches multiplied by 100.

Branch condition coverage focuses on testing complex conditional expressions that depend on multiple smaller conditions. It involves testing every atomic part (condition without logical operators) with true or false. The goal is to achieve 100% coverage by testing all atomic parts.

Branch condition combination coverage expands on branch condition coverage by testing all possible combinations of atomic conditions in decision statements. This type of coverage requires testing all possible combinations, which can be challenging for complex statements with many atomic conditions.

There are hierarchical testing levels including statement coverage, branch coverage, branch condition coverage, branch condition combination coverage, and selective combination coverage. Each level offers a more thorough testing approach than the previous one, helping uncover potential issues in the code and improving software quality.

Using UI or end-to-end tests written in WebDriver or other frameworks can help calculate backend coverage, providing a metric to determine what parts of the code are covered by UI or system tests. This approach depends on the server technology used. It is a useful method to assess test coverage and ensure comprehensive testing of the backend.

A demo website was created in Node.js to showcase registration, activation, and password reset functionalities. The website is open source and requires setting up free accounts and configurations. Previous videos covered authentication testing, including login, profile registration, integration of third-party services for email and SMS verification, test user registration via API, and bypassing two-factor authentication.

The server code was combined with Bootstrap, HTML, and JavaScript to create a demo. Istanbul, a JavaScript code coverage tool, was used to track code execution during tests. Istanbul computes statements, line, function, and branch coverage, providing insights into areas needing more testing. It was integrated to measure code coverage during Selenium UI tests, aiding in understanding code execution and progress.

Babel was used to compile the code, and Istanbul was integrated into the app to calculate code coverage. The coverage report showed almost 40% coverage of the server JS code. Code coverage analysis helps in identifying areas for additional testing and serves as a metric for progress. Selenium UI tests can measure server-side code coverage by instrumenting the code.

The test setup included dependencies like RestAssured for testing APIs, Twilio for passwordless login with SMS, JUnit for testing, Selenium and WebDriver for browser automation. WebDriverManager was used for managing drivers, but Selenium 4.11 and above have built-in driver management. Mswp, a third-party service, was used for single sign-on and passwordless authentication.

Authentication tests included login with different users, checking login status, testing remember me functionality, and updating user profiles. WebDriverManager was used to download the Chrome driver before tests. The tests were run successfully, showing green results, and code coverage was recorded by Istanbul. The coverage report was generated after stopping the server.

Regardless of where tests are run, as long as the application is integrated with Lambda Test Cloud, code coverage will be calculated. Using a capabilities generator to generate capabilities for Lambda Test Cloud, providing username and access as environmental variables, and running the tests will result in a report. Different technologies may require specific tools for code coverage, such as instrumenting code with Jacoco for Java setups.

While high code coverage is important, it should not be the sole metric for test quality. Code coverage indicates the percentage of code run by tests, not their effectiveness or coverage of edge cases. It is essential to combine code coverage with other quality measures and good testing practices.

Lambda Test Cloud offers integrations with tools like Airc Tracer, which can enhance code coverage analysis. Depending on the code base, compatibility with Airc Tracer should be verified. Explore documentation on code coverage tools to determine suitability. Different languages may have specific recommended tools, like Inano for Node.js or other tools for Java or Kotlin applications.

Encouraging audience engagement, the speaker invites questions and suggestions for future videos. Emphasizing community involvement, viewers are encouraged to follow the blog, participate in the Lambda Test Community, and pursue free certifications in JUnit and Selenium. The speaker expresses eagerness to interact with the audience and hints at upcoming content.