Argument aggregation in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of JUnit test with argument aggregation

Consider the following JUnit 5 test using @CsvSource and argument aggregation. What will be the output when the test runs?

JUnit

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import org.junit.jupiter.params.aggregator.AggregateWith;
import static org.junit.jupiter.api.Assertions.*;

class User {
    String name;
    int age;
    User(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

class UserAggregator implements org.junit.jupiter.params.aggregator.ArgumentsAggregator {
    @Override
    public User aggregateArguments(org.junit.jupiter.params.aggregator.ArgumentsAccessor accessor, java.lang.reflect.Parameter parameter) {
        return new User(accessor.getString(0), accessor.getInteger(1));
    }
}

public class UserTest {
    @ParameterizedTest
    @CsvSource({"Alice,30", "Bob,25"})
    void testUser(@AggregateWith(UserAggregator.class) User user) {
        assertNotNull(user.name);
        assertTrue(user.age > 20);
    }
}

A Test passes for both Alice and Bob

B Test fails for Alice because age is not > 20

C Test fails for Bob because name is null

D Test throws a runtime exception due to aggregator error

💡 Hint

Think about how the aggregator converts CSV input into User objects and what the assertions check.

The aggregator correctly creates User objects from the CSV input. Both users have non-null names and ages greater than 20, so all assertions pass.

❓ assertion

intermediate

Identify failing assertion in argument aggregation test

Given a parameterized test using argument aggregation, which assertion will fail if the aggregator incorrectly maps parameters?

JUnit

import static org.junit.jupiter.api.Assertions.*;

class Product {
    String id;
    double price;
    Product(String id, double price) {
        this.id = id;
        this.price = price;
    }
}

// Aggregator maps first param to price, second to id (incorrect)
class ProductAggregator implements org.junit.jupiter.params.aggregator.ArgumentsAggregator {
    @Override
    public Product aggregateArguments(org.junit.jupiter.params.aggregator.ArgumentsAccessor accessor, java.lang.reflect.Parameter parameter) {
        return new Product(accessor.getString(1), accessor.getDouble(0));
    }
}

@org.junit.jupiter.params.ParameterizedTest
@org.junit.jupiter.params.provider.CsvSource({"19.99, P123", "5.50, P456"})
void testProduct(@org.junit.jupiter.params.aggregator.AggregateWith(ProductAggregator.class) Product product) {
    assertNotNull(product.id);
    assertTrue(product.price > 0);
}

A assertNotNull(product.id) fails

B assertTrue(product.price > 0) fails

C Test throws NullPointerException

D Both assertions pass

💡 Hint

Check how the aggregator swaps parameters and what values are passed.

Although the aggregator swaps parameters, the CSV source provides price first and id second, so product.id gets the string id and product.price gets the double price correctly. Both assertions pass.

🔧 Debug

advanced

Debug failing argument aggregation test due to missing parameter

A parameterized test using argument aggregation fails with an IndexOutOfBoundsException. What is the most likely cause?

JUnit

import static org.junit.jupiter.api.Assertions.*;

@org.junit.jupiter.params.ParameterizedTest
@org.junit.jupiter.params.provider.CsvSource({"John", "Jane, 28"})
void testPerson(@org.junit.jupiter.params.aggregator.AggregateWith(PersonAggregator.class) Person person) {
    assertNotNull(person.name);
    assertTrue(person.age > 0);
}

class Person {
    String name;
    int age;
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

class PersonAggregator implements org.junit.jupiter.params.aggregator.ArgumentsAggregator {
    @Override
    public Person aggregateArguments(org.junit.jupiter.params.aggregator.ArgumentsAccessor accessor, java.lang.reflect.Parameter parameter) {
        return new Person(accessor.getString(0), accessor.getInteger(1));
    }
}

A The first CSV line has missing age parameter causing IndexOutOfBoundsException

B PersonAggregator class is not public causing reflection failure

C The test method is missing @Test annotation

D Person constructor parameters are in wrong order

💡 Hint

Look at the CSV input lines and how many parameters each has.

The first CSV line has only one parameter (name), but the aggregator expects two parameters (name and age). Trying to access the second parameter causes IndexOutOfBoundsException.

❓ framework

advanced

Best practice for argument aggregation in JUnit 5

Which practice is recommended when implementing a custom ArgumentsAggregator in JUnit 5?

A Throw RuntimeException inside aggregateArguments to fail tests on invalid input

B Use instance variables in the aggregator to store state between test runs

C Make the aggregator class a static nested class or top-level class to avoid reflection issues

D Use @BeforeEach to initialize aggregator fields before each aggregation

💡 Hint

Think about how JUnit uses reflection to instantiate aggregators.

JUnit requires aggregators to be static nested or top-level classes so it can instantiate them via reflection without needing an instance of the outer class. Using instance variables or lifecycle methods is not recommended.

🧠 Conceptual

expert

Understanding argument aggregation behavior with nested objects

In JUnit 5, when using argument aggregation to create a complex object with nested objects, which statement is true?

A JUnit automatically aggregates nested objects if their aggregators are registered globally

B You must manually aggregate nested objects inside the main aggregator; JUnit does not recursively aggregate nested parameters

C Nested objects cannot be used with argument aggregation and require separate parameterized tests

D JUnit uses reflection to automatically instantiate nested objects without custom aggregators

💡 Hint

Consider how argument aggregation works with complex parameter types.

JUnit's argument aggregation works at the top level and does not recursively aggregate nested objects. You must manually create nested objects inside your aggregator implementation.