Verification times (times, never, atLeast) in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this JUnit verification?

Given the following Mockito verification code, what will be the test result?

JUnit

mockList.add("test");
mockList.add("test");
verify(mockList, times(2)).add("test");

A Test fails because add("test") was called only once.

B Test passes because add("test") was called exactly twice.

C Test fails because times(2) is not a valid verification mode.

D Test passes because add("test") was called at least twice.

💡 Hint

Remember that times(2) means exactly two calls.

The verify statement expects exactly two calls to add("test"). Since the method is called twice, the verification passes.

❓ Predict Output

intermediate

What happens if a method is never called but verified with never()?

Consider this code snippet: mockList.add("hello"); verify(mockList, never()).clear();

JUnit

mockList.add("hello");
verify(mockList, never()).clear();

A Test passes because clear() was never called.

B Test fails because add("hello") was called.

C Test fails because never() requires at least one call.

D Test passes because add("hello") counts as clear() call.

💡 Hint

never() means the method should not be called at all.

The verify statement checks that clear() was never called. Since clear() was not called, the verification passes.

❓ assertion

advanced

Which verification will fail if the method is called once?

Assume the method mockService.process() is called exactly once. Which verify statement will fail?

JUnit

mockService.process();

A verify(mockService, times(1)).process();

B verify(mockService).process();

C verify(mockService, never()).process();

D verify(mockService, atLeast(2)).process();

💡 Hint

atLeast(2) means two or more calls are expected.

Since process() is called only once, atLeast(2) verification fails because it expects two or more calls.

🔧 Debug

advanced

Identify the error in this verification code

What is wrong with this verification code snippet? verify(mockObj, times(0)).execute();

JUnit

verify(mockObj, times(0)).execute();

A times(0) is valid and means the method was never called.

B times(0) means the method was called once.

C times(0) causes a runtime exception.

D times(0) is invalid; use never() instead.

💡 Hint

times(0) and never() are equivalent in Mockito.

times(0) is a valid verification mode meaning the method was not called. It is equivalent to never().

❓ framework

expert

Which verification mode best fits this scenario?

You want to verify that a method was called at least once but you don't care how many times exactly. Which verification mode should you use?

A never()

B times(1)

C atLeastOnce()

D times(0)

💡 Hint

Think about a verification mode that allows one or more calls.

atLeastOnce() verifies the method was called one or more times, matching the scenario.

Practice

1. Which Mockito verification method checks that a method was called exactly 3 times?

easy

A. verify(mock, atMost(3)).method()

B. verify(mock, never()).method()

C. verify(mock, atLeast(3)).method()

D. verify(mock, times(3)).method()

Solution

1. Step 1: Understand times(n) usage

   The times(n) method verifies that the method was called exactly n times.

2. Step 2: Match the exact call count

   Since the question asks for exactly 3 calls, times(3) is the correct choice.

3. Final Answer:

   verify(mock, times(3)).method() -> Option D

4. Quick Check:

   Exact call count = times(n) [OK]

Hint: Use times(n) for exact call count verification [OK]

Common Mistakes:

• Confusing times(n) with atLeast(n)
• Using never() when calls exist
• Using atMost(n) instead of times(n)

2. Which of the following is the correct syntax to verify that a method was never called using Mockito?

easy

A. verify(mock, never()).method();

B. verify(mock, atLeast(0)).method();

C. verify(mock, times(0));

D. verify(mock).never().method();

Solution

1. Step 1: Identify the correct method for zero calls

   Mockito provides never() to verify that a method was not called at all.

2. Step 2: Check syntax correctness

   The correct syntax is verify(mock, never()).method();. Using times(0) also works but never() is clearer and preferred.

3. Final Answer:

   verify(mock, never()).method(); -> Option A

4. Quick Check:

   No calls = never() [OK]

Hint: Use never() to verify zero calls clearly [OK]

Common Mistakes:

• Using times(0) instead of never() for clarity
• Incorrect chaining like verify(mock).never()
• Using atLeast(0) which always passes

3. Given the following code snippet:

verify(mock, atLeast(2)).process();

Which statement is true about the verification?

medium

A. The method process() must be called exactly 2 times.

B. The method process() must be called at most 2 times.

C. The method process() must be called at least 2 times or more.

D. The method process() must never be called.

Solution

1. Step 1: Understand atLeast(n) meaning

   The atLeast(n) method verifies that the method was called at least n times, meaning 2 or more times.

2. Step 2: Match the verification condition

   Since the code uses atLeast(2), it means the method must be called 2 or more times, not exactly 2.

3. Final Answer:

   The method process() must be called at least 2 times or more. -> Option C

4. Quick Check:

   Minimum calls = atLeast(n) [OK]

Hint: atLeast(n) means minimum n calls, not exact [OK]

Common Mistakes:

• Confusing atLeast(n) with times(n)
• Thinking atLeast(n) means at most n
• Assuming never() means zero calls only

4. Identify the error in this Mockito verification:

verify(mock, never).execute();

medium

A. Using times() instead of never()

B. Missing parentheses after never()

C. Incorrect method name execute()

D. No error, syntax is correct

Solution

1. Step 1: Check syntax of never()

   The never() method requires parentheses to be called as a method.

2. Step 2: Identify missing parentheses

   The code uses never without parentheses, which is a syntax error.

3. Final Answer:

   Missing parentheses after never() -> Option B

4. Quick Check:

   never() requires parentheses [OK]

Hint: Always add () after never to avoid syntax errors [OK]

Common Mistakes:

• Omitting parentheses after never
• Confusing never with times(0)
• Assuming method name causes error

5. You want to verify that a method update() was called at least once but no more than 5 times. Which Mockito verification code correctly expresses this?

hard

A. verify(mock, atLeast(1)).update(); verify(mock, atMost(5)).update();

B. verify(mock, times(1)).update(); verify(mock, times(5)).update();

C. verify(mock, never()).update();

D. verify(mock, atLeast(5)).update();

Solution

1. Step 1: Understand the requirement

   The method update() must be called at least once and at most 5 times.

2. Step 2: Use correct verification methods

   Use atLeast(1) to check minimum calls and atMost(5) to check maximum calls.

3. Step 3: Combine verifications

   Both verifications must be done separately to ensure the call count is between 1 and 5.

4. Final Answer:

   verify(mock, atLeast(1)).update(); verify(mock, atMost(5)).update(); -> Option A

5. Quick Check:

   Range check = atLeast + atMost [OK]

Hint: Combine atLeast(n) and atMost(m) for call count range [OK]

Common Mistakes:

• Using times() twice with different values
• Using never() when calls exist
• Using only atLeast(5) which ignores max limit