Back to Repositories

Testing Queue Data Structure Implementations in williamfiset/Algorithms

This test suite validates the implementation of various Queue data structures in Java, including ArrayQueue, LinkedQueue, and IntQueue. The suite uses JUnit’s parameterized testing to ensure consistent behavior across different queue implementations.

Test Coverage Overview

The test suite provides comprehensive coverage of queue operations including:

Empty queue validation
Basic operations (offer, peek, poll)
Edge cases for empty queue operations
Exhaustive testing of queue state transitions

Tests verify size tracking, element ordering, and proper exception handling across all queue implementations.

Implementation Analysis

The testing approach utilizes JUnit 5’s parameterized testing framework with @MethodSource to test multiple queue implementations simultaneously. Each test case is executed against ArrayQueue, LinkedQueue, and IntQueue implementations, ensuring consistent behavior across different underlying data structures.

The suite employs Google Truth assertions for improved readability and error reporting.

Technical Details

Testing tools and configuration:

JUnit Jupiter for test execution
ParameterizedTest annotations for multiple implementation testing
Google Truth assertion library
Method source provider for test parameterization
Exception testing using assertThrows

Best Practices Demonstrated

The test suite exemplifies several testing best practices:

DRY principle through parameterized testing
Comprehensive state validation
Isolated test cases for specific behaviors
Clear test method naming
Thorough edge case coverage
Consistent verification patterns

williamfiset/algorithms

src/test/java/com/williamfiset/algorithms/datastructures/queue/QueueTest.java

            
package com.williamfiset.algorithms.datastructures.queue;

import static com.google.common.truth.Truth.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;

import java.util.ArrayList;
import java.util.List;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;

public class QueueTest {

  private static List<Queue<Integer>> inputs() {
    List<Queue<Integer>> queues = new ArrayList<>();
    queues.add(new ArrayQueue<Integer>(2));
    queues.add(new LinkedQueue<Integer>());
    queues.add(new IntQueue(2));
    return queues;
  }

  @ParameterizedTest
  @MethodSource("inputs")
  public void testEmptyQueue(Queue<Integer> queue) {
    assertThat(queue.isEmpty()).isTrue();
    assertThat(queue.size()).isEqualTo(0);
  }

  @ParameterizedTest
  @MethodSource("inputs")
  public void testPollOnEmpty(Queue<Integer> queue) {
    assertThrows(Exception.class, () -> queue.poll());
  }

  @ParameterizedTest
  @MethodSource("inputs")
  public void testPeekOnEmpty(Queue<Integer> queue) {
    assertThrows(Exception.class, () -> queue.peek());
  }

  @ParameterizedTest
  @MethodSource("inputs")
  public void testOffer(Queue<Integer> queue) {
    queue.offer(2);
    assertThat(queue.size()).isEqualTo(1);
  }

  @ParameterizedTest
  @MethodSource("inputs")
  public void testPeek(Queue<Integer> queue) {
    queue.offer(2);
    assertThat((int) queue.peek()).isEqualTo(2);
    assertThat(queue.size()).isEqualTo(1);
  }

  @ParameterizedTest
  @MethodSource("inputs")
  public void testPoll(Queue<Integer> queue) {
    queue.offer(2);
    assertThat((int) queue.poll()).isEqualTo(2);
    assertThat(queue.size()).isEqualTo(0);
  }

  @ParameterizedTest
  @MethodSource("inputs")
  public void testExhaustively(Queue<Integer> queue) {
    assertThat(queue.isEmpty()).isTrue();
    queue.offer(1);
    assertThat(queue.isEmpty()).isFalse();
    queue.offer(2);
    assertThat(queue.size()).isEqualTo(2);
    assertThat((int) queue.peek()).isEqualTo(1);
    assertThat(queue.size()).isEqualTo(2);
    assertThat((int) queue.poll()).isEqualTo(1);
    assertThat(queue.size()).isEqualTo(1);
    assertThat((int) queue.peek()).isEqualTo(2);
    assertThat(queue.size()).isEqualTo(1);
    assertThat((int) queue.poll()).isEqualTo(2);
    assertThat(queue.size()).isEqualTo(0);
    assertThat(queue.isEmpty()).isTrue();
  }
}