assertAll for grouped assertions in JUnit - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of assertAll in JUnit?

assertAll allows you to group multiple assertions together so that all are checked, and you see all failures at once instead of stopping at the first failure.

beginner

How does assertAll improve test feedback compared to separate assertions?

It runs all assertions inside it and reports all failures together, so you get a complete picture of what went wrong in one test run.

beginner

Write a simple example of assertAll with two assertions checking if 2+2 equals 4 and 3+3 equals 6.

assertAll("Math checks",
  () -> assertEquals(4, 2 + 2),
  () -> assertEquals(6, 3 + 3)
);

intermediate

What happens if one assertion inside assertAll fails?

JUnit continues running the other assertions inside assertAll and reports all failures together after running them all.

beginner

Can assertAll be used with lambda expressions in JUnit?

Yes, assertAll takes a heading and a list of lambda expressions, each containing an assertion to run.

What is the main benefit of using assertAll in JUnit tests?

A It stops test execution at the first failure

B It runs all assertions and reports all failures together

C It automatically fixes failed assertions

D It runs assertions in parallel threads

assertAll runs all grouped assertions and reports all failures at once, unlike normal assertions that stop at the first failure.

Which syntax correctly uses assertAll in JUnit?

A assertAll("group", () -> assertEquals(1, 1), () -> assertTrue(true));

B assertAll(assertEquals(1, 1), assertTrue(true));

C assertAll(() -> assertEquals(1, 1), () -> assertTrue(true));

D assertAll("group", assertEquals(1, 1), assertTrue(true));

The correct syntax includes a heading string and lambda expressions for each assertion.

If one assertion fails inside assertAll, what happens next?

A Test stops immediately

B Only the first failure is reported

C Test passes anyway

D Remaining assertions run and all failures reported

assertAll runs all assertions and reports all failures together after running them all.

Which of these is NOT a valid use of assertAll?

A Grouping multiple assertions for better feedback

B Running assertions sequentially and reporting all failures

C Automatically retrying failed assertions

D Using lambda expressions to define assertions

assertAll does not retry failed assertions; it only groups them.

What type of arguments does assertAll accept for assertions?

A Lambda expressions

B Integers

C Strings

D Boolean values

assertAll accepts lambda expressions that contain assertions to run.

Explain how assertAll helps improve test results when multiple checks are needed.

Think about how you want to see all problems at once instead of fixing one by one.

Write a short example using assertAll to check that a string is not null and its length is 5.

Use assertNotNull and assertEquals inside lambda expressions.

Practice

1. What is the main benefit of using assertAll in JUnit tests?

easy

A. It runs multiple assertions and reports all failures together.

B. It stops the test immediately after the first failure.

C. It automatically fixes failed assertions.

D. It runs assertions in parallel threads.

Solution

1. Step 1: Understand assertAll behavior

   assertAll groups multiple assertions and executes them all, regardless of failures.

2. Step 2: Compare options

   It runs multiple assertions and reports all failures together. correctly states that all failures are reported together. Options A, C, and D are incorrect because assertAll does not stop early, fix errors, or run assertions in parallel.

3. Final Answer:

   It runs multiple assertions and reports all failures together. -> Option A

4. Quick Check:

   assertAll reports all failures together = B [OK]

Hint: Remember: assertAll shows all errors, not just first [OK]

Common Mistakes:

• Thinking assertAll stops after first failure
• Believing assertAll fixes errors automatically
• Assuming assertAll runs assertions in parallel

2. Which of the following is the correct syntax to use assertAll in JUnit 5?

easy

A. assertAll(() -> assertEquals(5, sum), () -> assertTrue(flag));

B. assertAll(assertEquals(5, sum), assertTrue(flag));

C. assertAll{ assertEquals(5, sum); assertTrue(flag); }

D. assertAll[() -> assertEquals(5, sum), () -> assertTrue(flag)];

Solution

1. Step 1: Recall assertAll syntax

   In JUnit 5, assertAll takes lambda expressions as arguments, each representing an assertion.

2. Step 2: Check options

   assertAll(() -> assertEquals(5, sum), () -> assertTrue(flag)); correctly uses lambdas with parentheses. Options A, B, and D use incorrect syntax like missing lambdas, braces, or wrong brackets.

3. Final Answer:

   assertAll(() -> assertEquals(5, sum), () -> assertTrue(flag)); -> Option A

4. Quick Check:

   assertAll uses lambdas with parentheses = C [OK]

Hint: Use lambdas inside parentheses for assertAll [OK]

Common Mistakes:

• Omitting lambda arrows () ->
• Using curly braces instead of parentheses
• Passing assertions directly without lambdas

3. Given the code below, what will be the test result?

assertAll(
  () -> assertEquals(2, 1 + 1),
  () -> assertTrue(3 > 5),
  () -> assertFalse(false)
);

medium

A. Test fails showing only the second assertion failure.

B. Test fails showing failures for the second assertion only, but all assertions run.

C. Test fails showing failures for the second assertion only.

D. Test passes because two assertions are true.

Solution

1. Step 1: Evaluate each assertion

   First assertion: 1+1 equals 2, passes. Second: 3 > 5 is false, fails. Third: assertFalse(false) passes.

2. Step 2: Understand assertAll behavior

   All assertions run. The test fails because one assertion failed. The failure report shows the second assertion failure only.

3. Final Answer:

   Test fails showing failures for the second assertion only, but all assertions run. -> Option B

4. Quick Check:

   assertAll runs all, reports all failures = D [OK]

Hint: assertAll runs all assertions, reports all failures [OK]

Common Mistakes:

• Thinking test passes if some assertions pass
• Believing assertAll stops at first failure
• Expecting multiple failure messages when only one fails

4. Identify the error in the following JUnit 5 test code using assertAll:

assertAll(
  () -> assertEquals(10, calculate()),
  assertTrue(isReady())
);

medium

A. assertAll cannot take more than one assertion.

B. assertEquals should be replaced with assertSame.

C. Missing lambda expression for the second assertion.

D. assertTrue should be inside curly braces.

Solution

1. Step 1: Check assertAll argument types

   Each argument to assertAll must be a lambda expression or executable.

2. Step 2: Identify the problem

   The second argument assertTrue(isReady()) is a method call, not a lambda. It should be wrapped as () -> assertTrue(isReady()).

3. Final Answer:

   Missing lambda expression for the second assertion. -> Option C

4. Quick Check:

   assertAll needs lambdas for each assertion = A [OK]

Hint: Wrap each assertion in () -> for assertAll [OK]

Common Mistakes:

• Passing assertions directly without lambdas
• Confusing assertEquals with assertSame
• Using curly braces instead of lambdas

5. You want to test a Person object's fields name, age, and email together using assertAll. Which code snippet correctly groups these assertions and reports all failures at once?

Person p = new Person("Alice", 30, "[e-mail]");
// Choose the correct assertAll usage:

hard

A. assertAll[
() -> assertEquals("Alice", p.getName()),
() -> assertEquals(30, p.getAge()),
() -> assertEquals("[e-mail]", p.getEmail())
];

B. assertAll(
assertEquals("Alice", p.getName()),
assertEquals(30, p.getAge()),
assertEquals("[e-mail]", p.getEmail())
);

C. assertAll(() -> {
assertEquals("Alice", p.getName());
assertEquals(30, p.getAge());
assertEquals("[e-mail]", p.getEmail());
});

D. assertAll(
() -> assertEquals("Alice", p.getName()),
() -> assertEquals(30, p.getAge()),
() -> assertEquals("[e-mail]", p.getEmail())
);

Solution

1. Step 1: Understand assertAll argument requirements

   assertAll expects multiple lambda expressions as separate arguments, each containing one assertion.

2. Step 2: Evaluate each option

   assertAll( () -> assertEquals("Alice", p.getName()), () -> assertEquals(30, p.getAge()), () -> assertEquals("[e-mail]", p.getEmail()) ); correctly passes three lambdas as separate arguments. assertAll( assertEquals("Alice", p.getName()), assertEquals(30, p.getAge()), assertEquals("[e-mail]", p.getEmail()) ); passes method calls directly, which is invalid. assertAll(() -> { assertEquals("Alice", p.getName()); assertEquals(30, p.getAge()); assertEquals("[e-mail]", p.getEmail()); }); passes a single lambda with multiple assertions inside, which does not report all failures separately. assertAll[ () -> assertEquals("Alice", p.getName()), () -> assertEquals(30, p.getAge()), () -> assertEquals("[e-mail]", p.getEmail()) ]; uses square brackets, which is invalid syntax.

3. Final Answer:

   assertAll( () -> assertEquals("Alice", p.getName()), () -> assertEquals(30, p.getAge()), () -> assertEquals("[e-mail]", p.getEmail()) ); -> Option D

4. Quick Check:

   assertAll needs separate lambdas for each assertion = A [OK]

Hint: Use separate lambdas for each assertion inside assertAll [OK]

Common Mistakes:

• Passing assertions directly without lambdas
• Using one lambda with multiple assertions inside
• Using wrong brackets like [] instead of ()