Testing private methods (should you?) in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why avoid testing private methods directly?

In unit testing with JUnit, why is it generally discouraged to test private methods directly?

A Because private methods are automatically tested when public methods are tested

B Because private methods are implementation details and testing them breaks encapsulation

C Because private methods cannot be accessed by any test framework

D Because private methods always contain bugs and should be rewritten instead

💡 Hint

Think about what private methods represent in object-oriented design.

Private methods are internal helpers. Testing them directly exposes internal details and makes tests fragile. Instead, test the public methods that use them.

❓ Predict Output

intermediate

JUnit test output for private method access

What will happen if you try to call a private method directly from a JUnit test class without using reflection?

JUnit

public class Calculator {
    private int add(int a, int b) {
        return a + b;
    }
}

public class CalculatorTest {
    @Test
    public void testAdd() {
        Calculator calc = new Calculator();
        int result = calc.add(2, 3); // Direct call to private method
    }
}

A Compilation error: add(int,int) has private access in Calculator

B Test passes and result is 5

C Runtime error: IllegalAccessException

D Test fails with NullPointerException

💡 Hint

Consider Java access modifiers and compile-time checks.

Private methods cannot be accessed outside their class. Trying to call them directly from test code causes a compile-time error.

❓ framework

advanced

Using reflection to test private methods in JUnit

Which code snippet correctly uses Java reflection to invoke a private method calculate with no parameters in a class MathUtils inside a JUnit test?

A

Method method = MathUtils.class.getMethod("calculate");
Object result = method.invoke(new MathUtils());

B

Method method = MathUtils.class.getMethod("calculate");
method.setAccessible(true);
Object result = method.invoke(new MathUtils());

C

Method method = MathUtils.class.getDeclaredMethod("calculate");
Object result = method.invoke(new MathUtils());

D

Method method = MathUtils.class.getDeclaredMethod("calculate");
method.setAccessible(true);
Object result = method.invoke(new MathUtils());

💡 Hint

Remember that private methods require getDeclaredMethod and setAccessible(true).

Private methods are not accessible via getMethod which only returns public methods. You must use getDeclaredMethod and then set accessibility to true before invoking.

❓ assertion

advanced

Correct assertion for private method result via reflection

After invoking a private method computeSum via reflection that returns an int, which JUnit assertion correctly verifies the result equals 10?

JUnit

Method method = MyClass.class.getDeclaredMethod("computeSum", int.class, int.class);
method.setAccessible(true);
int result = (int) method.invoke(new MyClass(), 4, 6);

A assertEquals(10, result);

B assertTrue(result == 10);

C assertEquals(result, 10);

D assertSame(10, result);

💡 Hint

Check the order of parameters in assertEquals.

In JUnit, the expected value comes first, then the actual value. Using assertEquals(10, result) is correct.

🧠 Conceptual

expert

Best practice for testing private methods in TDD

In Test-Driven Development (TDD), what is the best practice regarding testing private methods?

A Make private methods public temporarily to test them directly, then revert access modifiers

B Write separate tests for private methods using reflection to ensure full coverage

C Test only the public interface; private methods are tested indirectly through public methods

D Avoid writing tests for private methods because they never contain logic

💡 Hint

Think about how TDD focuses on behavior rather than implementation.

TDD encourages testing behavior through the public API. Private methods are implementation details and should be tested only indirectly.