Skip to content

testing: improve QueueTest #6423

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 3 commits into from
Jul 23, 2025
Merged
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
200 changes: 200 additions & 0 deletions src/test/java/com/thealgorithms/datastructures/queues/QueueTest.java
Original file line number Diff line number Diff line change
Expand Up @@ -124,4 +124,204 @@ void testQueueCapacityException() {
Assertions.assertThrows(IllegalArgumentException.class, () -> new Queue<>(0));
Assertions.assertThrows(IllegalArgumentException.class, () -> new Queue<>(-5));
}

@Test
void testCircularBehavior() {
// Test that queue behaves correctly after multiple insert/remove cycles
queue.insert(1);
queue.insert(2);
queue.insert(3);

// Remove all elements
queue.remove(); // removes 1
queue.remove(); // removes 2
queue.remove(); // removes 3

// Add elements again to test circular behavior
queue.insert(4);
queue.insert(5);
queue.insert(6);

Assertions.assertEquals(4, queue.peekFront());
Assertions.assertEquals(6, queue.peekRear());
Assertions.assertEquals(3, queue.getSize());
Assertions.assertTrue(queue.isFull());
}

@Test
void testMixedInsertRemoveOperations() {
// Test interleaved insert and remove operations
queue.insert(1);
queue.insert(2);

Assertions.assertEquals(1, queue.remove());
queue.insert(3);
queue.insert(4);

Assertions.assertEquals(2, queue.remove());
Assertions.assertEquals(3, queue.remove());

queue.insert(5);
queue.insert(6);

Assertions.assertEquals(4, queue.peekFront());
Assertions.assertEquals(6, queue.peekRear());
Assertions.assertEquals(3, queue.getSize());
}

@Test
void testSingleElementOperations() {
// Test operations with single element
queue.insert(42);

Assertions.assertEquals(42, queue.peekFront());
Assertions.assertEquals(42, queue.peekRear());
Assertions.assertEquals(1, queue.getSize());
Assertions.assertFalse(queue.isEmpty());
Assertions.assertFalse(queue.isFull());

Assertions.assertEquals(42, queue.remove());
Assertions.assertTrue(queue.isEmpty());
Assertions.assertEquals(0, queue.getSize());
}

@Test
void testNullValueHandling() {
// Test queue with null values (if supported)
Queue<String> stringQueue = new Queue<>(3);

Assertions.assertTrue(stringQueue.insert(null));
Assertions.assertTrue(stringQueue.insert("test"));
Assertions.assertTrue(stringQueue.insert(null));

Assertions.assertNull(stringQueue.peekFront());
Assertions.assertNull(stringQueue.peekRear());
Assertions.assertEquals(3, stringQueue.getSize());

Assertions.assertNull(stringQueue.remove());
Assertions.assertEquals("test", stringQueue.peekFront());
}

@Test
void testStringDataType() {
// Test queue with String data type
Queue<String> stringQueue = new Queue<>(2);
stringQueue.insert("first");
stringQueue.insert("second");

Assertions.assertEquals("first", stringQueue.peekFront());
Assertions.assertEquals("second", stringQueue.peekRear());
}

@Test
void testLargerCapacityQueue() {
// Test queue with larger capacity
Queue<Integer> largeQueue = new Queue<>(10);

// Fill the queue
for (int i = 1; i <= 10; i++) {
Assertions.assertTrue(largeQueue.insert(i));
}

Assertions.assertTrue(largeQueue.isFull());
Assertions.assertFalse(largeQueue.insert(11));

// Remove half the elements
for (int i = 1; i <= 5; i++) {
Assertions.assertEquals(i, largeQueue.remove());
}

Assertions.assertEquals(6, largeQueue.peekFront());
Assertions.assertEquals(10, largeQueue.peekRear());
Assertions.assertEquals(5, largeQueue.getSize());
}

@Test
void testQueueCapacityOne() {
// Test queue with capacity of 1
Queue<Integer> singleQueue = new Queue<>(1);

Assertions.assertTrue(singleQueue.isEmpty());
Assertions.assertFalse(singleQueue.isFull());

Assertions.assertTrue(singleQueue.insert(100));
Assertions.assertTrue(singleQueue.isFull());
Assertions.assertFalse(singleQueue.isEmpty());
Assertions.assertFalse(singleQueue.insert(200));

Assertions.assertEquals(100, singleQueue.peekFront());
Assertions.assertEquals(100, singleQueue.peekRear());

Assertions.assertEquals(100, singleQueue.remove());
Assertions.assertTrue(singleQueue.isEmpty());
}

@Test
void testQueueWraparoundIndexing() {
// Test that internal array indexing wraps around correctly
queue.insert(1);
queue.insert(2);
queue.insert(3); // Queue full

// Remove one element
queue.remove(); // removes 1

// Add another element (should wrap around)
queue.insert(4);

Assertions.assertEquals("[2, 3, 4]", queue.toString());
Assertions.assertEquals(2, queue.peekFront());
Assertions.assertEquals(4, queue.peekRear());

// Continue the pattern
queue.remove(); // removes 2
queue.insert(5);

Assertions.assertEquals(3, queue.peekFront());
Assertions.assertEquals(5, queue.peekRear());
}

@Test
void testQueueStateAfterMultipleCycles() {
// Test queue state after multiple complete fill/empty cycles
for (int cycle = 0; cycle < 3; cycle++) {
// Fill the queue
for (int i = 1; i <= 3; i++) {
queue.insert(i + cycle * 10);
}

// Verify state
Assertions.assertTrue(queue.isFull());
Assertions.assertEquals(3, queue.getSize());

// Empty the queue
for (int i = 1; i <= 3; i++) {
queue.remove();
}

// Verify empty state
Assertions.assertTrue(queue.isEmpty());
Assertions.assertEquals(0, queue.getSize());
}
}

@Test
void testQueueConsistencyAfterOperations() {
// Test that queue maintains consistency after various operations
queue.insert(10);
queue.insert(20);

int firstRemoved = queue.remove();
queue.insert(30);
queue.insert(40);

int secondRemoved = queue.remove();
queue.insert(50);

// Verify the order is maintained
Assertions.assertEquals(10, firstRemoved);
Assertions.assertEquals(20, secondRemoved);
Assertions.assertEquals(30, queue.peekFront());
Assertions.assertEquals(50, queue.peekRear());
}
}