This article walks through adjusting Java unit tests with ChatGPT, measuring coverage using JaCoCo, rewriting test code for User and PasswordRecovery classes, adding Mockito and PowerMock mocks, and showing how the changes raise coverage from 73.7% to over 80% across the project.
This article presents a detailed, step‑by‑step guide on improving unit test coverage in large Java codebases, covering strategies such as mocking, divide‑and‑conquer, tool‑assisted test generation, reflection‑based coverage, Maven configuration, and practical tips for handling static methods, final classes, and test data replay.
This guide explains what unit testing is, its benefits, the AIR principles of good tests, step‑by‑step Java test creation with JUnit and Mockito, and how the AI tool Tongyi Lingma can quickly generate reliable unit tests.
This article explains why upgrading JDK 11 prompts the removal of the unmaintained PowerMock framework, outlines the steps to replace it with Mockito‑Only—including JUnit runner configuration, handling static, private, and final methods, multithreaded mock limitations, and performance gains—while providing code examples and migration tips.
This article presents a concise, beginner-friendly approach to building a Spring Boot unit testing environment using only essential Maven dependencies and test classes, covering both integration-style and pure unit test techniques, complete with annotated examples and practical testing tips.
This article explains the core concepts of the Mockito framework, compares it with other Java unit‑testing tools, demonstrates practical code examples, and breaks down the internal workings of annotations like @InjectMocks, @Mock, @RunWith, as well as the Mockito.when() and Mockito.verify() mechanisms.
This article explains what unit testing is, why it is essential for software quality, outlines its benefits such as early bug detection and design improvement, and provides practical guidance on writing effective Java unit tests using JUnit5, Mockito, and JaCoCo, along with CI integration and best‑practice principles.
This article explores Test‑Driven Development (TDD), explaining its core concepts, common misconceptions, tool choices such as JUnit, Mockito and JaCoCo, and provides practical case studies including a simple calculator and layered architecture examples in both anemic and DDD models.
This article explains the fundamentals of Test‑Driven Development (TDD), highlights common misconceptions, guides tool selection, and walks through a complete Java TDD case study—including a strange calculator example, multi‑iteration refactoring, and DDD‑based testing—showing how to improve code quality and maintainability.
This article explains why unit tests should focus on verifying behavior rather than merely increasing coverage, outlines essential testing principles such as AIR, FIRST, and ASCII, provides concrete Java examples for writing, validating, and asserting tests, and offers detailed guidance on handling exceptions and method‑call verification to avoid ineffective testing.
This article demonstrates how to use JUnit's Assert methods for various checks, creates mock objects and verifies interactions with Mockito, and leverages Java 8 Stream's peek operation for debugging, providing complete code examples for each technique.
The article outlines how to design robust SpringBoot unit tests by first mastering business flows and external dependencies, preparing isolated test data, using Mockito’s @Mock/@MockBean and @Spy/@SpyBean correctly—including proper stubbing techniques—and applying best‑practice rules and the ACTS 2.0 framework for data‑driven, coverage‑verified testing.
This tutorial explains how to install and use the Squaretest IntelliJ plugin to automatically generate unit test methods for Java classes, covering setup, template selection, generated code examples, handling of getters/setters, and tips for achieving high test coverage quickly.
Unit testing in Java projects, essential for catching over 90% of bugs early, follows the AIR (Automatic, Independent, Repeatable) and BCDE (Boundary, Correct, Design, Error) principles, uses Mockito’s Mock‑Do‑Verify pattern, automated IDE generation, JaCoCo coverage metrics, CI pipelines, achieving 85‑+% coverage, zero production incidents, and guides future TDD adoption.
This article examines common unit‑testing problems in Java projects, analyzes their root causes such as development and maintenance costs, and presents practical solutions including choosing JUnit5, leveraging Mockito, using in‑memory databases, and employing a custom IntelliJ plugin to automatically generate test code and test data.
The article walks through a step‑by‑step evolution of a simple isEmpty utility, demonstrates proper JUnit assertions, introduces Mockito for isolating complex service logic, and explains Spring Boot Test components, illustrating why thorough unit testing saves time and improves code quality.
This article provides a step‑by‑step guide on mocking static variables and static methods in the Spock testing framework using PowerMock, covering annotation setup, custom behavior definitions, and handling mixed scenarios where both static and instance mocks are required.
This article walks through setting up Spock for Java/Groovy projects, lists required Maven dependencies, shows how to handle static‑method mocking with PowerMock and Mockito, and provides concrete code examples for mocking @Autowired components, shared objects, and defining mock behavior.
Part 4 of Airbnb’s Android testing series presents a dedicated framework that lets developers write concise, single‑function unit tests for ViewModel classes by specifying initial state, parameters, and expected state or dependency calls through a Kotlin DSL, integrating with JUnit, Robolectric, Mockito, and offering scaffolding and IntelliJ plugins for streamlined, systematic ViewModel logic verification.
The author describes encountering quality‑assurance challenges in Spring Boot, revisiting unit‑testing frameworks like Spock, Mockito, and PowerMock, struggling with static‑method mocking, and ultimately adopting a "reset and rebuild" strategy to resolve dependency conflicts and improve test coverage.
This article shows how to streamline Java backend unit tests by loading JSON fixtures, deserializing them into objects, and re‑serializing results for concise assertions, while providing naming conventions, Maven setup, FastJSON tricks, and advanced Mockito techniques to replace verbose manual object construction.
This article introduces Mockito, a Java mocking framework, explains when to use it for testing code with external dependencies, and provides step‑by‑step guidance—including Maven setup, creating mock objects in Scala, and configuring mock behavior—complete with code snippets and reference links.
This comprehensive guide walks Java developers through the principles and practical steps of writing high‑coverage unit tests using Mockito and PowerMock, covering framework basics, Maven dependencies, typical service code, test case structure, mocking techniques, verification methods, exception handling, and common pitfalls with solutions.
This comprehensive guide walks you through writing effective Java unit tests, covering test framework basics, Maven dependencies, typical code examples, step‑by‑step test case creation, mocking techniques with Mockito and PowerMock, verification strategies, handling special cases, and best practices for achieving high coverage.
This comprehensive guide walks Java developers through setting up PowerMock and Mockito, demonstrates creating and spying on mocks, stubbing methods, using parameter matchers, verifying interactions—including static and private members—and explains essential annotations and best‑practice principles for robust, maintainable unit tests.
This article explains how to simplify complex Java code by using PowerMock and Mockito for unit testing, covering environment setup, mock, spy, when, parameter matchers, verification, static method mocking, private field and method handling, and essential annotations with practical code examples.
This article explains what unit testing is, why it’s essential, common obstacles, best practices for writing effective Java unit tests, including naming conventions, assertions, mocking strategies, and design principles for testable code.
TestableMock is a lightweight Java mock testing tool that eliminates initialization and framework dependencies, allowing any method—including private, static, or constructor—to be replaced with a single @MockMethod annotation, dramatically simplifying unit test development.
This article explores why unit testing is essential, how to conquer the psychological obstacles that prevent developers from writing tests, and provides practical methodologies such as TDD, BDD, the test pyramid, and the Fixture‑Scenario‑Case pattern with concrete Java examples.
This article explains what makes good code, introduces SOLID and other design principles, defines unit testing, outlines its benefits, provides before‑and‑after Java refactoring examples, and reviews essential testing tools like Fast‑tester, JUnit and Mockito along with coverage metrics.
This article explains how to use Mockito's doNothing, doAnswer, doThrow, and doCallRealMethod to mock void methods in Java, demonstrating parameter verification, argument capture, and real‑method invocation with detailed code examples and reasoning behind each approach.
This guide explains why unit testing matters, compares Java testing tools, introduces PowerMock’s capabilities, details essential annotations, shows how to configure dependencies, and provides step‑by‑step code examples for mocking public, final, static, private, constructor, field and superclass methods.
This article introduces the Groovy‑based Spock framework and the Mockito mocking library, shows how to configure them together in Gradle, and provides detailed Groovy demo code illustrating various mocking, spying, verification, and exception‑handling techniques for robust Java unit testing.
This tutorial guides you through creating a basic Spring Boot calculator app, adding JUnit 4 tests, then fully migrating the project to JUnit 5 by updating dependencies, rewriting test annotations, and leveraging new JUnit 5 features such as @ExtendWith and @DisplayName.
This article explains why Android testing is crucial, outlines common testability problems, and provides step‑by‑step solutions using MVP architecture, interface‑based design, JUnit, Mockito, Robolectric, Espresso, and CI integration to create maintainable unit and UI tests.
This article explains the fundamentals of unit testing in Java, covering what unit tests are, why they matter, when to write them, and detailed step‑by‑step examples using Mockito, PowerMock, JUnit, and Spring Boot to mock dependencies, verify behavior, and assert results across DAO, service, and controller layers.
The article explains why many developers avoid unit testing despite its importance, demonstrates a Java method for filtering unpromised tools in a home‑renovation app, provides complete JUnit and Groovy/Spock test implementations, and shows how richer output from Groovy/Spock can speed debugging.
This article explains Youzan’s layered unit‑testing framework for microservice applications, outlines typical pain points such as massive test‑case rewrites, unstable test data, and missing result verification, and demonstrates how tools like DbUnit, H2, springockito, spring‑test and PowerMock are combined to provide data preparation, mock injection, automatic cleanup, and declarative result checks.
Learn how to use MockMvc in Spring Boot to simulate HTTP requests, test controller logic without launching a server, and verify responses with concise code examples, covering dependency setup, controller creation, test class configuration, request execution, assertions, and common testing scenarios.
This article explains the importance of unit testing in Android development, outlines why developers should invest time in it, and provides a step‑by‑step guide on writing effective Android unit tests using JUnit, Mockito, Dagger2, and Robolectric, along with practical tips, CI integration, and common pitfalls.
This article shares practical experiences and best practices for Android unit testing, covering why testing matters, simple test structures, mocking with Mockito, dependency injection via Dagger2, using Robolectric, CI integration, common pitfalls, and a detailed checkout flow example.
