Skip to content

Commit ab28f1c

Browse files
alxkmalxkm
authored
Merge branch 'master' into testing/NodeStackTest
2 parents 9ac4d8e + fc07cd8 commit ab28f1c

File tree

8 files changed

+948
-5
lines changed

8 files changed

+948
-5
lines changed

‎pom.xml

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@
2020
<dependency>
2121
<groupId>org.junit</groupId>
2222
<artifactId>junit-bom</artifactId>
23-
<version>5.13.3</version>
23+
<version>5.13.4</version>
2424
<type>pom</type>
2525
<scope>import</scope>
2626
</dependency>

‎src/test/java/com/thealgorithms/datastructures/buffers/CircularBufferTest.java

Lines changed: 148 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,6 @@
22

33
import static org.junit.jupiter.api.Assertions.assertEquals;
44
import static org.junit.jupiter.api.Assertions.assertNull;
5-
import static org.junit.jupiter.api.Assertions.assertThrows;
65
import static org.junit.jupiter.api.Assertions.assertTrue;
76

87
import org.junit.jupiter.api.Test;
@@ -68,11 +67,11 @@ void testFullBuffer() {
6867

6968
@Test
7069
void testIllegalArguments() {
71-
assertThrows(IllegalArgumentException.class, () -> new CircularBuffer<>(0));
72-
assertThrows(IllegalArgumentException.class, () -> new CircularBuffer<>(-1));
70+
org.junit.jupiter.api.Assertions.assertThrows(IllegalArgumentException.class, () -> new CircularBuffer<>(0));
71+
org.junit.jupiter.api.Assertions.assertThrows(IllegalArgumentException.class, () -> new CircularBuffer<>(-1));
7372

7473
CircularBuffer<String> buffer = new CircularBuffer<>(1);
75-
assertThrows(IllegalArgumentException.class, () -> buffer.put(null));
74+
org.junit.jupiter.api.Assertions.assertThrows(IllegalArgumentException.class, () -> buffer.put(null));
7675
}
7776

7877
@Test
@@ -85,4 +84,149 @@ void testLargeBuffer() {
8584
buffer.put(1000); // This should overwrite 0
8685
assertEquals(1, buffer.get());
8786
}
87+
88+
@Test
89+
void testPutAfterGet() {
90+
CircularBuffer<Integer> buffer = new CircularBuffer<>(2);
91+
buffer.put(10);
92+
buffer.put(20);
93+
assertEquals(10, buffer.get());
94+
buffer.put(30);
95+
assertEquals(20, buffer.get());
96+
assertEquals(30, buffer.get());
97+
assertNull(buffer.get());
98+
}
99+
100+
@Test
101+
void testMultipleWrapArounds() {
102+
CircularBuffer<Integer> buffer = new CircularBuffer<>(3);
103+
for (int i = 1; i <= 6; i++) {
104+
buffer.put(i);
105+
buffer.get(); // add and immediately remove
106+
}
107+
assertTrue(buffer.isEmpty());
108+
assertNull(buffer.get());
109+
}
110+
111+
@Test
112+
void testOverwriteMultipleTimes() {
113+
CircularBuffer<String> buffer = new CircularBuffer<>(2);
114+
buffer.put("X");
115+
buffer.put("Y");
116+
buffer.put("Z"); // overwrites "X"
117+
buffer.put("W"); // overwrites "Y"
118+
assertEquals("Z", buffer.get());
119+
assertEquals("W", buffer.get());
120+
assertNull(buffer.get());
121+
}
122+
123+
@Test
124+
void testIsEmptyAndIsFullTransitions() {
125+
CircularBuffer<Integer> buffer = new CircularBuffer<>(2);
126+
assertTrue(buffer.isEmpty());
127+
org.junit.jupiter.api.Assertions.assertFalse(buffer.isFull());
128+
129+
buffer.put(1);
130+
org.junit.jupiter.api.Assertions.assertFalse(buffer.isEmpty());
131+
org.junit.jupiter.api.Assertions.assertFalse(buffer.isFull());
132+
133+
buffer.put(2);
134+
assertTrue(buffer.isFull());
135+
136+
buffer.get();
137+
org.junit.jupiter.api.Assertions.assertFalse(buffer.isFull());
138+
139+
buffer.get();
140+
assertTrue(buffer.isEmpty());
141+
}
142+
143+
@Test
144+
void testInterleavedPutAndGet() {
145+
CircularBuffer<String> buffer = new CircularBuffer<>(3);
146+
buffer.put("A");
147+
buffer.put("B");
148+
assertEquals("A", buffer.get());
149+
buffer.put("C");
150+
assertEquals("B", buffer.get());
151+
assertEquals("C", buffer.get());
152+
assertNull(buffer.get());
153+
}
154+
155+
@Test
156+
void testRepeatedNullInsertionThrows() {
157+
CircularBuffer<Object> buffer = new CircularBuffer<>(5);
158+
for (int i = 0; i < 3; i++) {
159+
int finalI = i;
160+
org.junit.jupiter.api.Assertions.assertThrows(IllegalArgumentException.class, () -> buffer.put(null), "Iteration: " + finalI);
161+
}
162+
}
163+
@Test
164+
void testFillThenEmptyThenReuseBuffer() {
165+
CircularBuffer<Integer> buffer = new CircularBuffer<>(3);
166+
167+
buffer.put(1);
168+
buffer.put(2);
169+
buffer.put(3);
170+
assertTrue(buffer.isFull());
171+
172+
assertEquals(1, buffer.get());
173+
assertEquals(2, buffer.get());
174+
assertEquals(3, buffer.get());
175+
176+
assertTrue(buffer.isEmpty());
177+
178+
buffer.put(4);
179+
buffer.put(5);
180+
assertEquals(4, buffer.get());
181+
assertEquals(5, buffer.get());
182+
assertTrue(buffer.isEmpty());
183+
}
184+
185+
@Test
186+
void testPutReturnsTrueOnlyIfPreviouslyEmpty() {
187+
CircularBuffer<String> buffer = new CircularBuffer<>(2);
188+
189+
assertTrue(buffer.put("one")); // was empty
190+
org.junit.jupiter.api.Assertions.assertFalse(buffer.put("two")); // not empty
191+
org.junit.jupiter.api.Assertions.assertFalse(buffer.put("three")); // overwrite
192+
}
193+
194+
@Test
195+
void testOverwriteAndGetAllElementsCorrectly() {
196+
CircularBuffer<Integer> buffer = new CircularBuffer<>(3);
197+
198+
buffer.put(1);
199+
buffer.put(2);
200+
buffer.put(3);
201+
buffer.put(4); // Overwrites 1
202+
buffer.put(5); // Overwrites 2
203+
204+
assertEquals(3, buffer.get());
205+
assertEquals(4, buffer.get());
206+
assertEquals(5, buffer.get());
207+
assertNull(buffer.get());
208+
}
209+
210+
@Test
211+
void testBufferWithOneElementCapacity() {
212+
CircularBuffer<String> buffer = new CircularBuffer<>(1);
213+
214+
assertTrue(buffer.put("first"));
215+
assertEquals("first", buffer.get());
216+
assertNull(buffer.get());
217+
218+
assertTrue(buffer.put("second"));
219+
assertEquals("second", buffer.get());
220+
}
221+
222+
@Test
223+
void testPointerWraparoundWithExactMultipleOfCapacity() {
224+
CircularBuffer<Integer> buffer = new CircularBuffer<>(3);
225+
for (int i = 0; i < 6; i++) {
226+
buffer.put(i);
227+
buffer.get(); // keep buffer size at 0
228+
}
229+
assertTrue(buffer.isEmpty());
230+
assertNull(buffer.get());
231+
}
88232
}

‎src/test/java/com/thealgorithms/datastructures/lists/CursorLinkedListTest.java

Lines changed: 185 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -109,4 +109,189 @@ void testMemoryLimitExceeded() {
109109
}
110110
});
111111
}
112+
113+
@Test
114+
void testSingleElementOperations() {
115+
// Test operations with just one element
116+
list.append("Only");
117+
assertEquals("Only", list.get(0));
118+
assertEquals(0, list.indexOf("Only"));
119+
120+
list.remove("Only");
121+
assertNull(list.get(0));
122+
assertEquals(-1, list.indexOf("Only"));
123+
}
124+
125+
@Test
126+
void testDuplicateElements() {
127+
// Test handling of duplicate elements
128+
list.append("Duplicate");
129+
list.append("Other");
130+
list.append("Duplicate");
131+
132+
assertEquals(0, list.indexOf("Duplicate")); // Should return first occurrence
133+
assertEquals("Duplicate", list.get(0));
134+
assertEquals("Duplicate", list.get(2));
135+
136+
list.remove("Duplicate"); // Should remove first occurrence
137+
assertEquals("Other", list.get(0));
138+
assertEquals("Duplicate", list.get(1));
139+
}
140+
141+
@Test
142+
void testRemoveByIndexEdgeCases() {
143+
list.append("First");
144+
list.append("Second");
145+
list.append("Third");
146+
147+
// Test removing invalid indices
148+
list.removeByIndex(-1); // Should not crash
149+
list.removeByIndex(10); // Should not crash
150+
151+
// Verify list unchanged
152+
assertEquals("First", list.get(0));
153+
assertEquals("Second", list.get(1));
154+
assertEquals("Third", list.get(2));
155+
156+
// Test removing first element by index
157+
list.removeByIndex(0);
158+
assertEquals("Second", list.get(0));
159+
assertEquals("Third", list.get(1));
160+
}
161+
162+
@Test
163+
void testRemoveByIndexLastElement() {
164+
list.append("First");
165+
list.append("Second");
166+
list.append("Third");
167+
168+
// Remove last element by index
169+
list.removeByIndex(2);
170+
assertEquals("First", list.get(0));
171+
assertEquals("Second", list.get(1));
172+
assertNull(list.get(2));
173+
}
174+
175+
@Test
176+
void testConsecutiveOperations() {
177+
// Test multiple consecutive operations
178+
list.append("A");
179+
list.append("B");
180+
list.append("C");
181+
list.append("D");
182+
183+
list.remove("B");
184+
list.remove("D");
185+
186+
assertEquals("A", list.get(0));
187+
assertEquals("C", list.get(1));
188+
assertNull(list.get(2));
189+
190+
list.append("E");
191+
assertEquals("E", list.get(2));
192+
}
193+
194+
@Test
195+
void testMemoryReclamation() {
196+
// Test that removed elements free up memory space
197+
for (int i = 0; i < 50; i++) {
198+
list.append("Element" + i);
199+
}
200+
201+
// Remove some elements
202+
for (int i = 0; i < 25; i++) {
203+
list.remove("Element" + i);
204+
}
205+
206+
// Should be able to add more elements (testing memory reclamation)
207+
for (int i = 100; i < 150; i++) {
208+
list.append("New" + i);
209+
}
210+
211+
// Verify some elements exist
212+
assertEquals("Element25", list.get(0));
213+
assertEquals("New100", list.get(25));
214+
}
215+
216+
@Test
217+
void testSpecialCharacters() {
218+
// Test with strings containing special characters
219+
list.append("Hello World!");
220+
list.append("Test@123");
221+
list.append("Special#$%");
222+
list.append(""); // Empty string
223+
224+
assertEquals("Hello World!", list.get(0));
225+
assertEquals("Test@123", list.get(1));
226+
assertEquals("Special#$%", list.get(2));
227+
assertEquals("", list.get(3));
228+
229+
assertEquals(3, list.indexOf(""));
230+
}
231+
232+
@Test
233+
void testLargeIndices() {
234+
list.append("Test");
235+
236+
// Test very large indices
237+
assertNull(list.get(Integer.MAX_VALUE));
238+
assertNull(list.get(1000));
239+
}
240+
241+
@Test
242+
void testSequentialRemovalByIndex() {
243+
list.append("A");
244+
list.append("B");
245+
list.append("C");
246+
list.append("D");
247+
248+
// Remove elements sequentially by index
249+
list.removeByIndex(1); // Remove "B"
250+
assertEquals("A", list.get(0));
251+
assertEquals("C", list.get(1));
252+
assertEquals("D", list.get(2));
253+
254+
list.removeByIndex(1); // Remove "C"
255+
assertEquals("A", list.get(0));
256+
assertEquals("D", list.get(1));
257+
assertNull(list.get(2));
258+
}
259+
260+
@Test
261+
void testAppendAfterRemoval() {
262+
list.append("First");
263+
list.append("Second");
264+
265+
list.remove("First");
266+
list.append("Third");
267+
268+
assertEquals("Second", list.get(0));
269+
assertEquals("Third", list.get(1));
270+
assertEquals(1, list.indexOf("Third"));
271+
}
272+
273+
@Test
274+
void testPerformanceWithManyOperations() {
275+
// Test with many mixed operations
276+
for (int i = 0; i < 50; i++) {
277+
list.append("Item" + i);
278+
}
279+
280+
// Remove every other element
281+
for (int i = 0; i < 50; i += 2) {
282+
list.remove("Item" + i);
283+
}
284+
285+
// Verify remaining elements
286+
assertEquals("Item1", list.get(0));
287+
assertEquals("Item3", list.get(1));
288+
assertEquals("Item5", list.get(2));
289+
290+
// Add more elements
291+
for (int i = 100; i < 110; i++) {
292+
list.append("New" + i);
293+
}
294+
295+
assertEquals("New100", list.get(25));
296+
}
112297
}

0 commit comments

Comments
 (0)