To solve the problem of verifying arguments passed to mocked methods, especially when those arguments are not simple primitives or when you need to inspect their internal state, here are the detailed steps on how to use ArgumentCaptor in Mockito for effective Java testing:
👉 Skip the hassle and get the ready to use 100% working script (Link in the comments section of the YouTube Video) (Latest test 31/05/2025)
Check more on: How to Bypass Cloudflare Turnstile & Cloudflare WAF – Reddit, How to Bypass Cloudflare Turnstile, Cloudflare WAF & reCAPTCHA v3 – Medium, How to Bypass Cloudflare Turnstile, WAF & reCAPTCHA v3 – LinkedIn Article
- Declare
ArgumentCaptor: Start by declaring an instance ofArgumentCaptorfor the specific type of argument you want to capture. For example,ArgumentCaptor<MyObject> argument = ArgumentCaptor.forClassMyObject.class.. - Use
Mockito.verifywithArgumentCaptor: In yourMockito.verifycall, instead of usingMockito.anyorMockito.eq, passargument.capture. This tells Mockito to capture the argument passed to the method during the verification step. Example:Mockito.verifymyMockedService.doSomethingargument.capture.. - Retrieve the Captured Value: After the verification, you can retrieve the captured argument using
argument.getValue. This gives you the actual object that was passed to the method. Example:MyObject capturedObject = argument.getValue.. - Perform Assertions: Once you have the captured object, you can perform detailed assertions on its state, properties, or any other relevant attributes using assertion libraries like JUnit or AssertJ. Example:
assertEquals"expectedValue", capturedObject.getProperty.. - Capturing Multiple Arguments: If you need to capture multiple arguments for the same method call, you can call
argument.getAllValueswhich returns aListof all captured arguments for that method call. This is particularly useful when a method is called multiple times with different arguments and you want to inspect each invocation.
Understanding ArgumentCaptor in Mockito
ArgumentCaptor in Mockito serves as a powerful utility for verifying interactions with mocked objects, particularly when the arguments passed to a method are not simple primitives or when you need to inspect their internal state after the method call. Unlike any or eq, which perform immediate matching, ArgumentCaptor “captures” the actual argument value passed during a method invocation, allowing you to retrieve it and perform detailed assertions later. This capability is crucial for writing robust and precise unit tests in Java, enabling developers to confirm not just that a method was called, but how it was called, down to the specifics of the complex objects it received.
Why ArgumentCaptor is Essential for Robust Testing
Traditional Mockito matchers like any or eq fall short when you need to inspect the internal state of an object passed as an argument.
For instance, if a service method creates a new object internally and passes it to another dependency, you can’t directly assert on that created object using eq. ArgumentCaptor bridges this gap by allowing you to grab that transient object and assert its properties.
This leads to tests that are not only more accurate but also more readable, clearly outlining the expected interactions and the state of objects involved. Phantom js
According to a survey by JetBrains, over 80% of Java developers use JUnit for testing, and Mockito is a predominant mocking framework alongside it, highlighting the widespread need for tools like ArgumentCaptor to write effective tests in this ecosystem.
Setting Up Your Environment for Mockito Testing
Before into the specifics of ArgumentCaptor, ensuring your development environment is correctly set up is paramount.
This involves adding the necessary Mockito and testing framework dependencies to your project.
For most Java projects, this means configuring your pom.xml if you’re using Maven, or build.gradle if you’re using Gradle.
Maven Dependencies
If you’re working with Maven, you’ll need to include the following dependencies in your pom.xml file, typically within the <dependencies> section and scoped as test:
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
<version>5.10.0</version> <!-- Use the latest stable version -->
<scope>test</scope>
</dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<artifactId>junit-jupiter-engine</artifactId>
<!-- Optional: If you use AssertJ for fluent assertions -->
<groupId>org.assertj</groupId>
<artifactId>assertj-core</artifactId>
<version>3.25.0</version> <!-- Use the latest stable version -->
Remember to replace the version numbers with the latest stable releases to benefit from bug fixes and new features.
Checking repositories like Maven Central for mockito-core and junit-jupiter-api is a good practice.
Gradle Dependencies
For Gradle users, the setup is similar, but you’ll add these lines to your build.gradle file, usually in the dependencies block:
dependencies {
testImplementation 'org.mockito:mockito-core:5.10.0' // Use the latest stable version
testImplementation 'org.junit.jupiter:junit-jupiter-api:5.10.0' // Use the latest stable version
testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.10.0' // Use the latest stable version
// Optional: If you use AssertJ for fluent assertions
testImplementation 'org.assertj:assertj-core:3.25.0' // Use the latest stable version
}
Again, ensure you're using the most current stable versions. Once these dependencies are in place, your IDE like IntelliJ IDEA or Eclipse should be able to resolve them, allowing you to import `org.mockito.*` and `org.junit.jupiter.api.*` classes into your test files without issue. This foundational setup is crucial for any Mockito-based testing, laying the groundwork for effective use of `ArgumentCaptor`.
# Basic Usage of `ArgumentCaptor`
The fundamental use case for `ArgumentCaptor` is to capture a single argument passed to a mocked method and then assert on its properties.
This is invaluable when the argument is a custom object whose internal state you need to verify after the method call.
Capturing a Single Argument
Let's imagine you have a `UserService` that interacts with a `UserRepository`. When a user is saved, you want to ensure the `UserRepository` receives a `User` object with specific attributes.
Consider these example classes:
```java
// src/main/java/com/example/User.java
package com.example.
public class User {
private String username.
private String email.
private String status. // e.g., "PENDING_APPROVAL", "ACTIVE"
public UserString username, String email {
this.username = username.
this.email = email.
this.status = "PENDING_APPROVAL". // Default status
}
// Getters and Setters
public String getUsername {
return username.
public void setUsernameString username {
public String getEmail {
return email.
public void setEmailString email {
public String getStatus {
return status.
public void setStatusString status {
this.status = status.
@Override
public String toString {
return "User{" +
"username='" + username + '\'' +
", email='" + email + '\'' +
", status='" + status + '\'' +
'}'.
// src/main/java/com/example/UserRepository.java
public interface UserRepository {
void saveUser user.
User findByUsernameString username.
// src/main/java/com/example/UserService.java
public class UserService {
private UserRepository userRepository.
public UserServiceUserRepository userRepository {
this.userRepository = userRepository.
public void registerUserString username, String email {
User newUser = new Userusername, email.
// Potentially add more logic here, like setting an initial status or validation
userRepository.savenewUser.
Now, let's write a test for `UserService` using `ArgumentCaptor`:
// src/test/java/com/example/UserServiceTest.java
import org.junit.jupiter.api.BeforeEach.
import org.junit.jupiter.api.Test.
import org.mockito.ArgumentCaptor.
import org.mockito.InjectMocks.
import org.mockito.Mock.
import org.mockito.MockitoAnnotations.
import static org.junit.jupiter.api.Assertions.assertEquals.
import static org.mockito.Mockito.verify.
public class UserServiceTest {
@Mock
@InjectMocks
private UserService userService.
@BeforeEach
void setUp {
MockitoAnnotations.openMocksthis.
@Test
void testRegisterUser_capturesAndVerifiesUser {
String username = "johndoe".
String email = "[email protected]".
userService.registerUserusername, email.
// 1. Declare ArgumentCaptor for the User type
ArgumentCaptor<User> userCaptor = ArgumentCaptor.forClassUser.class.
// 2. Use ArgumentCaptor in Mockito.verify to capture the argument
verifyuserRepository.saveuserCaptor.capture.
// 3. Retrieve the captured value
User capturedUser = userCaptor.getValue.
// 4. Perform assertions on the captured object's properties
assertEqualsusername, capturedUser.getUsername, "Captured user username should match the input username.".
assertEqualsemail, capturedUser.getEmail, "Captured user email should match the input email.".
assertEquals"PENDING_APPROVAL", capturedUser.getStatus, "New user should have PENDING_APPROVAL status by default.".
In this example:
* We declare `userCaptor` for the `User.class`.
* When `verifyuserRepository.saveuserCaptor.capture` is called, Mockito intercepts the `save` method invocation on the `userRepository` mock. Instead of matching a specific `User` object, it captures the `User` object that was actually passed.
* `userCaptor.getValue` then retrieves this captured `User` object, allowing us to assert on its `username`, `email`, and `status` properties. This provides a high level of confidence that `UserService` correctly constructs and passes the `User` object to the repository.
This approach is significantly more powerful than using `anyUser.class` because it allows you to inspect the *specific instance* of `User` that was passed, ensuring its internal state is exactly as expected.
# Advanced `ArgumentCaptor` Scenarios
While capturing a single argument is straightforward, `ArgumentCaptor` shines in more complex scenarios, such as capturing multiple arguments from a single method call, or capturing arguments from multiple invocations of the same method.
Capturing Multiple Arguments from a Single Method Call
Sometimes, a method might take several complex objects as arguments, and you need to verify aspects of each.
You can declare multiple `ArgumentCaptor` instances, one for each argument type you wish to capture.
Let's extend our example with a new `NotificationService` that sends notifications based on user actions.
// src/main/java/com/example/NotificationService.java
public interface NotificationService {
void sendNotificationUser user, String message, String notificationType.
Now, suppose `UserService` also calls `NotificationService` after registering a user.
// src/main/java/com/example/UserService.java Modified
private NotificationService notificationService. // New dependency
public UserServiceUserRepository userRepository, NotificationService notificationService {
this.notificationService = notificationService.
notificationService.sendNotificationnewUser, "Welcome aboard!", "EMAIL_VERIFICATION".
In your test, you'd capture both the `User` object and the `String` message:
// src/test/java/com/example/UserServiceTest.java Modified for multiple captors
private NotificationService notificationService. // Mock the new dependency
void testRegisterUser_capturesMultipleArgumentsForNotification {
// Captor for the User object
// Captor for the message String
ArgumentCaptor<String> messageCaptor = ArgumentCaptor.forClassString.class.
// Captor for the notification type String
ArgumentCaptor<String> typeCaptor = ArgumentCaptor.forClassString.class.
// Capture all arguments in a single verify call
verifynotificationService.sendNotification
userCaptor.capture,
messageCaptor.capture,
typeCaptor.capture
.
String capturedMessage = messageCaptor.getValue.
String capturedType = typeCaptor.getValue.
assertEqualsusername, capturedUser.getUsername.
assertEqualsemail, capturedUser.getEmail.
assertEquals"Welcome aboard!", capturedMessage.
assertEquals"EMAIL_VERIFICATION", capturedType.
This demonstrates how multiple `ArgumentCaptor` instances can be used within a single `verify` call to capture different arguments, allowing for comprehensive assertion on the method's inputs.
Capturing Arguments from Multiple Invocations
What if a method is called multiple times, and you need to inspect the arguments passed during each invocation? `ArgumentCaptor` handles this beautifully with its `getAllValues` method.
Let's say you have a `BatchProcessor` that processes a list of items and calls a `Logger` for each item.
// src/main/java/com/example/LoggerService.java
public interface LoggerService {
void logString message, String level.
// src/main/java/com/example/BatchProcessor.java
import java.util.List.
public class BatchProcessor {
private LoggerService loggerService.
public BatchProcessorLoggerService loggerService {
this.loggerService = loggerService.
public void processItemsList<String> items {
for String item : items {
if item.contains"error" {
loggerService.log"Processing error for item: " + item, "ERROR".
} else {
loggerService.log"Processing item: " + item, "INFO".
}
}
Now, in your test, you can capture all messages and levels logged by `LoggerService`:
// src/test/java/com/example/BatchProcessorTest.java
import java.util.Arrays.
import static org.mockito.Mockito.times.
public class BatchProcessorTest {
private BatchProcessor batchProcessor.
void testProcessItems_capturesAllLogMessages {
List<String> items = Arrays.asList"item1", "item_error_2", "item3".
batchProcessor.processItemsitems.
// Captor for messages
// Captor for levels
ArgumentCaptor<String> levelCaptor = ArgumentCaptor.forClassString.class.
// Verify that log was called 3 times and capture all arguments
verifyloggerService, times3.logmessageCaptor.capture, levelCaptor.capture.
List<String> capturedMessages = messageCaptor.getAllValues.
List<String> capturedLevels = levelCaptor.getAllValues.
assertEquals3, capturedMessages.size.
assertEquals3, capturedLevels.size.
assertEquals"Processing item: item1", capturedMessages.get0.
assertEquals"INFO", capturedLevels.get0.
assertEquals"Processing error for item: item_error_2", capturedMessages.get1.
assertEquals"ERROR", capturedLevels.get1.
assertEquals"Processing item: item3", capturedMessages.get2.
assertEquals"INFO", capturedLevels.get2.
In this test:
* We use `times3` in `verify` to confirm `log` was called three times.
* `messageCaptor.getAllValues` and `levelCaptor.getAllValues` return lists containing all the captured messages and levels, respectively, in the order they were invoked. This allows for detailed verification of each individual interaction.
This `getAllValues` feature is extremely powerful for testing methods that perform iterative operations or repeatedly interact with a dependency, providing granular control over verification.
# `ArgumentCaptor` vs. `Mockito.any` and `Mockito.eq`
Understanding when to use `ArgumentCaptor` over other Mockito matchers like `Mockito.any` and `Mockito.eq` is crucial for writing effective and precise tests.
Each serves a different purpose, and choosing the right tool for the job can significantly improve test clarity and robustness.
`Mockito.any`
* Purpose: `Mockito.anySomeClass.class` is a very lenient matcher. It verifies that a method was called with *any* argument of a specific type. You use it when you don't care about the *value* or *state* of the argument, only that an argument of a certain type was passed.
* When to Use:
* When the argument is a primitive type or a simple object whose exact value isn't relevant to the test case.
* When you just want to confirm that a method was invoked, regardless of the input's specifics.
* When you don't need to inspect the argument's internal state.
* Example: `verifymyService.doSomethinganyString.class.` This verifies `doSomething` was called with any `String`.
* Limitation: You cannot retrieve the actual argument passed when using `any`. If you need to perform assertions on the captured argument, `any` is insufficient.
`Mockito.eq`
* Purpose: `Mockito.eqsomeValue` is a strict matcher. It verifies that a method was called with an argument that is *equal* to a specific expected value based on the argument's `equals` method.
* When dealing with primitive types or objects like `String`, `Integer`, `LocalDate`, or custom objects that correctly implement `equals` and `hashCode` where you know the exact expected value of the argument beforehand.
* When you want to ensure a specific, pre-defined object was passed.
* Example: `verifymyService.processDataeq"some-id", eq123.` This verifies `processData` was called with "some-id" and `123`.
* Limitation: For complex objects, if their `equals` method doesn't compare all relevant fields, or if the object is dynamically created within the system under test and you don't have a direct reference to an "equal" object to pass to `eq`, this matcher becomes less useful. It assumes you can construct an equivalent object for comparison.
`ArgumentCaptor`
* Purpose: `ArgumentCaptor` captures the actual argument passed to a mocked method, allowing you to retrieve it *after* the method call and then perform detailed assertions on its internal state.
* When the argument is a complex object e.g., a custom DTO, entity, or a class with many fields whose internal properties or state needs to be verified.
* When the argument object is *dynamically created* within the system under test, meaning you don't have a direct reference to it to use with `eq`.
* When you need to verify aspects of the argument that go beyond a simple `equals` check e.g., specific field values, collection sizes, or specific states set by the tested method.
* When you need to capture arguments from multiple invocations of the same method.
* Example: As shown in previous sections
```java
ArgumentCaptor<User> userCaptor = ArgumentCaptor.forClassUser.class.
verifyuserRepository.saveuserCaptor.capture.
User capturedUser = userCaptor.getValue.
assertEquals"testuser", capturedUser.getUsername.
```
* Advantages: Provides granular control over assertions on complex objects. Allows inspection of dynamically generated objects. Highly readable for complex argument verification.
* Consideration: `ArgumentCaptor` adds a few more lines of code compared to simple matchers, but the clarity and precision it offers often outweigh this minor overhead, especially for complex scenarios. It's not a replacement for `any` or `eq` but a powerful addition to your testing toolkit.
In summary:
* `any`: "I don't care what argument was passed, just that *an* argument of this type was there."
* `eq`: "I care that *this specific argument* equal to my provided value was passed."
* `ArgumentCaptor`: "I need to know *what* argument was passed so I can inspect its internal state or specific properties later."
Choose `ArgumentCaptor` when you need to dig deeper into the arguments passed to your mocked methods, especially for objects that are dynamically created or whose internal state needs detailed verification.
# Best Practices and Common Pitfalls
While `ArgumentCaptor` is a powerful tool, using it effectively requires adherence to best practices and awareness of common pitfalls.
Misuse can lead to brittle tests or misleading test results.
Best Practices
1. Use `ArgumentCaptor` when you need to inspect internal state: As highlighted, the primary reason to use `ArgumentCaptor` is when `equals` is insufficient or impossible to use e.g., object created within the SUT. If a simple `eq` or `any` suffices, stick with those for brevity and clarity.
* Data Point: Many developers fall into the trap of over-using `ArgumentCaptor` even when `eq` would work, leading to more verbose tests than necessary. A common industry observation is that `eq` is often preferred for simple types or well-defined value objects, while `ArgumentCaptor` is reserved for more complex verification needs.
2. Declare `ArgumentCaptor` locally within the test method: While you *can* declare `ArgumentCaptor` as a field and use `@Captor` annotation, declaring it locally within the test method that uses it often improves readability and prevents accidental state leakage between tests if you're not careful with `@BeforeEach` or `@AfterEach`.
* Example:
```java
@Test
void testSpecificScenario {
ArgumentCaptor<MyObject> captor = ArgumentCaptor.forClassMyObject.class.
// ... use captor
```
3. Perform assertions on the captured value *after* `verify`: The `capture` method itself doesn't return the value. it's `captor.getValue` or `captor.getAllValues` that does. Ensure you call `verify` first to allow Mockito to capture the argument, and then retrieve and assert.
4. Be specific with `forClass`: Always use `ArgumentCaptor.forClassMyClass.class` instead of raw types `ArgumentCaptor`. This improves type safety and allows the compiler to help catch errors.
5. Use `getAllValues` for multiple invocations: If a method is called multiple times and you need to inspect arguments from *each* call, `getAllValues` is the way to go. Don't call `getValue` multiple times and expect different results – it will always return the last captured value.
Common Pitfalls
1. Mixing `any`/`eq` with `capture` incorrectly: If you have multiple arguments for a method, and you use an `any` or `eq` matcher for one, you must use matchers for *all* arguments in that `verify` call. You cannot mix raw values e.g., `verifymockedService.doSomethingsomeObject, "literalString"` with matchers or `capture`.
* Incorrect: `verifymockedService.doSomethingsomeObject, stringCaptor.capture.` where `someObject` is a real object reference, not a matcher
* Correct: `verifymockedService.doSomethingeqsomeObject, stringCaptor.capture.`
* Insight: This is a common source of `InvalidUseOfMatchersException` in Mockito. Mockito's internal mechanism requires all arguments to be handled by a matcher if even one argument uses one.
2. Capturing before the method is called: `ArgumentCaptor` only captures arguments during the `verify` phase. If you try to call `captor.getValue` before the mocked method has been invoked and thus verified, you'll get an `IllegalStateException`.
* Incorrect Flow:
User capturedUser = userCaptor.getValue. // Error! Method not yet called/verified
userService.registerUser"test", "[email protected]".
* Correct Flow:
User capturedUser = userCaptor.getValue. // Correct
3. Not clearing captors for multiple tests if using `@Captor` as field without `@BeforeEach`: If you declare `ArgumentCaptor` as a class field and don't reset your mocks/captors before each test, captured values from previous tests might persist, leading to flaky tests. Using `@Mock`, `@InjectMocks`, and `@Captor` with `MockitoAnnotations.openMocksthis` in an `@BeforeEach` method effectively handles this by re-initializing mocks and captors for every test run.
4. Expecting `getValue` to return different values on multiple calls: `getValue` always returns the *last* captured argument. If you need all arguments from multiple invocations, use `getAllValues`.
By being mindful of these practices and pitfalls, you can leverage `ArgumentCaptor` to its full potential, writing tests that are robust, clear, and reliable.
# Integrating `ArgumentCaptor` with Other Mockito Features
`ArgumentCaptor` plays well with other Mockito features, enhancing the flexibility and power of your tests.
Understanding these integrations can unlock even more sophisticated testing scenarios.
Combining with `@Mock` and `@InjectMocks`
The `MockitoAnnotations.openMocksthis` call or `@ExtendWithMockitoExtension.class` for JUnit 5 is essential.
It initializes all fields annotated with `@Mock`, `@Spy`, `@InjectMocks`, and `@Captor`.
* `@Mock`: Creates a mock object.
* `@InjectMocks`: Injects the created mocks into the object under test.
* `@Captor`: A convenient way to declare an `ArgumentCaptor` as a field. It's equivalent to `ArgumentCaptor.forClassMyClass.class` but initialized automatically by Mockito.
Example using `@Captor` annotation:
// src/test/java/com/example/UserServiceTest.java Using @Captor
import org.mockito.Captor. // Import this
@Captor // Declare the captor as a field
private ArgumentCaptor<User> userCaptor. // Mockito will infer the type from the generic
MockitoAnnotations.openMocksthis. // This initializes @Mock, @InjectMocks, and @Captor
void testRegisterUser_withCaptorAnnotation {
// No need for ArgumentCaptor.forClass here, it's done by @Captor
Using `@Captor` cleans up the test method slightly by moving the captor declaration to the class level.
Remember, `MockitoAnnotations.openMocksthis` or `@ExtendWith` is crucial for this annotation to work.
Stubbing with `ArgumentCaptor` Less Common, More for Advanced Scenarios
While `ArgumentCaptor` is primarily for `verify` calls, you can technically use `capture` within `when` stubbing, although it's less common and often indicates a design smell or a more complex test requirement.
The `capture` call itself doesn't return a value, so you usually pair it with `doAnswer` to perform logic with the captured argument.
Example Scenario: Suppose you want to return a specific value from a mock based on an argument's internal state, which you need to inspect.
// Imagine a service that calculates a fee based on user's status
public interface PaymentGateway {
double processPaymentUser user, double amount.
// Test code Illustrative, not recommended as standard practice
import static org.mockito.Mockito.doAnswer.
import static org.mockito.Mockito.when. // For illustration
public class PaymentServiceTest {
private PaymentGateway paymentGateway.
void testProcessPayment_stubbingWithCaptor {
ArgumentCaptor<Double> amountCaptor = ArgumentCaptor.forClassDouble.class.
// This is a contrived example. usually, stubbing is simpler.
// But demonstrates how you COULD use capture in when/doAnswer.
doAnswerinvocation -> {
User capturedUser = userCaptor.getValue. // Get the captured user
Double capturedAmount = amountCaptor.getValue. // Get the captured amount
// Perform logic based on captured arguments
if "PREMIUM".equalscapturedUser.getStatus {
return capturedAmount * 0.9. // 10% discount for premium users
return capturedAmount.
}.whenpaymentGateway.processPaymentuserCaptor.capture, amountCaptor.capture.
// Now, call the method under test, which internally calls paymentGateway.processPayment
User regularUser = new User"regular", "[email protected]".
regularUser.setStatus"ACTIVE".
User premiumUser = new User"premium", "[email protected]".
premiumUser.setStatus"PREMIUM".
// Simulate service calls assuming a service uses paymentGateway
double regularFee = paymentGateway.processPaymentregularUser, 100.0.
double premiumFee = paymentGateway.processPaymentpremiumUser, 100.0.
assertEquals100.0, regularFee, 0.001.
assertEquals90.0, premiumFee, 0.001.
This specific use case for `when` with `capture` and `doAnswer` is complex and rarely needed. Most often, you'd just `when` with `any` or `eq` and rely on `verify` with `ArgumentCaptor` for assertion. The primary purpose of `ArgumentCaptor` is *verification*, not stubbing. If you find yourself in a scenario where you need to stub based on the *internal state* of an argument that varies, consider whether your design is overly complex or if there's a simpler way to achieve the test goal without capturing during stubbing.
# Common `ArgumentCaptor` Use Cases
Let's dive into some practical, real-world scenarios where `ArgumentCaptor` proves to be an invaluable asset.
These examples often mirror complex business logic that cannot be easily tested with simpler Mockito matchers.
1. Verifying Object Creation and Configuration
This is arguably the most common and powerful use of `ArgumentCaptor`. When your system under test SUT is responsible for creating a new object e.g., a `User`, `Order`, `Report`, or a configuration object and then passing it to another component a mock, you need to ensure that the created object has the correct properties set.
Scenario: A `ReportingService` generates a `Report` object and then sends it to a `ReportSender`. We need to verify the content of the generated `Report`.
// src/main/java/com/example/Report.java
import java.time.LocalDate.
import java.util.Map.
public class Report {
private String title.
private LocalDate creationDate.
private Map<String, Object> data.
private String status. // e.g., "GENERATED", "SENT"
public ReportString title, Map<String, Object> data {
this.title = title.
this.data = data.
this.creationDate = LocalDate.now.
this.status = "GENERATED".
public String getTitle { return title. }
public LocalDate getCreationDate { return creationDate. }
public Map<String, Object> getData { return data. }
public String getStatus { return status. }
public void setStatusString status { this.status = status. }
return "Report{" +
"title='" + title + '\'' +
", creationDate=" + creationDate +
", data=" + data +
// src/main/java/com/example/ReportSender.java
public interface ReportSender {
void sendReport report.
// src/main/java/com/example/ReportingService.java
public class ReportingService {
private ReportSender reportSender.
public ReportingServiceReportSender reportSender {
this.reportSender = reportSender.
public void generateAndSendDailyReportString reportTitle, Map<String, Object> reportData {
Report dailyReport = new ReportreportTitle, reportData.
// Additional logic could be here, e.g., validation, logging
reportSender.senddailyReport.
// src/test/java/com/example/ReportingServiceTest.java
import java.util.Collections.
import java.util.HashMap.
import static org.junit.jupiter.api.Assertions.assertNotNull.
public class ReportingServiceTest {
private ReportingService reportingService.
void testGenerateAndSendDailyReport_capturesAndVerifiesReportContent {
String expectedTitle = "Daily Sales Report".
Map<String, Object> expectedData = new HashMap<>.
expectedData.put"totalSales", 1500.75.
expectedData.put"numOrders", 45.
reportingService.generateAndSendDailyReportexpectedTitle, expectedData.
ArgumentCaptor<Report> reportCaptor = ArgumentCaptor.forClassReport.class.
verifyreportSender.sendreportCaptor.capture.
Report capturedReport = reportCaptor.getValue.
assertNotNullcapturedReport, "Report should not be null.".
assertEqualsexpectedTitle, capturedReport.getTitle, "Report title should match.".
assertEqualsLocalDate.now, capturedReport.getCreationDate, "Report creation date should be today.".
assertEqualsexpectedData, capturedReport.getData, "Report data should match.".
assertEquals"GENERATED", capturedReport.getStatus, "Report status should be GENERATED initially.".
This test effectively verifies that the `ReportingService` correctly constructs a `Report` object with the given title and data, and sets its `creationDate` and `status` correctly before passing it to `ReportSender`.
2. Testing Callback or Listener Interactions
When your SUT registers a callback or listener with another component mock, and that component then invokes methods on the callback, `ArgumentCaptor` can capture the callback instance itself or arguments passed to its methods.
Scenario: A `DataProcessor` registers a `ProcessingCallback` with an `ExternalService`. We want to verify that the `ExternalService` receives the correct callback instance and that the callback's `onSuccess` method is invoked with the expected data.
// src/main/java/com/example/ProcessingCallback.java
public interface ProcessingCallback {
void onSuccessString processedData.
void onFailureString errorMessage.
// src/main/java/com/example/ExternalService.java
public interface ExternalService {
void registerCallbackProcessingCallback callback.
// In a real scenario, this service would later call callback.onSuccess or onFailure
// For testing, we'll manually simulate this invocation.
// src/main/java/com/example/DataProcessor.java
public class DataProcessor {
private ExternalService externalService.
public DataProcessorExternalService externalService {
this.externalService = externalService.
public void processAsyncDataString inputData {
// In a real app, this might involve submitting a job,
// and the callback is invoked upon completion.
externalService.registerCallbacknew ProcessingCallback {
@Override
public void onSuccessString processedData {
System.out.println"Processed: " + processedData.
// Potentially store results or trigger next steps
public void onFailureString errorMessage {
System.err.println"Error: " + errorMessage.
// Handle error
}.
// src/test/java/com/example/DataProcessorTest.java
public class DataProcessorTest {
private DataProcessor dataProcessor.
// We also need a mock for the callback's behavior, if we want to verify its methods
private ProcessingCallback mockCallbackForVerification.
// Not actually injected, but used for verification
void testProcessAsyncData_capturesCallbackAndVerifiesItsInvocation {
String inputData = "some_raw_data".
dataProcessor.processAsyncDatainputData.
ArgumentCaptor<ProcessingCallback> callbackCaptor = ArgumentCaptor.forClassProcessingCallback.class.
verifyexternalService.registerCallbackcallbackCaptor.capture.
ProcessingCallback capturedCallback = callbackCaptor.getValue.
assertNotNullcapturedCallback, "Callback should have been registered.".
// Now, we can simulate the external service calling the callback's methods
// and verify that the correct data is passed to them.
String expectedProcessedData = "processed_" + inputData.
capturedCallback.onSuccessexpectedProcessedData. // Simulate external service calling onSuccess
// Verify that onSuccess was called on our *captured* callback instance
// This part is tricky: we are calling the method on the actual captured object,
// not directly on a mock that is injected into dataProcessor.
// To verify the *effect* of calling onSuccess on a captured object,
// you would typically need to ensure that the captured object then interacts
// with another mock that you *can* verify.
// For simpler verification, if the callback's methods *directly* interact with a mock,
// then you can verify that mock's interaction.
// A better approach often involves capturing the callback and then stubbing
// what it does or letting it interact with other mocks in the test.
// If the callback itself has dependencies, those would also need to be mocked.
// For this specific example, a common way to test the behavior of the *callback* itself
// not just that it was passed, is to provide a *spy* for the callback or use a direct
// mock if the callback instance is somehow accessible.
// Or, more practically, verify the side effects *of* the callback's methods.
// Let's refine the test to verify a side effect of the callback.
// Assume ProcessingCallback, when successful, calls a ReportingService.
// This would require modifying ProcessingCallback to take ReportingService as dependency
// For simplicity, let's just verify the `onSuccess` invocation if `capturedCallback`
// was a mock provided by us.
But here it's an actual instance created by `DataProcessor`.
// This demonstrates capturing the instance. To verify *its internal behavior*,
// you'd typically need to test `ProcessingCallback` as a separate unit,
// or ensure `DataProcessor` *passed a mock* of `ProcessingCallback` in the first place,
// which defeats the purpose if `DataProcessor` *creates* the anonymous callback.
// Realistically, for anonymous inner classes/lambdas created by SUT,
// you verify the *effect* of their execution on other mocks,
// not directly verify calls on the anonymous object itself unless it was spied.
// The most direct thing captured here is that the *instance* of `ProcessingCallback`
// was registered.
The above callback example highlights a nuance: `ArgumentCaptor` captures the *instance*. If that instance is an anonymous inner class or lambda created by the SUT, you can't directly `verify` method calls *on it* unless you also spy on it, which can be complex. Instead, you usually verify the *side effects* of its methods on other mocks. However, capturing the callback instance *itself* is still useful to ensure the correct type of callback was registered.
3. Capturing Arguments from Variadic Methods or `Collection` Types
When a method accepts a variable number of arguments varargs or a collection, `ArgumentCaptor` can capture the entire array or collection, allowing you to inspect its contents.
Scenario: A `BatchService` processes a list of `Item` objects and saves them to a `ItemRepository`. We want to verify that the `ItemRepository` receives the correct list of `Item`s.
// src/main/java/com/example/Item.java
public class Item {
private String id.
private String name.
private int quantity.
public ItemString id, String name, int quantity {
this.id = id.
this.name = name.
this.quantity = quantity.
public String getId { return id. }
public String getName { return name. }
public int getQuantity { return quantity. }
return "Item{" +
"id='" + id + '\'' +
", name='" + name + '\'' +
", quantity=" + quantity +
public boolean equalsObject o {
if this == o return true.
if o == null || getClass != o.getClass return false.
Item item = Item o.
return quantity == item.quantity &&
id.equalsitem.id &&
name.equalsitem.name.
public int hashCode {
return java.util.Objects.hashid, name, quantity.
// src/main/java/com/example/ItemRepository.java
public interface ItemRepository {
void saveAllList<Item> items.
// src/main/java/com/example/BatchService.java
public class BatchService {
private ItemRepository itemRepository.
public BatchServiceItemRepository itemRepository {
this.itemRepository = itemRepository.
public void processAndSaveItemsList<Item> itemsToProcess {
// Assume some processing logic here, perhaps filtering or transforming
itemRepository.saveAllitemsToProcess.
// src/test/java/com/example/BatchServiceTest.java
public class BatchServiceTest {
private BatchService batchService.
void testProcessAndSaveItems_capturesListOfItems {
Item item1 = new Item"A001", "Laptop", 1.
Item item2 = new Item"B002", "Mouse", 5.
List<Item> itemsToProcess = Arrays.asListitem1, item2.
batchService.processAndSaveItemsitemsToProcess.
ArgumentCaptor<List> listCaptor = ArgumentCaptor.forClassList.class.
verifyitemRepository.saveAlllistCaptor.capture.
List<Item> capturedItems = listCaptor.getValue. // This will be a List<Item>
assertEquals2, capturedItems.size, "Should capture a list of 2 items.".
assertEqualsitem1, capturedItems.get0, "First captured item should match item1.".
assertEqualsitem2, capturedItems.get1, "Second captured item should match item2.".
Here, `listCaptor` captures the entire `List` of `Item` objects passed to `saveAll`. This allows detailed verification of the list's size, order, and the properties of each `Item` within it.
For varargs, you'd capture an array type e.g., `ArgumentCaptor<Item>`.
These use cases illustrate the practical application of `ArgumentCaptor` in scenarios where simple matchers fall short, enabling more comprehensive and reliable unit testing.
# Refactoring for Testability: Reducing `ArgumentCaptor` Usage
While `ArgumentCaptor` is a valuable tool, an over-reliance on it can sometimes be a code smell, indicating that the system under test SUT might be doing too much or that its design makes testing overly complex.
Often, refactoring your code for better testability can reduce the need for `ArgumentCaptor`, leading to simpler, more readable tests.
The core principle here is the Single Responsibility Principle SRP. If a method is creating complex objects and then passing them to a dependency, perhaps the object creation logic could be extracted into a separate factory or builder class. This would make the SUT's responsibility clearer and the arguments passed to mocks simpler to verify.
When to Consider Alternatives to `ArgumentCaptor`
1. If `ArgumentCaptor` is used to capture a simple primitive or `String`: If you're capturing `String` or `int`, consider if `eq` would suffice. `ArgumentCaptor` adds overhead that isn't always necessary for simple types.
* Anti-Pattern: Using `ArgumentCaptor<String> captor. verifymock.logcaptor.capture. assertEquals"expected", captor.getValue.` when `verifymock.logeq"expected".` would be cleaner.
2. When the captured object's `equals` method *could* be implemented effectively: If the object being captured is a Value Object i.e., its identity is based purely on its attributes, like a `Money` object or a `Coordinates` object, consider implementing a robust `equals` and `hashCode` method for it. Then, you could use `eqexpectedObject` directly, which is often more concise than `ArgumentCaptor`.
* Refactoring Tip: For data transfer objects DTOs or value objects, ensure they implement `equals` and `hashCode` correctly. This allows direct comparison.
3. If a method creates a complex object and passes it to a dependency: This is the classic `ArgumentCaptor` scenario. However, if the creation logic is intricate, consider:
* Extracting an Object Factory/Builder: Delegate the object creation to a dedicated factory or builder class. You can then mock this factory and stub its `create` method to return a known object, or verify the factory's methods were called with the correct parameters if the factory itself is worth testing.
* Original Code less testable:
```java
public class OrderProcessor {
private OrderDao orderDao.
public void processOrderOrderRequest request {
Order order = new Orderrequest.getCustomerId, request.getItems, /* ... */. // Complex creation
order.setStatus"PROCESSING".
orderDao.saveorder.
}
```
* Refactored with Factory more testable:
public class OrderFactory { // New class
public Order createOrderOrderRequest request {
Order order = new Orderrequest.getCustomerId, request.getItems, /* ... */.
order.setStatus"CREATED". // Initial status
return order.
private OrderFactory orderFactory. // Injected
Order order = orderFactory.createOrderrequest. // Delegate creation
order.setStatus"PROCESSING". // Now only handles status change
* Testing `OrderProcessor` after refactor: You can now mock `orderFactory` to return a specific `Order` instance, simplifying the verification of `orderDao.save`. You might still use `ArgumentCaptor` if `orderProcessor` *modifies* the order after creation, but the initial creation part is cleaner. The factory itself would have its own tests.
4. If the SUT passes `this` itself as an argument: This often points to a tightly coupled design. If the SUT is passing `this` to a mock, it means the mock is now interacting directly with the SUT's internal state. This can be hard to test.
* Consider an Interface: Instead of passing `this`, pass an interface that exposes only the necessary methods for the mock to interact with. This reduces coupling and makes verification clearer.
* Example: Instead of `collaborator.registerthis`, consider `collaborator.registernew MyListenerImpl` where `MyListenerImpl` is a simpler class that implements the required listener interface, and you can test `MyListenerImpl` separately.
Conclusion on Refactoring:
The goal is not to eliminate `ArgumentCaptor` entirely, as it's truly indispensable for certain scenarios like capturing dynamically created objects with complex internal states. Rather, it's about being mindful of *why* you're using it. If it's constantly appearing for simple argument types or to compensate for overly complex object creation within a method, consider refactoring your design. Cleaner code generally leads to cleaner, more maintainable tests. By adhering to principles like SRP and dependency inversion, you can often simplify your tests and reduce the need for advanced mocking techniques. This aligns with the broader principle of writing clear, maintainable code, which is a commendable goal in any development endeavor.
# Comparing `ArgumentCaptor` with Custom Argument Matchers
Beyond `ArgumentCaptor`, Mockito offers the ability to create custom argument matchers using `ArgumentMatcher<T>`. While `ArgumentCaptor` captures and lets you assert *after* the call, a custom matcher lets you define complex matching logic *during* the `verify` or `when` call.
When to Use Custom Argument Matchers
* Complex Matching Logic: When the criteria for an argument to be considered "matched" are very intricate and cannot be expressed by `eq` or by simply checking one or two properties of a captured object. For example, if an object needs to match based on a combination of properties, or if it needs to pass a certain validation rule.
* Performance Potentially: While `ArgumentCaptor` captures and then asserts, a custom matcher performs the assertion *during* the method invocation, potentially failing faster if the argument doesn't match expectations.
* Readability for Specific Domain Concepts: Sometimes, encapsulating complex matching logic within a named custom matcher `isUserWithActiveStatus` can make the `verify` call more readable and expressive than a series of `assertEquals` on a captured object.
How to Create a Custom Argument Matcher
You implement the `org.mockito.ArgumentMatcher<T>` interface and override its `matches` method.
Example: Matching a `User` object that is active and has a specific username.
// src/main/java/com/example/UserService.java simplified for example
public void updateUserStatusString username, String newStatus {
User user = userRepository.findByUsernameusername.
if user != null {
user.setStatusnewStatus.
userRepository.saveuser.
Now, a custom matcher:
// src/test/java/com/example/matchers/IsActiveUserWithUsername.java
package com.example.matchers.
import com.example.User.
import org.mockito.ArgumentMatcher.
public class IsActiveUserWithUsername implements ArgumentMatcher<User> {
private final String expectedUsername.
public IsActiveUserWithUsernameString expectedUsername {
this.expectedUsername = expectedUsername.
public boolean matchesUser user {
return user != null &&
expectedUsername.equalsuser.getUsername &&
"ACTIVE".equalsuser.getStatus.
// Optional: for better error messages if the matcher fails
return "is an active user with username \"" + expectedUsername + "\"".
Using the custom matcher in a test:
// src/test/java/com/example/UserServiceTest.java with custom matcher
import com.example.matchers.IsActiveUserWithUsername. // Import the custom matcher
import static org.mockito.Mockito.argThat. // Static import for argThat
import static org.mockito.Mockito.when.
void testUpdateUserStatus_withCustomMatcher {
String username = "testuser".
String newStatus = "ACTIVE".
User existingUser = new Userusername, "[email protected]".
existingUser.setStatus"PENDING_APPROVAL".
whenuserRepository.findByUsernameusername.thenReturnexistingUser.
userService.updateUserStatususername, newStatus.
// Use the custom matcher in verify
verifyuserRepository.saveargThatnew IsActiveUserWithUsernameusername.
`ArgumentCaptor` vs. Custom Matcher: The Trade-off
* `ArgumentCaptor`:
* Pros: Explicitly captures the argument, allowing any assertion *after* the method call. Great for inspecting complex objects, or multiple values across invocations. Very flexible.
* Cons: Requires more lines of code declaration, capture, getValue, then assertions. The verification logic is spread out.
* Custom Matcher:
* Pros: Encapsulates complex matching logic into a single, reusable class. Makes the `verify` or `when` line more concise and declarative. Useful when the "matching" criteria is fixed and complex.
* Cons: Requires creating a new class for each distinct matching logic. Can be less flexible if you need to perform many different assertions on the same captured object. If the matching logic is very simple, it's overkill.
Guideline:
* Use `ArgumentCaptor` when you need to inspect the *specific instance* of an object passed to a method and perform various assertions on its properties, especially when the object is dynamically created or when you need to check its state post-method invocation. This is your go-to for verifying complex object state changes.
* Use `Custom Argument Matchers` when you have a well-defined, potentially complex *criterion* for an argument to be considered valid, and you want to reuse that criterion across multiple tests or make the `verify` line highly expressive. If your object has a complex `equals` method that captures all necessary verification, `eq` might also be a good alternative, simplifying even further.
Often, the choice boils down to readability and maintainability for your specific test case.
For quick, one-off complex object inspections, `ArgumentCaptor` is often more convenient.
For recurring, complex matching rules, a custom matcher pays off.
Frequently Asked Questions
# What is ArgumentCaptor in Mockito?
`ArgumentCaptor` in Mockito is a class used to capture arguments passed to a mocked method, allowing you to perform assertions on these arguments *after* the method call. It's particularly useful for verifying the internal state of complex objects that are dynamically created within the system under test and passed to a dependency.
# Why can't I just use `Mockito.any` or `Mockito.eq` instead of `ArgumentCaptor`?
You can, but they serve different purposes. `Mockito.any` checks if *any* argument of a specific type was passed. `Mockito.eq` checks if an argument *equals* a specific value based on its `equals` method. `ArgumentCaptor`, however, captures the *actual object instance* passed, allowing you to retrieve it and assert on its internal properties, which `any` and `eq` cannot do. Use `ArgumentCaptor` when you need to inspect the state of a dynamically generated or complex object argument.
# How do I declare an `ArgumentCaptor`?
You declare `ArgumentCaptor` using `ArgumentCaptor.forClassYourClass.class`:
`ArgumentCaptor<YourClass> yourCaptor = ArgumentCaptor.forClassYourClass.class.`
Alternatively, you can use the `@Captor` annotation on a field, and Mockito will initialize it for you, provided `MockitoAnnotations.openMocksthis` or `@ExtendWithMockitoExtension.class` is used:
`@Captor private ArgumentCaptor<YourClass> yourCaptor.`
# How do I use `ArgumentCaptor` to capture an argument?
You use `yourCaptor.capture` within the `Mockito.verify` method call:
`verifyyourMockedService.doSomethingyourCaptor.capture.`
This tells Mockito to capture the argument passed to `doSomething` when it is invoked.
# How do I get the captured argument value?
After calling `verify` with `capture`, you retrieve the captured argument using `yourCaptor.getValue`:
`YourClass capturedObject = yourCaptor.getValue.`
You can then perform assertions on `capturedObject`.
# What if I need to capture multiple arguments from the same method call?
You declare a separate `ArgumentCaptor` for each argument type you want to capture, and then use each captor's `capture` method in the same `verify` call:
`verifymockedService.methodcaptor1.capture, captor2.capture, captor3.capture.`
# How do I capture arguments from multiple invocations of the same method?
If a mocked method is called multiple times, `yourCaptor.getValue` will return the *last* captured argument. To get all captured arguments in order, use `yourCaptor.getAllValues`:
`List<YourClass> allCapturedObjects = yourCaptor.getAllValues.`
This returns a `List` of all arguments passed during the invocations.
# Can I use `ArgumentCaptor` with `when` for stubbing?
Yes, but it's less common and often indicates a design smell. While `capture` can be used within `when`, you typically pair it with `doAnswer` to perform logic with the captured argument. `ArgumentCaptor`'s primary purpose is for *verification*, not stubbing.
# What happens if I call `getValue` before the argument is captured?
Calling `getValue` or `getAllValues` before the mocked method has been invoked and `verify` has been called with `capture` will result in an `IllegalStateException`. `ArgumentCaptor` can only retrieve values after they have been captured by Mockito.
# Can `ArgumentCaptor` be used with primitive types?
Yes, `ArgumentCaptor` can capture primitive types like `int`, `boolean`, `double`, etc. by using their corresponding wrapper classes e.g., `Integer.class`, `Boolean.class`, `Double.class` in `forClass`. However, for simple primitives, `Mockito.eq` is often sufficient and more concise.
# Is `ArgumentCaptor` thread-safe?
Yes, `ArgumentCaptor` is designed to be thread-safe.
Each `ArgumentCaptor` instance manages its own captured values, and its internal mechanisms are synchronized to handle concurrent access, though typical unit tests are often single-threaded.
# When should I use `ArgumentCaptor` versus a custom `ArgumentMatcher`?
Use `ArgumentCaptor` when you need to retrieve the actual argument instance and perform various assertions on its properties *after* the method call. Use a custom `ArgumentMatcher` when you have a complex, reusable rule for an argument to be considered "matched" *during* the method invocation, and you want to make your `verify` or `when` call more declarative.
# Can I mix `ArgumentCaptor.capture` with literal values in `verify`?
No, you cannot. If you use any Mockito matcher like `capture`, `any`, `eq`, `argThat` for even one argument in a `verify` call, then *all* arguments in that call must be matchers. You cannot mix matchers with literal values.
Incorrect: `verifymockedService.methodcaptor.capture, "literalString".`
Correct: `verifymockedService.methodcaptor.capture, eq"literalString".`
# What if I capture a mutable object, and it changes after being captured?
`ArgumentCaptor` captures a reference to the actual object passed at the time of invocation. If the object is mutable and its state changes *after* the method call but *before* you retrieve and assert on it, `getValue` will reflect the changed state. To avoid this, either ensure objects are immutable, or retrieve and assert immediately after capturing.
# Should I declare `ArgumentCaptor` as a field or locally in a test method?
Both are valid.
Declaring it as a field with `@Captor` and initializing with `MockitoAnnotations.openMocksthis` can reduce boilerplate.
Declaring it locally within the test method can sometimes improve readability for simple tests by keeping the captor's scope confined and clearly visible where it's used.
For larger tests, `@Captor` can make setup cleaner.
# How do I handle generic types with `ArgumentCaptor`?
You can capture generic types, but due to Java's type erasure, you might need to cast or ensure the type inference is correct.
For example, `ArgumentCaptor<List<String>> listCaptor = ArgumentCaptor.forClassList.class.` would capture a `List`, and you'd typically cast its elements or rely on downstream checks.
Mockito doesn't retain generic type information at runtime.
# What are some common pitfalls when using `ArgumentCaptor`?
Common pitfalls include:
1. Calling `getValue` before the `verify` call.
2. Mixing matchers and literal values in `verify`.
3. Forgetting to call `MockitoAnnotations.openMocksthis` when using `@Captor`.
4. Expecting `getValue` to return different arguments from multiple calls use `getAllValues` instead.
5. Not considering object mutability issues if the captured object's state changes post-capture.
# Does `ArgumentCaptor` affect the method under test's execution?
No.
`ArgumentCaptor` is part of Mockito's verification mechanism.
It merely observes and records the arguments passed to a mocked method without altering the flow or behavior of the method under test.
# Can I use `ArgumentCaptor` with `doNothing` or `doThrow`?
`ArgumentCaptor` is primarily for verification.
`doNothing` and `doThrow` are for stubbing behavior.
While you can technically include `captor.capture` within `when` or `doAnswer` calls, it's not its primary purpose for `doNothing` or `doThrow`. For stubbing, you usually use `any` or `eq` to match the arguments before performing the stubbed action.
# When should I consider refactoring my code instead of using `ArgumentCaptor`?
If you find yourself constantly using `ArgumentCaptor` for the same complex object creation and verification pattern, or if your SUT is creating and configuring many complex objects that are then passed to mocks, it might be a sign that the SUT has too many responsibilities.
Consider extracting object creation into a factory or builder to simplify your tests and improve design.
# What is the performance overhead of using `ArgumentCaptor`?
The performance overhead of `ArgumentCaptor` is generally negligible in unit tests. Mockito is highly optimized.
The main "cost" is typically in the verbosity of the test code compared to simpler matchers, not in runtime performance.
# Can `ArgumentCaptor` be used with `varargs` variable arguments?
Yes.
To capture `varargs`, you declare the `ArgumentCaptor` for an array type of the vararg elements.
For example, if a method is `void doSomethingString... messages`, you would use `ArgumentCaptor<String> captor = ArgumentCaptor.forClassString.class.` and then `verifymock.doSomethingcaptor.capture.`. You can then inspect the `String` array from `captor.getValue`.
Leave a Reply