Test execution time analysis in JUnit - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to measure the execution time of a test method using System.nanoTime().

JUnit

long startTime = System.nanoTime();
// test code here
long endTime = System.nanoTime();
long duration = endTime - [1];
System.out.println("Execution time in nanoseconds: " + duration);

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

ASystem.currentTimeMillis()

BendTime

Cduration

DstartTime

Attempts:

3 left

💡 Hint

Common Mistakes

Subtracting endTime from startTime, which results in negative duration.

Using System.currentTimeMillis() instead of System.nanoTime() for both times.

The duration is calculated by subtracting the start time from the end time. So, duration = endTime - startTime; is correct.

2fill in blank

medium

Complete the code to annotate a JUnit 5 test method that measures execution time.

JUnit

@[1]
void testMethodExecutionTime() {
    // test code
}

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

ABeforeEach

BAfterEach

CTest

DDisabled

Attempts:

3 left

💡 Hint

Common Mistakes

Using @BeforeEach or @AfterEach instead of @Test.

Using @Disabled which disables the test.

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

3fill in blank

hard

Fix the error in the code that tries to assert the test execution time is less than 1 second.

JUnit

long duration = endTime - startTime;
assertTrue(duration [1] 1_000_000_000, "Test took too long");

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

A>

B<

C==

D>=

Attempts:

3 left

💡 Hint

Common Mistakes

Using > which would assert the test took longer than 1 second.

Using == which is too strict and unlikely.

The assertion should check that the duration is less than 1 second (1,000,000,000 nanoseconds), so the operator is <.

4fill in blank

hard

Fill both blanks to correctly calculate and print the execution time in milliseconds.

JUnit

long start = System.nanoTime();
// test code
long end = System.nanoTime();
long durationMs = (end [1] start) [2] 1_000_000;
System.out.println("Execution time in ms: " + durationMs);

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

A-

B/

C*

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Multiplying instead of dividing by 1,000,000.

Adding instead of subtracting start from end.

First, subtract start from end to get duration in nanoseconds, then divide by 1,000,000 to convert to milliseconds.

5fill in blank

hard

Fill both blanks to create a map of test names to their execution times in milliseconds, filtering only tests longer than 100 ms.

JUnit

Map<String, Long> slowTests = testTimes.entrySet().stream()
    .filter(e -> e.getValue() [1] 100_000_000)
    .collect(Collectors.toMap(
        e -> e.getKey(),
        e -> e.getValue() [2] 1_000_000, 
        (a, b) -> a, 
        LinkedHashMap::new));

slowTests.forEach((name, time) -> System.out.println(name + ": " + time + " ms"));

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

A>

B/

C*

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using < instead of > in filter.

Multiplying instead of dividing to convert units.

Filter tests with execution time greater than 100 ms, then convert nanoseconds to milliseconds by dividing by 1,000,000.

Practice

1. What is the main purpose of measuring test execution time in JUnit?

easy

A. To automatically fix failing tests

B. To check if tests are written with correct syntax

C. To verify the correctness of test assertions

D. To identify slow tests and improve test suite performance

Solution

1. Step 1: Understand test execution time concept

   Measuring execution time helps find tests that take longer than expected.

2. Step 2: Identify the goal of measuring time

   Knowing slow tests allows developers to optimize or fix them, improving overall test speed.

3. Final Answer:

   To identify slow tests and improve test suite performance -> Option D

4. Quick Check:

   Execution time = find slow tests [OK]

Hint: Execution time helps spot slow tests to speed up runs [OK]

Common Mistakes:

• Confusing execution time with test correctness
• Thinking it fixes tests automatically
• Ignoring performance impact of slow tests

2. Which JUnit code snippet correctly measures the execution time of a test method?

easy

A. long start = System.nanoTime(); // test code here
long end = System.nanoTime(); System.out.println(end - start);

B. long start = System.currentTimeMillis(); // test code here
long end = System.currentTimeMillis(); System.out.println(end - start);

C. int start = System.nanoTime(); // test code here
int end = System.nanoTime(); System.out.println(end - start);

D. int start = System.currentTimeMillis(); // test code here
int end = System.currentTimeMillis(); System.out.println(end - start);

Solution

1. Step 1: Check correct data type for time

   System.nanoTime() returns long, so variables must be long, not int.

2. Step 2: Verify correct method usage

   System.nanoTime() is preferred for measuring elapsed time with better precision.

3. Final Answer:

   long start = System.nanoTime(); // test code here long end = System.nanoTime(); System.out.println(end - start); -> Option A

4. Quick Check:

   Use long + System.nanoTime() for timing [OK]

Hint: Use long type with System.nanoTime() for precise timing [OK]

Common Mistakes:

• Using int instead of long for time variables
• Using System.currentTimeMillis() for high precision timing
• Mixing data types causing compile errors

3. Given the following JUnit test snippet, what will be printed?

long start = System.nanoTime();
Thread.sleep(100);
long end = System.nanoTime();
System.out.println((end - start) / 1_000_000 + " ms");

medium

A. Approximately 100 ms

B. Exactly 100 ms

C. Approximately 0 ms

D. Compilation error due to Thread.sleep

Solution

1. Step 1: Understand Thread.sleep effect

   Thread.sleep(100) pauses the thread for about 100 milliseconds.

2. Step 2: Calculate elapsed time in milliseconds

   Elapsed time = (end - start) in nanoseconds, divided by 1,000,000 converts to milliseconds, close to 100 ms.

3. Final Answer:

   Approximately 100 ms -> Option A

4. Quick Check:

   Sleep 100ms prints ~100 ms [OK]

Hint: Sleep pauses ~100ms, nanoTime difference shows ~100 ms [OK]

Common Mistakes:

• Expecting exact 100 ms (sleep is approximate)
• Confusing nanoseconds with milliseconds
• Thinking Thread.sleep causes compile error

4. Identify the error in this JUnit test measuring execution time:

@Test
void testMethod() {
  long start = System.nanoTime();
  // test code
  long end = System.nanoTime();
  System.out.println(end - start);
}

medium

A. Missing exception handling for test code

B. Using System.nanoTime() is incorrect for timing

C. No error; code correctly measures time

D. Printing time inside test causes test failure

Solution

1. Step 1: Review timing code correctness

   Using System.nanoTime() before and after test code correctly measures elapsed time.

2. Step 2: Check for syntax or runtime errors

   No syntax errors or exceptions are present; printing time is allowed and does not fail test.

3. Final Answer:

   No error; code correctly measures time -> Option C

4. Quick Check:

   System.nanoTime() timing code is valid [OK]

Hint: Timing code with nanoTime and print is valid [OK]

Common Mistakes:

• Assuming print causes test failure
• Thinking exception handling is mandatory here
• Confusing nanoTime with incorrect timing method

5. You want to fail a JUnit test if it runs longer than 500 milliseconds. Which approach correctly implements this using execution time measurement?

hard

A. Use System.currentTimeMillis() and assert elapsed time <= 500 nanoseconds without conversion

B. Record start and end time with System.nanoTime(), then assert elapsed time <= 500_000_000 nanoseconds

C. Print execution time and manually check after test runs

D. Use Thread.sleep(500) inside the test to limit execution time

Solution

1. Step 1: Understand time units and assertion

   System.nanoTime() returns nanoseconds; 500 ms = 500,000,000 ns.

2. Step 2: Implement assertion on elapsed time

   Calculate elapsed = end - start; assert elapsed <= 500_000_000 to fail if too slow.

3. Final Answer:

   Record start and end time with System.nanoTime(), then assert elapsed time <= 500_000_000 nanoseconds -> Option B

4. Quick Check:

   Assert elapsed ≤ 500ms in nanoseconds [OK]

Hint: Convert 500ms to nanoseconds and assert elapsed ≤ that [OK]

Common Mistakes:

• Using Thread.sleep to limit test time
• Not converting time units correctly
• Only printing time without assertion