Arrange-Act-Assert pattern in JUnit - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare the test method with the correct annotation.

JUnit

@[1]
public void testAddition() {
    // test code here
}

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

AIgnore

BBefore

CAfter

DTest

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Before or @After instead of @Test

Forgetting the '@' symbol

The @Test annotation marks a method as a test method in JUnit.

2fill in blank

medium

Complete the code to create an instance of Calculator in the Arrange step.

JUnit

public void testAddition() {
    Calculator calculator = new [1]();
    int result = calculator.add(2, 3);
    // assertions
}

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

ACalculator

BAdd

CTest

DSum

Attempts:

3 left

💡 Hint

Common Mistakes

Using method names instead of class names

Using lowercase instead of class name capitalization

In the Arrange step, we create an object of the class we want to test, here Calculator.

3fill in blank

hard

Fix the error in the assertion statement to check the expected result.

JUnit

assertEquals([1], result);

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

A"5"

Bresult

C5

Dtrue

Attempts:

3 left

💡 Hint

Common Mistakes

Using the actual result as expected value

Using a string instead of an integer

The expected value should be the number 5, not the variable or string.

4fill in blank

hard

Fill both blanks to complete the Arrange and Act steps correctly.

JUnit

Calculator calculator = new [1]();
int result = calculator.[2](4, 6);

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

ACalculator

Badd

Csubtract

DCalculatorTest

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong class name for object creation

Calling a method that does not exist or is incorrect

We create a Calculator object and call its add method.

5fill in blank

hard

Fill all three blanks to complete the Arrange, Act, and Assert steps in the test method.

JUnit

@Test
public void testMultiply() {
    Calculator calculator = new [1]();
    int result = calculator.[2](3, 7);
    assertEquals([3], result);
}

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

ACalculator

Bmultiply

C21

DCalculatorTest

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong class name

Calling wrong method

Asserting wrong expected value

The test creates a Calculator, calls multiply with 3 and 7, and asserts the result is 21.

Practice

1. What is the main purpose of the Arrange-Act-Assert pattern in JUnit testing?

easy

A. To write tests without any setup

B. To organize tests into setup, action, and verification steps

C. To skip assertions in tests

D. To run tests in parallel automatically

Solution

1. Step 1: Understand the pattern components

   Arrange-Act-Assert divides a test into three clear parts: setup (Arrange), execution (Act), and checking results (Assert).

2. Step 2: Identify the purpose

   This separation helps make tests easier to read and maintain by clearly showing what is prepared, what is done, and what is checked.

3. Final Answer:

   To organize tests into setup, action, and verification steps -> Option B

4. Quick Check:

   Arrange-Act-Assert = organize test steps [OK]

Hint: Remember: Arrange = setup, Act = do, Assert = check [OK]

Common Mistakes:

• Thinking Arrange means skipping setup
• Believing Act is for assertions
• Confusing Assert with running tests
• Assuming it runs tests in parallel

2. Which of the following is the correct order of steps in the Arrange-Act-Assert pattern in a JUnit test?

easy

A. Arrange, Act, Assert

B. Assert, Arrange, Act

C. Act, Arrange, Assert

D. Act, Assert, Arrange

Solution

1. Step 1: Recall the pattern sequence

   The pattern always starts with Arrange (setup), then Act (execute), and finally Assert (verify).

2. Step 2: Match the correct order

   Only Arrange, Act, Assert lists the steps in the correct order: Arrange, Act, Assert.

3. Final Answer:

   Arrange, Act, Assert -> Option A

4. Quick Check:

   Order = Arrange, Act, Assert [OK]

Hint: Think: Prepare, Perform, Prove in order [OK]

Common Mistakes:

• Mixing up the order of Act and Assert
• Starting with Assert before setup
• Skipping the Arrange step
• Confusing Act with Assert

3. Consider the following JUnit test code snippet:

void testSum() {
  int a = 5;
  int b = 3;
  int result = Calculator.add(a, b);
  assertEquals(8, result);
}

Which part of the Arrange-Act-Assert pattern does int result = Calculator.add(a, b); represent?

medium

A. Arrange

B. Cleanup

C. Assert

D. Act

Solution

1. Step 1: Identify the code purpose

   The line calls the method under test to perform the action, storing the output.

2. Step 2: Match to pattern step

   This is the 'Act' step where the test executes the behavior to be tested.

3. Final Answer:

   Act -> Option D

4. Quick Check:

   Calling method = Act step [OK]

Hint: Act is the step where you call the method under test [OK]

Common Mistakes:

• Confusing Act with Arrange (setup)
• Thinking assertEquals line is Act
• Assuming variable declarations are Act
• Selecting Cleanup which is not part of AAA

4. Identify the error in this JUnit test following the Arrange-Act-Assert pattern:

@Test
void testMultiply() {
  int x = 4;
  int y = 2;
  int product = x * y;
  assertEquals(8, x * y);
}

medium

A. The Act step is missing

B. The Arrange step is incorrect

C. The Assert step uses a direct expression instead of the product variable

D. The test method lacks the @Before annotation

Solution

1. Step 1: Review the Act step

   The Act step is the calculation: int product = x * y; which is correct.

2. Step 2: Check the Assert step

   The assertion compares 8 with x * y directly instead of using the product variable, which breaks the pattern clarity.

3. Final Answer:

   The Assert step uses a direct expression instead of the product variable -> Option C

4. Quick Check:

   Assert should check the Act result variable [OK]

Hint: Assert should verify the Act result variable, not repeat calculation [OK]

Common Mistakes:

• Thinking Act step is missing
• Believing @Before is required for every test
• Confusing Arrange with Act
• Ignoring the importance of using variables in Assert

5. You want to test a method divide(int a, int b) that throws IllegalArgumentException when b is zero. Using Arrange-Act-Assert, which is the best way to write this test in JUnit 5?

hard

A. Arrange inputs, call divide inside assertThrows, Assert exception is thrown

B. Arrange inputs, call divide normally, Assert result equals zero

C. Call divide without Arrange, Assert no exception thrown

D. Arrange inputs, call divide, Assert result equals a divided by b

Solution

1. Step 1: Arrange inputs for exception case

   Set a to any number and b to zero to trigger the exception.

2. Step 2: Act by calling divide inside assertThrows

   Use assertThrows(IllegalArgumentException.class, () -> divide(a, b)) to check the exception is thrown.

3. Step 3: Assert the exception is correctly thrown

   This confirms the method behaves as expected when dividing by zero.

4. Final Answer:

   Arrange inputs, call divide inside assertThrows, Assert exception is thrown -> Option A

5. Quick Check:

   Use assertThrows for exception tests [OK]

Hint: Use assertThrows to test exceptions in Act-Assert step [OK]

Common Mistakes:

• Ignoring exception testing and checking wrong result
• Calling method outside assertThrows
• Not arranging inputs properly
• Asserting wrong expected value