Builder pattern for test data in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of JUnit test using Builder pattern

Given the following JUnit test code using a Builder pattern for creating test data, what will be the test result?

JUnit

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

public class User {
    private String name;
    private int age;

    private User(Builder builder) {
        this.name = builder.name;
        this.age = builder.age;
    }

    public String getName() { return name; }
    public int getAge() { return age; }

    public static class Builder {
        private String name = "Default";
        private int age = 18;

        public Builder name(String name) {
            this.name = name;
            return this;
        }

        public Builder age(int age) {
            this.age = age;
            return this;
        }

        public User build() {
            return new User(this);
        }
    }
}

public class UserTest {
    @Test
    public void testUserBuilder() {
        User user = new User.Builder()
            .name("Alice")
            .age(25)
            .build();

        assertEquals("Alice", user.getName());
        assertEquals(25, user.getAge());
    }
}

A Test fails because age is 18, not 25

B Compilation error due to missing Builder constructor

C Test fails because name is "Default", not "Alice"

D Test passes successfully

💡 Hint

Check how the Builder sets the fields before building the User object.

The Builder pattern sets name to "Alice" and age to 25 before building the User. The test asserts these values correctly, so it passes.

❓ assertion

intermediate

Correct assertion for Builder-created object

You have a User object created by the Builder with name "Bob" and age 30. Which assertion correctly verifies the age in JUnit 5?

JUnit

User user = new User.Builder().name("Bob").age(30).build();

A assertEquals(30, user.getAge());

B assertTrue(user.getAge() == 30);

C assertEquals("30", user.getAge());

D assertFalse(user.getAge() != 30);

💡 Hint

Use the assertion that compares expected and actual values with correct types.

assertEquals(30, user.getAge()) compares the expected int 30 with the actual int age correctly. Option A compares int to String, causing failure.

🔧 Debug

advanced

Identify the bug in Builder pattern usage

What is the bug in this test code using the Builder pattern?

JUnit

User user = new User.Builder()
    .name(null)
    .age(22)
    .build();

assertEquals("John", user.getName());

A The test expects name "John" but Builder sets name to null

B Builder does not initialize age, causing NullPointerException

C User class constructor is missing, causing NullPointerException

D assertEquals cannot compare null values, causing NullPointerException

💡 Hint

Check what value the Builder sets for name and what the test expects.

The Builder sets name to null explicitly, but the test expects "John". This mismatch causes the assertion to fail.

🧠 Conceptual

advanced

Why use Builder pattern for test data?

Which is the best reason to use the Builder pattern when creating test data objects in automated tests?

A It automatically generates test reports after each test

B It allows creating complex objects with readable code and optional parameters

C It replaces the need for assertions in tests

D It ensures tests run faster by caching objects

💡 Hint

Think about how Builder helps with object creation in tests.

Builder pattern helps create complex test data with clear, readable code and optional fields, improving test maintainability.

❓ framework

expert

Integrating Builder pattern with JUnit 5 parameterized tests

How can you use the Builder pattern to supply different User objects to a JUnit 5 parameterized test?

JUnit

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
import static org.junit.jupiter.api.Assertions.*;
import java.util.stream.Stream;

public class UserTest {

    static Stream<User> userProvider() {
        return Stream.of(
            new User.Builder().name("Anna").age(20).build(),
            new User.Builder().name("Ben").age(35).build()
        );
    }

    @ParameterizedTest
    @MethodSource("userProvider")
    void testUserAges(User user) {
        assertTrue(user.getAge() > 18);
    }
}

A MethodSource must return Strings, not User objects

B Builder pattern cannot be used with parameterized tests

C This code correctly uses Builder objects as parameters for the test

D ParameterizedTest requires @ValueSource, not @MethodSource

💡 Hint

Check if the method source returns the correct type for the test parameter.

JUnit 5 supports parameterized tests with @MethodSource returning any object type. Using Builder to create User objects for test parameters is valid.