Skip to content

Commit 053d744

Browse files
DenizAltunkapanDenizAltunkapan
authored
Merge branch 'master' into test/CountSinglyLinkedListRecursionTest
2 parents 073833c + 2f2a32b commit 053d744

File tree

5 files changed

+235
-10
lines changed

5 files changed

+235
-10
lines changed

‎src/test/java/com/thealgorithms/bitmanipulation/ParityCheckTest.java

Lines changed: 23 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -6,10 +6,30 @@
66
import org.junit.jupiter.api.Test;
77

88
public class ParityCheckTest {
9+
@Test
10+
public void testIsEvenParity() {
11+
assertTrue(ParityCheck.checkParity(0)); // 0 -> 0 ones
12+
assertTrue(ParityCheck.checkParity(3)); // 11 -> 2 ones
13+
assertTrue(ParityCheck.checkParity(5)); // 101 -> 2 ones
14+
assertTrue(ParityCheck.checkParity(10)); // 1010 -> 2 ones
15+
assertTrue(ParityCheck.checkParity(15)); // 1111 -> 4 ones
16+
assertTrue(ParityCheck.checkParity(1023)); // 10 ones
17+
}
18+
919
@Test
1020
public void testIsOddParity() {
11-
assertTrue(ParityCheck.checkParity(5)); // 101 has 2 ones (even parity)
12-
assertFalse(ParityCheck.checkParity(7)); // 111 has 3 ones (odd parity)
13-
assertFalse(ParityCheck.checkParity(8)); // 1000 has 1 one (odd parity)
21+
assertFalse(ParityCheck.checkParity(1)); // 1 -> 1 one
22+
assertFalse(ParityCheck.checkParity(2)); // 10 -> 1 one
23+
assertFalse(ParityCheck.checkParity(7)); // 111 -> 3 ones
24+
assertFalse(ParityCheck.checkParity(8)); // 1000 -> 1 one
25+
assertFalse(ParityCheck.checkParity(11)); // 1011 -> 3 ones
26+
assertFalse(ParityCheck.checkParity(31)); // 11111 -> 5 ones
27+
}
28+
29+
@Test
30+
public void testLargeNumbers() {
31+
assertTrue(ParityCheck.checkParity(0b10101010)); // 4 ones
32+
assertFalse(ParityCheck.checkParity(0b100000000)); // 1 one
33+
assertTrue(ParityCheck.checkParity(0xAAAAAAAA)); // Alternating bits, 16 ones
1434
}
1535
}

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

Lines changed: 77 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -128,4 +128,81 @@ public void testIsEmptyAfterDeletion() {
128128
list.delete(10);
129129
assertTrue(list.isEmpty());
130130
}
131+
132+
@Test
133+
public void testInsertNegativeNumbers() {
134+
list.insert(-10);
135+
list.insert(-5);
136+
list.insert(-20);
137+
assertEquals("[-20, -10, -5]", list.toString());
138+
}
139+
140+
@Test
141+
public void testInsertMixedPositiveAndNegativeNumbers() {
142+
list.insert(0);
143+
list.insert(-1);
144+
list.insert(1);
145+
assertEquals("[-1, 0, 1]", list.toString());
146+
}
147+
148+
@Test
149+
public void testMultipleDeletesUntilEmpty() {
150+
list.insert(2);
151+
list.insert(4);
152+
list.insert(6);
153+
assertTrue(list.delete(4));
154+
assertTrue(list.delete(2));
155+
assertTrue(list.delete(6));
156+
assertTrue(list.isEmpty());
157+
assertEquals("[]", list.toString());
158+
}
159+
160+
@Test
161+
public void testDeleteDuplicateValuesOnlyDeletesOneInstance() {
162+
list.insert(5);
163+
list.insert(5);
164+
list.insert(5);
165+
assertTrue(list.delete(5));
166+
assertEquals("[5, 5]", list.toString());
167+
assertTrue(list.delete(5));
168+
assertEquals("[5]", list.toString());
169+
assertTrue(list.delete(5));
170+
assertEquals("[]", list.toString());
171+
}
172+
173+
@Test
174+
public void testSearchOnListWithDuplicates() {
175+
list.insert(7);
176+
list.insert(7);
177+
list.insert(7);
178+
assertTrue(list.search(7));
179+
assertFalse(list.search(10));
180+
}
181+
182+
@Test
183+
public void testToStringOnEmptyList() {
184+
assertEquals("[]", list.toString());
185+
}
186+
187+
@Test
188+
public void testDeleteAllDuplicates() {
189+
list.insert(4);
190+
list.insert(4);
191+
list.insert(4);
192+
assertTrue(list.delete(4));
193+
assertTrue(list.delete(4));
194+
assertTrue(list.delete(4));
195+
assertFalse(list.delete(4)); // nothing left to delete
196+
assertEquals("[]", list.toString());
197+
}
198+
199+
@Test
200+
public void testInsertAfterDeletion() {
201+
list.insert(1);
202+
list.insert(3);
203+
list.insert(5);
204+
assertTrue(list.delete(3));
205+
list.insert(2);
206+
assertEquals("[1, 2, 5]", list.toString());
207+
}
131208
}

‎src/test/java/com/thealgorithms/maths/AbsoluteValueTest.java

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -12,4 +12,28 @@ public class AbsoluteValueTest {
1212
void testGetAbsValue() {
1313
Stream.generate(() -> ThreadLocalRandom.current().nextInt()).limit(1000).forEach(number -> assertEquals(Math.abs(number), AbsoluteValue.getAbsValue(number)));
1414
}
15+
16+
@Test
17+
void testZero() {
18+
assertEquals(0, AbsoluteValue.getAbsValue(0));
19+
}
20+
21+
@Test
22+
void testPositiveNumbers() {
23+
assertEquals(5, AbsoluteValue.getAbsValue(5));
24+
assertEquals(123456, AbsoluteValue.getAbsValue(123456));
25+
assertEquals(Integer.MAX_VALUE, AbsoluteValue.getAbsValue(Integer.MAX_VALUE));
26+
}
27+
28+
@Test
29+
void testNegativeNumbers() {
30+
assertEquals(5, AbsoluteValue.getAbsValue(-5));
31+
assertEquals(123456, AbsoluteValue.getAbsValue(-123456));
32+
assertEquals(Integer.MAX_VALUE, AbsoluteValue.getAbsValue(-Integer.MAX_VALUE));
33+
}
34+
35+
@Test
36+
void testMinIntEdgeCase() {
37+
assertEquals(Integer.MIN_VALUE, AbsoluteValue.getAbsValue(Integer.MIN_VALUE));
38+
}
1539
}

‎src/test/java/com/thealgorithms/maths/BinaryPowTest.java

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -13,4 +13,34 @@ void testBinPow() {
1313
assertEquals(729, BinaryPow.binPow(9, 3));
1414
assertEquals(262144, BinaryPow.binPow(8, 6));
1515
}
16+
17+
@Test
18+
void testZeroExponent() {
19+
assertEquals(1, BinaryPow.binPow(2, 0));
20+
assertEquals(1, BinaryPow.binPow(100, 0));
21+
assertEquals(1, BinaryPow.binPow(-5, 0));
22+
}
23+
24+
@Test
25+
void testZeroBase() {
26+
assertEquals(0, BinaryPow.binPow(0, 5));
27+
assertEquals(1, BinaryPow.binPow(0, 0));
28+
}
29+
30+
@Test
31+
void testOneBase() {
32+
assertEquals(1, BinaryPow.binPow(1, 100));
33+
assertEquals(1, BinaryPow.binPow(1, 0));
34+
}
35+
36+
@Test
37+
void testNegativeBase() {
38+
assertEquals(-8, BinaryPow.binPow(-2, 3));
39+
assertEquals(16, BinaryPow.binPow(-2, 4));
40+
}
41+
42+
@Test
43+
void testLargeExponent() {
44+
assertEquals(1073741824, BinaryPow.binPow(2, 30));
45+
}
1646
}

‎src/test/java/com/thealgorithms/stacks/MinStackUsingTwoStacksTest.java

Lines changed: 81 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,38 +1,112 @@
11
package com.thealgorithms.stacks;
22

33
import static org.junit.jupiter.api.Assertions.assertEquals;
4+
import static org.junit.jupiter.api.Assertions.assertThrows;
45

6+
import java.util.EmptyStackException;
57
import org.junit.jupiter.api.Test;
68

79
public class MinStackUsingTwoStacksTest {
810

911
@Test
10-
public void testMinStackOperations() {
12+
public void testBasicOperations() {
1113
MinStackUsingTwoStacks minStack = new MinStackUsingTwoStacks();
1214
minStack.push(3);
1315
minStack.push(5);
14-
assertEquals(3, minStack.getMin());
16+
assertEquals(3, minStack.getMin(), "Min should be 3");
1517

1618
minStack.push(2);
1719
minStack.push(1);
18-
assertEquals(1, minStack.getMin());
20+
assertEquals(1, minStack.getMin(), "Min should be 1");
1921

2022
minStack.pop();
21-
assertEquals(2, minStack.getMin());
23+
assertEquals(2, minStack.getMin(), "Min should be 2 after popping 1");
24+
25+
assertEquals(2, minStack.top(), "Top should be 2");
26+
}
27+
28+
@Test
29+
public void testPushDuplicateMins() {
30+
MinStackUsingTwoStacks minStack = new MinStackUsingTwoStacks();
31+
minStack.push(2);
32+
minStack.push(2);
33+
minStack.push(1);
34+
minStack.push(1);
35+
assertEquals(1, minStack.getMin(), "Min should be 1");
36+
37+
minStack.pop();
38+
assertEquals(1, minStack.getMin(), "Min should still be 1 after popping one 1");
39+
40+
minStack.pop();
41+
assertEquals(2, minStack.getMin(), "Min should be 2 after popping both 1s");
42+
43+
minStack.pop();
44+
assertEquals(2, minStack.getMin(), "Min should still be 2 after popping one 2");
45+
46+
minStack.pop();
47+
// Now stack is empty, expect exception on getMin
48+
assertThrows(EmptyStackException.class, minStack::getMin);
2249
}
2350

2451
@Test
25-
public void testMinStackOperations2() {
52+
public void testPopOnEmptyStack() {
2653
MinStackUsingTwoStacks minStack = new MinStackUsingTwoStacks();
54+
assertThrows(EmptyStackException.class, minStack::pop);
55+
}
56+
57+
@Test
58+
public void testTopOnEmptyStack() {
59+
MinStackUsingTwoStacks minStack = new MinStackUsingTwoStacks();
60+
assertThrows(EmptyStackException.class, minStack::top);
61+
}
62+
63+
@Test
64+
public void testGetMinOnEmptyStack() {
65+
MinStackUsingTwoStacks minStack = new MinStackUsingTwoStacks();
66+
assertThrows(EmptyStackException.class, minStack::getMin);
67+
}
68+
69+
@Test
70+
public void testSingleElementStack() {
71+
MinStackUsingTwoStacks minStack = new MinStackUsingTwoStacks();
72+
minStack.push(10);
73+
assertEquals(10, minStack.getMin());
74+
assertEquals(10, minStack.top());
75+
76+
minStack.pop();
77+
assertThrows(EmptyStackException.class, minStack::getMin);
78+
}
79+
80+
@Test
81+
public void testIncreasingSequence() {
82+
MinStackUsingTwoStacks minStack = new MinStackUsingTwoStacks();
83+
minStack.push(1);
84+
minStack.push(2);
2785
minStack.push(3);
28-
minStack.push(5);
29-
assertEquals(3, minStack.getMin());
86+
minStack.push(4);
87+
88+
assertEquals(1, minStack.getMin());
89+
assertEquals(4, minStack.top());
90+
91+
minStack.pop();
92+
minStack.pop();
93+
assertEquals(1, minStack.getMin());
94+
assertEquals(2, minStack.top());
95+
}
3096

97+
@Test
98+
public void testDecreasingSequence() {
99+
MinStackUsingTwoStacks minStack = new MinStackUsingTwoStacks();
100+
minStack.push(4);
101+
minStack.push(3);
31102
minStack.push(2);
32103
minStack.push(1);
104+
33105
assertEquals(1, minStack.getMin());
106+
assertEquals(1, minStack.top());
34107

35108
minStack.pop();
36109
assertEquals(2, minStack.getMin());
110+
assertEquals(2, minStack.top());
37111
}
38112
}

0 commit comments

Comments
 (0)