From 89d1a7b0b9d007033111446388fa09af3586a324 Mon Sep 17 00:00:00 2001 From: alxkm Date: Sun, 20 Jul 2025 00:01:35 +0200 Subject: [PATCH 1/2] testing: improve CircularBufferTest --- .../buffers/CircularBufferTest.java | 152 +++++++++++++++++- 1 file changed, 148 insertions(+), 4 deletions(-) diff --git a/src/test/java/com/thealgorithms/datastructures/buffers/CircularBufferTest.java b/src/test/java/com/thealgorithms/datastructures/buffers/CircularBufferTest.java index b115fc187b1a..09adb07d9484 100644 --- a/src/test/java/com/thealgorithms/datastructures/buffers/CircularBufferTest.java +++ b/src/test/java/com/thealgorithms/datastructures/buffers/CircularBufferTest.java @@ -2,7 +2,6 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; import org.junit.jupiter.api.Test; @@ -68,11 +67,11 @@ void testFullBuffer() { @Test void testIllegalArguments() { - assertThrows(IllegalArgumentException.class, () -> new CircularBuffer<>(0)); - assertThrows(IllegalArgumentException.class, () -> new CircularBuffer<>(-1)); + org.junit.jupiter.api.Assertions.assertThrows(IllegalArgumentException.class, () -> new CircularBuffer<>(0)); + org.junit.jupiter.api.Assertions.assertThrows(IllegalArgumentException.class, () -> new CircularBuffer<>(-1)); CircularBuffer buffer = new CircularBuffer<>(1); - assertThrows(IllegalArgumentException.class, () -> buffer.put(null)); + org.junit.jupiter.api.Assertions.assertThrows(IllegalArgumentException.class, () -> buffer.put(null)); } @Test @@ -85,4 +84,149 @@ void testLargeBuffer() { buffer.put(1000); // This should overwrite 0 assertEquals(1, buffer.get()); } + + @Test + void testPutAfterGet() { + CircularBuffer buffer = new CircularBuffer<>(2); + buffer.put(10); + buffer.put(20); + assertEquals(10, buffer.get()); + buffer.put(30); + assertEquals(20, buffer.get()); + assertEquals(30, buffer.get()); + assertNull(buffer.get()); + } + + @Test + void testMultipleWrapArounds() { + CircularBuffer buffer = new CircularBuffer<>(3); + for (int i = 1; i <= 6; i++) { + buffer.put(i); + buffer.get(); // add and immediately remove + } + assertTrue(buffer.isEmpty()); + assertNull(buffer.get()); + } + + @Test + void testOverwriteMultipleTimes() { + CircularBuffer buffer = new CircularBuffer<>(2); + buffer.put("X"); + buffer.put("Y"); + buffer.put("Z"); // overwrites "X" + buffer.put("W"); // overwrites "Y" + assertEquals("Z", buffer.get()); + assertEquals("W", buffer.get()); + assertNull(buffer.get()); + } + + @Test + void testIsEmptyAndIsFullTransitions() { + CircularBuffer buffer = new CircularBuffer<>(2); + assertTrue(buffer.isEmpty()); + org.junit.jupiter.api.Assertions.assertFalse(buffer.isFull()); + + buffer.put(1); + org.junit.jupiter.api.Assertions.assertFalse(buffer.isEmpty()); + org.junit.jupiter.api.Assertions.assertFalse(buffer.isFull()); + + buffer.put(2); + assertTrue(buffer.isFull()); + + buffer.get(); + org.junit.jupiter.api.Assertions.assertFalse(buffer.isFull()); + + buffer.get(); + assertTrue(buffer.isEmpty()); + } + + @Test + void testInterleavedPutAndGet() { + CircularBuffer buffer = new CircularBuffer<>(3); + buffer.put("A"); + buffer.put("B"); + assertEquals("A", buffer.get()); + buffer.put("C"); + assertEquals("B", buffer.get()); + assertEquals("C", buffer.get()); + assertNull(buffer.get()); + } + + @Test + void testRepeatedNullInsertionThrows() { + CircularBuffer buffer = new CircularBuffer<>(5); + for (int i = 0; i < 3; i++) { + int finalI = i; + org.junit.jupiter.api.Assertions.assertThrows(IllegalArgumentException.class, () -> buffer.put(null), "Iteration: " + finalI); + } + } + @Test + void testFillThenEmptyThenReuseBuffer() { + CircularBuffer buffer = new CircularBuffer<>(3); + + buffer.put(1); + buffer.put(2); + buffer.put(3); + assertTrue(buffer.isFull()); + + assertEquals(1, buffer.get()); + assertEquals(2, buffer.get()); + assertEquals(3, buffer.get()); + + assertTrue(buffer.isEmpty()); + + buffer.put(4); + buffer.put(5); + assertEquals(4, buffer.get()); + assertEquals(5, buffer.get()); + assertTrue(buffer.isEmpty()); + } + + @Test + void testPutReturnsTrueOnlyIfPreviouslyEmpty() { + CircularBuffer buffer = new CircularBuffer<>(2); + + assertTrue(buffer.put("one")); // was empty + org.junit.jupiter.api.Assertions.assertFalse(buffer.put("two")); // not empty + org.junit.jupiter.api.Assertions.assertFalse(buffer.put("three")); // overwrite + } + + @Test + void testOverwriteAndGetAllElementsCorrectly() { + CircularBuffer buffer = new CircularBuffer<>(3); + + buffer.put(1); + buffer.put(2); + buffer.put(3); + buffer.put(4); // Overwrites 1 + buffer.put(5); // Overwrites 2 + + assertEquals(3, buffer.get()); + assertEquals(4, buffer.get()); + assertEquals(5, buffer.get()); + assertNull(buffer.get()); + } + + @Test + void testBufferWithOneElementCapacity() { + CircularBuffer buffer = new CircularBuffer<>(1); + + assertTrue(buffer.put("first")); + assertEquals("first", buffer.get()); + assertNull(buffer.get()); + + assertTrue(buffer.put("second")); + assertEquals("second", buffer.get()); + } + + @Test + void testPointerWraparoundWithExactMultipleOfCapacity() { + CircularBuffer buffer = new CircularBuffer<>(3); + for (int i = 0; i < 6; i++) { + buffer.put(i); + buffer.get(); // keep buffer size at 0 + } + assertTrue(buffer.isEmpty()); + assertNull(buffer.get()); + } } From c001f41e3ff4b57b853746b65c06e4db24c75bed Mon Sep 17 00:00:00 2001 From: alxkm Date: Sun, 20 Jul 2025 00:04:07 +0200 Subject: [PATCH 2/2] style: redundant whitespace --- .../datastructures/buffers/CircularBufferTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/java/com/thealgorithms/datastructures/buffers/CircularBufferTest.java b/src/test/java/com/thealgorithms/datastructures/buffers/CircularBufferTest.java index 09adb07d9484..69af422e7175 100644 --- a/src/test/java/com/thealgorithms/datastructures/buffers/CircularBufferTest.java +++ b/src/test/java/com/thealgorithms/datastructures/buffers/CircularBufferTest.java @@ -186,7 +186,7 @@ void testFillThenEmptyThenReuseBuffer() { void testPutReturnsTrueOnlyIfPreviouslyEmpty() { CircularBuffer buffer = new CircularBuffer<>(2); - assertTrue(buffer.put("one")); // was empty + assertTrue(buffer.put("one")); // was empty org.junit.jupiter.api.Assertions.assertFalse(buffer.put("two")); // not empty org.junit.jupiter.api.Assertions.assertFalse(buffer.put("three")); // overwrite }