Skip to content

Commit 3c223a7

Browse files
alxkmalxkm
authored
Merge branch 'master' into testing/BagTest
2 parents ca2a3fe + 7e3fbae commit 3c223a7

File tree

3 files changed

+332
-5
lines changed

3 files changed

+332
-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/stacks/SortStackTest.java

Lines changed: 183 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -74,4 +74,187 @@ public void testSortWithDuplicateElements() {
7474
assertEquals(2, (int) stack.pop());
7575
assertEquals(1, (int) stack.pop());
7676
}
77+
78+
@Test
79+
public void testSortReverseSortedStack() {
80+
// Test worst case scenario - completely reverse sorted
81+
stack.push(5);
82+
stack.push(4);
83+
stack.push(3);
84+
stack.push(2);
85+
stack.push(1);
86+
SortStack.sortStack(stack);
87+
88+
assertEquals(5, stack.size());
89+
assertEquals(5, (int) stack.pop());
90+
assertEquals(4, (int) stack.pop());
91+
assertEquals(3, (int) stack.pop());
92+
assertEquals(2, (int) stack.pop());
93+
assertEquals(1, (int) stack.pop());
94+
}
95+
96+
@Test
97+
public void testSortWithAllSameElements() {
98+
// Test stack with all identical elements
99+
stack.push(7);
100+
stack.push(7);
101+
stack.push(7);
102+
stack.push(7);
103+
SortStack.sortStack(stack);
104+
105+
assertEquals(4, stack.size());
106+
assertEquals(7, (int) stack.pop());
107+
assertEquals(7, (int) stack.pop());
108+
assertEquals(7, (int) stack.pop());
109+
assertEquals(7, (int) stack.pop());
110+
}
111+
112+
@Test
113+
public void testSortWithNegativeNumbers() {
114+
// Test with negative numbers
115+
stack.push(-3);
116+
stack.push(1);
117+
stack.push(-5);
118+
stack.push(2);
119+
stack.push(-1);
120+
SortStack.sortStack(stack);
121+
122+
assertEquals(5, stack.size());
123+
assertEquals(2, (int) stack.pop());
124+
assertEquals(1, (int) stack.pop());
125+
assertEquals(-1, (int) stack.pop());
126+
assertEquals(-3, (int) stack.pop());
127+
assertEquals(-5, (int) stack.pop());
128+
}
129+
130+
@Test
131+
public void testSortWithAllNegativeNumbers() {
132+
// Test with only negative numbers
133+
stack.push(-10);
134+
stack.push(-5);
135+
stack.push(-15);
136+
stack.push(-1);
137+
SortStack.sortStack(stack);
138+
139+
assertEquals(4, stack.size());
140+
assertEquals(-1, (int) stack.pop());
141+
assertEquals(-5, (int) stack.pop());
142+
assertEquals(-10, (int) stack.pop());
143+
assertEquals(-15, (int) stack.pop());
144+
}
145+
146+
@Test
147+
public void testSortWithZero() {
148+
// Test with zero included
149+
stack.push(3);
150+
stack.push(0);
151+
stack.push(-2);
152+
stack.push(1);
153+
SortStack.sortStack(stack);
154+
155+
assertEquals(4, stack.size());
156+
assertEquals(3, (int) stack.pop());
157+
assertEquals(1, (int) stack.pop());
158+
assertEquals(0, (int) stack.pop());
159+
assertEquals(-2, (int) stack.pop());
160+
}
161+
162+
@Test
163+
public void testSortLargerStack() {
164+
// Test with a larger number of elements
165+
int[] values = {15, 3, 9, 1, 12, 6, 18, 4, 11, 8};
166+
for (int value : values) {
167+
stack.push(value);
168+
}
169+
170+
SortStack.sortStack(stack);
171+
172+
assertEquals(10, stack.size());
173+
174+
// Verify sorted order (largest to smallest when popping)
175+
int[] expectedOrder = {18, 15, 12, 11, 9, 8, 6, 4, 3, 1};
176+
for (int expected : expectedOrder) {
177+
assertEquals(expected, (int) stack.pop());
178+
}
179+
}
180+
181+
@Test
182+
public void testSortTwoElements() {
183+
// Test edge case with exactly two elements
184+
stack.push(5);
185+
stack.push(2);
186+
SortStack.sortStack(stack);
187+
188+
assertEquals(2, stack.size());
189+
assertEquals(5, (int) stack.pop());
190+
assertEquals(2, (int) stack.pop());
191+
}
192+
193+
@Test
194+
public void testSortTwoElementsAlreadySorted() {
195+
// Test two elements already in correct order
196+
stack.push(2);
197+
stack.push(5);
198+
SortStack.sortStack(stack);
199+
200+
assertEquals(2, stack.size());
201+
assertEquals(5, (int) stack.pop());
202+
assertEquals(2, (int) stack.pop());
203+
}
204+
205+
@Test
206+
public void testSortStackWithMinAndMaxValues() {
207+
// Test with Integer.MAX_VALUE and Integer.MIN_VALUE
208+
stack.push(0);
209+
stack.push(Integer.MAX_VALUE);
210+
stack.push(Integer.MIN_VALUE);
211+
stack.push(100);
212+
SortStack.sortStack(stack);
213+
214+
assertEquals(4, stack.size());
215+
assertEquals(Integer.MAX_VALUE, (int) stack.pop());
216+
assertEquals(100, (int) stack.pop());
217+
assertEquals(0, (int) stack.pop());
218+
assertEquals(Integer.MIN_VALUE, (int) stack.pop());
219+
}
220+
221+
@Test
222+
public void testSortWithManyDuplicates() {
223+
// Test with multiple sets of duplicates
224+
stack.push(3);
225+
stack.push(1);
226+
stack.push(3);
227+
stack.push(1);
228+
stack.push(2);
229+
stack.push(2);
230+
stack.push(3);
231+
SortStack.sortStack(stack);
232+
233+
assertEquals(7, stack.size());
234+
assertEquals(3, (int) stack.pop());
235+
assertEquals(3, (int) stack.pop());
236+
assertEquals(3, (int) stack.pop());
237+
assertEquals(2, (int) stack.pop());
238+
assertEquals(2, (int) stack.pop());
239+
assertEquals(1, (int) stack.pop());
240+
assertEquals(1, (int) stack.pop());
241+
}
242+
243+
@Test
244+
public void testOriginalStackIsModified() {
245+
// Verify that the original stack is modified, not a copy
246+
Stack<Integer> originalReference = stack;
247+
stack.push(3);
248+
stack.push(1);
249+
stack.push(2);
250+
251+
SortStack.sortStack(stack);
252+
253+
// Verify it's the same object reference
254+
assertTrue(stack == originalReference);
255+
assertEquals(3, stack.size());
256+
assertEquals(3, (int) stack.pop());
257+
assertEquals(2, (int) stack.pop());
258+
assertEquals(1, (int) stack.pop());
259+
}
77260
}

0 commit comments

Comments
 (0)