Why assertions verify expected outcomes in JUnit - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to assert that the sum of 2 and 3 equals 5.

JUnit

assertEquals([1], 2 + 3);

Drag options to blanks, or click blank then click option'

A5

B7

C4

D6

Attempts:

3 left

💡 Hint

Common Mistakes

Using a wrong expected value like 6 or 4.

Confusing actual and expected values.

The assertion checks if 2 + 3 equals 5, which is the expected outcome.

2fill in blank

medium

Complete the code to assert that the string "hello" starts with "he".

JUnit

assertTrue("hello".[1]("he"));

Drag options to blanks, or click blank then click option'

AendsWith

BstartsWith

Ccontains

Dequals

Attempts:

3 left

💡 Hint

Common Mistakes

Using endsWith instead of startsWith.

Using equals which checks full string equality.

The assertion verifies that the string "hello" starts with the substring "he".

3fill in blank

hard

Fix the error in the assertion that checks if a list is empty.

JUnit

assertTrue([1].isEmpty());

Drag options to blanks, or click blank then click option'

AmyList.get(0)

BmyList.size()

CmyList

DmyList.isEmpty

Attempts:

3 left

💡 Hint

Common Mistakes

Calling isEmpty on size() or get(0) which are not boolean methods.

Using isEmpty without parentheses.

The method isEmpty() is called on the list object myList to check if it is empty.

4fill in blank

hard

Fill both blanks to assert that the multiplication of 4 and 5 equals 20.

JUnit

assertEquals([1], [2] * 5);

Drag options to blanks, or click blank then click option'

A4

B20

C6

D3

Attempts:

3 left

💡 Hint

Common Mistakes

Using 20 as the first blank and 20 as the second blank causing wrong multiplication.

Using 6 or 3 which do not produce 20 when multiplied by 5.

The assertion checks if 4 * 5 equals 20 by using 4 as the variable and multiplying by 5.

5fill in blank

hard

Fill all three blanks to assert that the substring "test" is contained in "unittesting".

JUnit

assertTrue("unittesting".[1]([2].[3]()));

Drag options to blanks, or click blank then click option'

Acontains

B"test"

CtoString

DstartsWith

Attempts:

3 left

💡 Hint

Common Mistakes

Using startsWith instead of contains.

Not converting the substring to string before checking.

The assertion checks if the string "unittesting" contains the substring "test" converted to string.

Practice

1. Why do we use assertions in JUnit tests?

easy

A. To pause the test execution

B. To print messages to the console

C. To create new objects in the test

D. To check if the actual output matches the expected output

Solution

1. Step 1: Understand the purpose of assertions

   Assertions are used to compare the actual result of code with what we expect it to be.

2. Step 2: Identify the correct use in JUnit

   JUnit assertions verify correctness by checking if actual equals expected, helping catch errors early.

3. Final Answer:

   To check if the actual output matches the expected output -> Option D

4. Quick Check:

   Assertions verify expected outcomes = A [OK]

Hint: Assertions compare actual vs expected results [OK]

Common Mistakes:

• Thinking assertions print messages
• Using assertions to create objects
• Believing assertions pause tests

2. Which of the following is the correct syntax to assert that two integers are equal in JUnit?

easy

A. assertEquals(expected, actual);

B. assertEqual(actual, expected);

C. assertEquals(actual, expected);

D. assertEqual(expected, actual);

Solution

1. Step 1: Recall JUnit assertion method signature

   The correct method is assertEquals(expected, actual) where expected value comes first.

2. Step 2: Check each option's parameter order and method name

   Only assertEquals(expected, actual); uses assertEquals with expected first, matching JUnit syntax.

3. Final Answer:

   assertEquals(expected, actual); -> Option A

4. Quick Check:

   assertEquals(expected, actual) = B [OK]

Hint: Remember expected value comes first in assertEquals [OK]

Common Mistakes:

• Swapping expected and actual parameters
• Using assertEqual instead of assertEquals
• Confusing parameter order

3. Consider this JUnit test snippet:

int result = calculator.add(2, 3);
assertEquals(5, result);

What happens if calculator.add(2, 3) returns 4 instead of 5?

medium

A. The test fails with an assertion error

B. The test passes successfully

C. The test throws a syntax error

D. The test is skipped

Solution

1. Step 1: Understand assertion behavior on mismatch

   If actual result (4) does not equal expected (5), assertEquals fails and throws an error.

2. Step 2: Identify test outcome

   JUnit reports a failure with an assertion error, indicating the test did not pass.

3. Final Answer:

   The test fails with an assertion error -> Option A

4. Quick Check:

   Mismatch causes failure = A [OK]

Hint: Assertion fails if actual ≠ expected [OK]

Common Mistakes:

• Thinking test passes despite wrong result
• Confusing assertion failure with syntax error
• Assuming test is skipped automatically

4. Identify the error in this JUnit assertion:

assertEquals(result, 10);

Assuming result is an integer variable expected to be 10.

medium

A. assertEquals requires a message parameter

B. assertEquals cannot compare integers

C. The parameters are reversed; expected should be first

D. Missing semicolon at the end

Solution

1. Step 1: Check parameter order in assertEquals

   JUnit expects assertEquals(expected, actual), but here actual is first.

2. Step 2: Confirm other syntax elements

   Semicolon is present, integers can be compared, message is optional, so no other errors.

3. Final Answer:

   The parameters are reversed; expected should be first -> Option C

4. Quick Check:

   Expected first in assertEquals = D [OK]

Hint: Expected value always comes first in assertEquals [OK]

Common Mistakes:

• Swapping expected and actual parameters
• Thinking assertEquals needs a message
• Assuming semicolon is missing

5. You want to verify a method returns a non-null string "Hello". Which assertion best verifies both conditions in one test?

hard

A. assertNotNull(result); assertEquals("Hello", result);

B. assertTrue(result != null && result.equals("Hello"));

C. assertEquals("Hello", result);

D. assertNull(result);

Solution

1. Step 1: Understand the requirement

   We want to check result is not null and equals "Hello" in one assertion.

2. Step 2: Evaluate each option

   assertNotNull(result); assertEquals("Hello", result); uses two assertions, not one. assertEquals("Hello", result); checks equality but not null explicitly. assertTrue(result != null && result.equals("Hello")); uses assertTrue with combined condition, verifying both at once. assertNull(result); checks for null, which is opposite.

3. Final Answer:

   assertTrue(result != null && result.equals("Hello")); -> Option B

4. Quick Check:

   Combine conditions in assertTrue = C [OK]

Hint: Use assertTrue with combined condition for multiple checks [OK]

Common Mistakes:

• Using multiple assertions instead of one
• Not checking for null explicitly
• Using assertNull when expecting non-null