Dummy objects in JUnit - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a dummy object in software testing?

A dummy object is a simple placeholder used in tests to fill parameter lists or satisfy method signatures without affecting the test outcome.

beginner

Why do we use dummy objects in unit tests?

We use dummy objects to avoid null values and to satisfy method parameters when the actual object is not needed for the test logic.

intermediate

How is a dummy object different from a mock object?

A dummy object is just a placeholder and does not have behavior, while a mock object simulates behavior and can verify interactions.

beginner

Example of creating a dummy object in JUnit tests?

In JUnit, you can create a dummy object by instantiating a simple class or using a mock library to create an object that is not used in assertions.

intermediate

When should you avoid using dummy objects?

Avoid dummy objects when the test requires real behavior or interaction; use mocks or stubs instead to simulate behavior.

What is the main purpose of a dummy object in testing?

A To replace the system under test

B To simulate complex behavior

C To fill parameter lists without affecting test logic

D To verify method calls

Dummy objects are used only to fill parameters and do not affect the test logic.

Which of the following is NOT true about dummy objects?

A They verify interactions

B They have no behavior

C They prevent null pointer exceptions

D They satisfy method signatures

Dummy objects do not verify interactions; that is the role of mocks.

In JUnit, how can you create a dummy object?

A Use a real database connection

B Use a mock to verify calls

C Write assertions on the dummy

D Instantiate a simple class with no logic

A dummy object can be a simple instance with no logic just to fill parameters.

When should you NOT use a dummy object?

A When the object is not used in the test

B When you need to simulate behavior

C When you want to avoid nulls

D When filling unused parameters

If behavior simulation is needed, use mocks or stubs, not dummy objects.

Which test double is a dummy object closest to?

A None, it is just a placeholder

B Stub

C Mock

D Fake

Dummy objects are simple placeholders without behavior, unlike mocks, stubs, or fakes.

Explain what a dummy object is and why it is useful in unit testing.

Think about objects that just fill space in method calls.

Describe the difference between dummy objects and mocks in testing.

Compare their roles in test logic and verification.

Practice

1. What is the main purpose of a dummy object in JUnit testing?

easy

A. To perform actual logic and return real data

B. To replace the entire system under test

C. To fill method parameters when the object is not used in the test

D. To generate random test data automatically

Solution

1. Step 1: Understand dummy object role

   Dummy objects are simple placeholders used only to fill method parameters without affecting test logic.

2. Step 2: Differentiate from other test doubles

   Unlike mocks or stubs, dummy objects do not perform any behavior or return values.

3. Final Answer:

   To fill method parameters when the object is not used in the test -> Option C

4. Quick Check:

   Dummy object = placeholder parameter [OK]

Hint: Dummy objects fill unused parameters only [OK]

Common Mistakes:

• Confusing dummy objects with mocks or stubs
• Thinking dummy objects execute logic
• Using dummy objects to test behavior

2. Which of the following is the correct way to create a dummy object for a parameter of type List<String> in JUnit?

easy

A. List<String> dummy = new LinkedList<>(Arrays.asList("test"));

B. List<String> dummy = new ArrayList<>();

C. List<String> dummy = null;

D. List<String> dummy = Mockito.mock(List.class);

Solution

1. Step 1: Identify dummy object creation

   A dummy object should be a simple instance without behavior, so creating an empty ArrayList works.

2. Step 2: Evaluate other options

   Null is not a dummy object; a LinkedList with data is more than dummy; Mockito.mock creates a mock, not a dummy.

3. Final Answer:

   List<String> dummy = new ArrayList<>(); -> Option B

4. Quick Check:

   Empty simple instance = dummy object [OK]

Hint: Use simple empty instance for dummy objects [OK]

Common Mistakes:

• Using null instead of a dummy object
• Creating mocks instead of dummies
• Adding data to dummy objects unnecessarily

3. Consider the following JUnit test snippet:

public void testProcess() {
    Processor processor = new Processor();
    Data dummyData = new Data(); // dummy object
    boolean result = processor.process(dummyData);
    assertTrue(result);
}

What is the role of dummyData here?

medium

A. It acts as a dummy object to satisfy method parameter

B. It provides real data for processing

C. It mocks the Data class behavior

D. It stubs the process method output

Solution

1. Step 1: Analyze dummyData usage

   dummyData is created but not configured or used to affect logic, so it acts as a placeholder.

2. Step 2: Understand dummy vs mock/stub

   It is not mocking or stubbing behavior, just filling the parameter for process method.

3. Final Answer:

   It acts as a dummy object to satisfy method parameter -> Option A

4. Quick Check:

   Dummy object = unused parameter filler [OK]

Hint: Dummy objects fill parameters without behavior [OK]

Common Mistakes:

• Assuming dummyData affects test logic
• Confusing dummy with mock or stub
• Thinking dummyData controls output

4. Identify the error in this JUnit test using a dummy object:

@Test
public void testCalculate() {
    Calculator calc = new Calculator();
    int result = calc.calculate(null); // passing null as dummy
    assertEquals(0, result);
}

medium

A. Test method missing @Before annotation

B. The assertEquals syntax is incorrect

C. Calculator class cannot be instantiated

D. Passing null instead of a dummy object may cause NullPointerException

Solution

1. Step 1: Check dummy object usage

   Passing null is not a dummy object; it may cause NullPointerException if method uses the parameter.

2. Step 2: Verify other options

   assertEquals syntax is correct; Calculator instantiation is valid; @Before is optional here.

3. Final Answer:

   Passing null instead of a dummy object may cause NullPointerException -> Option D

4. Quick Check:

   Null ≠ dummy object [OK]

Hint: Never use null as dummy object [OK]

Common Mistakes:

• Using null instead of dummy object
• Ignoring possible NullPointerException
• Confusing test annotations

5. You have a method sendEmail(User user, EmailContent content) where content is not used in your test. How should you use a dummy object for content in your JUnit test to keep it clean and safe?

hard

A. Create an empty EmailContent instance with default constructor

B. Pass null for content parameter

C. Use a Mockito mock for EmailContent

D. Create EmailContent with real data for testing

Solution

1. Step 1: Understand dummy object purpose

   Since content is unused, a simple empty instance suffices as dummy.

2. Step 2: Avoid null and mocks for dummy

   Null risks errors; mocks add complexity; real data is unnecessary here.

3. Final Answer:

   Create an empty EmailContent instance with default constructor -> Option A

4. Quick Check:

   Empty instance = dummy object [OK]

Hint: Use simple empty instance for unused parameters [OK]

Common Mistakes:

• Passing null causing NullPointerException
• Using mocks instead of dummy objects
• Adding unnecessary real data