Skip to content

Commit 6774385

Browse files
J-manLansJ-manLans
committed
Made style changes
According to Clang again...
1 parent c24cc40 commit 6774385

2 files changed

Lines changed: 72 additions & 27 deletions

File tree

‎src/test/java/com/thealgorithms/datastructures/trees/AVLSimpleTest.java‎

Lines changed: 4 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -39,8 +39,7 @@ String getExpectedTree() {
3939
10=>20<=30
4040
END=>10<=END
4141
END=>30<=END
42-
2"""
43-
.replace("\n", "");
42+
2""".replace("\n", "");
4443
}
4544

4645
String getActualTree() {
@@ -76,8 +75,7 @@ void testTreeCreation() {
7675
END=>20<=END
7776
27=>30<=END
7877
END=>27<=END
79-
4"""
80-
.replace("\n", "");
78+
4""".replace("\n", "");
8179

8280
assertEquals(expectedTree, getActualTree());
8381
}
@@ -130,15 +128,13 @@ public static Stream<Arguments> getTreeNodesInputForBFEqualsOneRotations() {
130128
5=>10<=END
131129
END=>5<=END
132130
END=>30<=END
133-
3"""
134-
.replace("\n", "")),
131+
3""".replace("\n", "")),
135132
Arguments.of(35, """
136133
10=>20<=30
137134
END=>10<=END
138135
END=>30<=35
139136
END=>35<=END
140-
3"""
141-
.replace("\n", ""))
137+
3""".replace("\n", ""))
142138
);
143139
}
144140

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

Lines changed: 68 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,7 @@
44
import org.junit.jupiter.api.Assertions;
55
import org.junit.jupiter.api.DisplayName;
66
import org.junit.jupiter.api.Test;
7+
import org.junit.jupiter.api.function.Executable;
78
import org.junit.jupiter.params.ParameterizedTest;
89
import org.junit.jupiter.params.provider.Arguments;
910
import org.junit.jupiter.params.provider.MethodSource;
@@ -97,14 +98,22 @@ void openParenthesisAndABSTest() {
9798
Assertions.assertEquals(expected, actual);
9899
Assertions.assertEquals(expected2, actual2);
99100
}
101+
100102
@Test
101103
@DisplayName("Runtime Errors Tests")
102104
void runtimeErrorTest() {
103105
MathBuilder.Builder actual = new MathBuilder.Builder(10.5);
104106

105-
Assertions.assertAll(() -> Assertions.assertThrows(RuntimeException.class, () -> actual.rand(1)), () -> Assertions.assertThrows(RuntimeException.class, () -> actual.randomInRange(1, 10)), () -> Assertions.assertThrows(RuntimeException.class, actual::pi), () -> Assertions.assertThrows(RuntimeException.class, actual::e), () -> Assertions.assertThrows(RuntimeException.class, () -> actual.set(1)));
107+
Executable randCheck = () -> Assertions.assertThrows(RuntimeException.class, () -> actual.rand(1));
108+
Executable rangeCheck = () -> Assertions.assertThrows(RuntimeException.class, () -> actual.randomInRange(1, 10));
109+
Executable piCheck = () -> Assertions.assertThrows(RuntimeException.class, actual::pi);
110+
Executable eCheck = () -> Assertions.assertThrows(RuntimeException.class, actual::e);
111+
Executable setCheck = () -> Assertions.assertThrows(RuntimeException.class, () -> actual.set(1));
112+
113+
Assertions.assertAll(randCheck, rangeCheck, piCheck, eCheck, setCheck);
106114
}
107115

116+
108117
@Test
109118
@DisplayName("Should divide 10 by 2")
110119
void divideByNum() {
@@ -121,24 +130,36 @@ void divideByNum() {
121130
@MethodSource("divideDoubleByZeroHelper")
122131
@DisplayName("Test that ensures dividing a double by zero follows IEEE 754")
123132
void divideDoubleByZero(double expected, MathBuilder.Builder actual, String error) {
124-
Assertions.assertAll(() -> Assertions.assertDoesNotThrow(() -> actual.build().get(), "Dividing a double with zero should not throw"), () -> Assertions.assertDoesNotThrow(() -> actual.divide(0).build().get(), "Dividing infinity with 0 should not throw"), () -> Assertions.assertTrue(Double.isInfinite(actual.build().get()), "Dividing a double by zero should result in infinity"), () -> Assertions.assertEquals(expected, actual.build().get(), error));
133+
Executable noThrowOnBuild = () -> Assertions.assertDoesNotThrow(() -> actual.build().get(), "Dividing a double with zero should not throw");
134+
Executable noThrowOnDivideZero = () -> Assertions.assertDoesNotThrow(() -> actual.divide(0).build().get(), "Dividing infinity with 0 should not throw");
135+
Executable resultIsInfinite = () -> Assertions.assertTrue(Double.isInfinite(actual.build().get()), "Dividing a double by zero should result in infinity");
136+
Executable equalsExpected = () -> Assertions.assertEquals(expected, actual.build().get(), error);
137+
138+
Assertions.assertAll(noThrowOnBuild, noThrowOnDivideZero, resultIsInfinite, equalsExpected);
125139
}
126140

141+
127142
static List<Arguments> divideDoubleByZeroHelper() {
128143
return List.of(Arguments.of(Double.POSITIVE_INFINITY, new MathBuilder.Builder(10.5).openParenthesis(0).closeParenthesisAndDivide(), "10.5 / 0 should be +Infinity"),
129144
Arguments.of(Double.NEGATIVE_INFINITY, new MathBuilder.Builder(-10.5).openParenthesis(0).closeParenthesisAndDivide(), "-10.5 / 0 should be -Infinity"));
130145
}
131146

132147
@Test
133148
void randomFunctionsTest() {
134-
135149
double minValue = 0.0;
136150
double maxValue = 2.1;
151+
137152
double actual = new MathBuilder.Builder().rand(2L).build().get();
138153
double actual2 = new MathBuilder.Builder().randomInRange(minValue, maxValue).build().get();
139-
Assertions.assertAll(() -> Assertions.assertTrue(actual < maxValue), () -> Assertions.assertTrue(actual2 >= minValue), () -> Assertions.assertTrue(actual2 <= maxValue));
154+
155+
Executable isBelowMax = () -> Assertions.assertTrue(actual < maxValue, "Random value should be less than maxValue");
156+
Executable isAboveMin = () -> Assertions.assertTrue(actual2 >= minValue, "RandomInRange value should be >= minValue");
157+
Executable isWithinRange = () -> Assertions.assertTrue(actual2 <= maxValue, "RandomInRange value should be <= maxValue");
158+
159+
Assertions.assertAll(isBelowMax, isAboveMin, isWithinRange);
140160
}
141161

162+
142163
@ParameterizedTest
143164
@MethodSource("radiansHelper")
144165
void toRadiansTests(double expectedAngle, double actualAngle) {
@@ -148,52 +169,80 @@ void toRadiansTests(double expectedAngle, double actualAngle) {
148169
private static List<Arguments> radiansHelper() {
149170
return List.of(Arguments.of(Math.toRadians(10), new MathBuilder.Builder(10).toRadians().build().get()), Arguments.of(2 + Math.toRadians(10), new MathBuilder.Builder(2).openParenthesis(10).toRadians().closeParenthesisAndPlus().build().get()));
150171
}
172+
151173
@Test
152174
void roundCielABSTest() {
153-
154175
double actual = new MathBuilder.Builder(10).openParenthesis(10.5).round().closeParenthesisAndPlus().build().get();
155176
double expected = 10 + Math.round(10.5);
156177

157-
double expected2 = 10 + Math.ceil(10.5);
158178
double actual2 = new MathBuilder.Builder(10).openParenthesis(10.5).ceil().closeParenthesisAndPlus().build().get();
179+
double expected2 = 10 + Math.ceil(10.5);
159180

160-
double expected3 = 10 + Math.abs(10.5);
161181
double actual3 = new MathBuilder.Builder(10).openParenthesis(10.5).abs().closeParenthesisAndPlus().build().get();
182+
double expected3 = 10 + Math.abs(10.5);
162183

163-
double expected4 = Math.abs(10 + 10.5);
164184
double actual4 = new MathBuilder.Builder(10).openParenthesis(10.5).closeParenthesisAndPlus().abs().build().get();
185+
double expected4 = Math.abs(10 + 10.5);
165186

166-
Assertions.assertAll(() -> Assertions.assertNotEquals(0, actual), () -> Assertions.assertNotEquals(1, actual2), () -> Assertions.assertEquals(expected, actual), () -> Assertions.assertEquals(expected2, actual2), () -> Assertions.assertEquals(expected3, actual3), () -> Assertions.assertEquals(expected4, actual4));
187+
Executable roundIsNotZero = () -> Assertions.assertNotEquals(0, actual);
188+
Executable ceilIsNotOne = () -> Assertions.assertNotEquals(1, actual2);
189+
Executable roundIsCorrect = () -> Assertions.assertEquals(expected, actual);
190+
Executable ceilIsCorrect = () -> Assertions.assertEquals(expected2, actual2);
191+
Executable absIsCorrect = () -> Assertions.assertEquals(expected3, actual3);
192+
Executable absAfterPlusIsCorrect = () -> Assertions.assertEquals(expected4, actual4);
193+
194+
Assertions.assertAll(roundIsNotZero, ceilIsNotOne, roundIsCorrect, ceilIsCorrect, absIsCorrect, absAfterPlusIsCorrect);
167195
}
168196

169197
@Test
170198
void toLongTest() {
199+
MathBuilder posOverflow = new MathBuilder.Builder(10.5).openParenthesis(0).closeParenthesisAndDivide().divide(0).build();
200+
MathBuilder negOverflow = new MathBuilder.Builder(10.5).openParenthesis(0).closeParenthesisAndDivide().divide(0).multiply(-1).build();
201+
MathBuilder maxRange = new MathBuilder.Builder(1999999999).multiply(2139999999).multiply(3).build();
202+
MathBuilder minRange = new MathBuilder.Builder(1999999999).multiply(2139999999).multiply(-3).build();
171203

172-
MathBuilder actual = new MathBuilder.Builder(10.5).openParenthesis(0).closeParenthesisAndDivide().divide(0).build();
173-
174-
MathBuilder actual2 = new MathBuilder.Builder(10.5).openParenthesis(0).closeParenthesisAndDivide().divide(0).multiply(-1).build();
204+
Executable posMaxCheck = () -> Assertions.assertEquals(Long.MAX_VALUE, posOverflow.toLong());
205+
Executable negMinCheck = () -> Assertions.assertEquals(Long.MIN_VALUE, negOverflow.toLong());
206+
Executable maxRangeCheck = () -> Assertions.assertEquals(Long.MAX_VALUE, maxRange.toLong());
207+
Executable minRangeCheck = () -> Assertions.assertEquals(Long.MIN_VALUE, minRange.toLong());
208+
Executable notZeroCheck = () -> Assertions.assertNotEquals(0, posOverflow.toLong());
209+
Executable notOneCheck = () -> Assertions.assertNotEquals(1, negOverflow.toLong());
175210

176-
MathBuilder actual3 = new MathBuilder.Builder(1999999999).multiply(2139999999).multiply(3).build();
177-
MathBuilder actual4 = new MathBuilder.Builder(1999999999).multiply(2139999999).multiply(-3).build();
178-
Assertions.assertAll(() -> Assertions.assertEquals(Long.MAX_VALUE, actual.toLong()), () -> Assertions.assertEquals(Long.MIN_VALUE, actual2.toLong()), () -> Assertions.assertEquals(Long.MAX_VALUE, actual3.toLong()), () -> Assertions.assertEquals(Long.MIN_VALUE, actual4.toLong()), () -> Assertions.assertNotEquals(0, actual.toLong()), () -> Assertions.assertNotEquals(1, actual2.toLong()));
211+
Assertions.assertAll(posMaxCheck, negMinCheck, maxRangeCheck, minRangeCheck, notZeroCheck, notOneCheck);
179212
}
180213

181214
@Test
182215
void maxTest() {
183216
MathBuilder actual = new MathBuilder.Builder(10.5).max(20).build();
184217
MathBuilder actual2 = new MathBuilder.Builder(13.5).max(10).build();
185-
186218
MathBuilder actual3 = new MathBuilder.Builder(10.5).openParenthesis(10).max(20).closeParenthesisAndPlus().build();
187219
MathBuilder actual4 = new MathBuilder.Builder(12.5).openParenthesis(10).closeParenthesisAndPlus().max(20).build();
188-
Assertions.assertAll(() -> Assertions.assertEquals(20, actual.get()), () -> Assertions.assertEquals(13.5, actual2.get()), () -> Assertions.assertEquals(30.5, actual3.get()), () -> Assertions.assertEquals(22.5, actual4.get()), () -> Assertions.assertNotEquals(30, actual4.get()), () -> Assertions.assertNotEquals(5, actual4.get()));
220+
221+
Executable maxCheck1 = () -> Assertions.assertEquals(20, actual.get());
222+
Executable maxCheck2 = () -> Assertions.assertEquals(13.5, actual2.get());
223+
Executable maxCheck3 = () -> Assertions.assertEquals(30.5, actual3.get());
224+
Executable maxCheck4 = () -> Assertions.assertEquals(22.5, actual4.get());
225+
Executable notEqualsCheck1 = () -> Assertions.assertNotEquals(30, actual4.get());
226+
Executable notEqualsCheck2 = () -> Assertions.assertNotEquals(5, actual4.get());
227+
228+
Assertions.assertAll(maxCheck1, maxCheck2, maxCheck3, maxCheck4, notEqualsCheck1, notEqualsCheck2);
189229
}
230+
190231
@Test
191232
void minTest() {
192233
MathBuilder actual = new MathBuilder.Builder(10.5).min(20).build();
193234
MathBuilder actual2 = new MathBuilder.Builder(8.5).min(10).build();
194-
195235
MathBuilder actual3 = new MathBuilder.Builder(10.5).openParenthesis(10).min(20).closeParenthesisAndPlus().build();
196236
MathBuilder actual4 = new MathBuilder.Builder(12.5).openParenthesis(10).closeParenthesisAndPlus().min(20).build();
197-
Assertions.assertAll(() -> Assertions.assertEquals(10.5, actual.get()), () -> Assertions.assertEquals(8.5, actual2.get()), () -> Assertions.assertEquals(20.5, actual3.get()), () -> Assertions.assertEquals(20, actual4.get()), () -> Assertions.assertNotEquals(5, actual.get()), () -> Assertions.assertNotEquals(-1000, actual3.get()));
237+
238+
Executable minCheck1 = () -> Assertions.assertEquals(10.5, actual.get());
239+
Executable minCheck2 = () -> Assertions.assertEquals(8.5, actual2.get());
240+
Executable minCheck3 = () -> Assertions.assertEquals(20.5, actual3.get());
241+
Executable minCheck4 = () -> Assertions.assertEquals(20, actual4.get());
242+
Executable notEqualsCheck1 = () -> Assertions.assertNotEquals(5, actual.get());
243+
Executable notEqualsCheck2 = () -> Assertions.assertNotEquals(-1000, actual3.get());
244+
245+
Assertions.assertAll(minCheck1, minCheck2, minCheck3, minCheck4, notEqualsCheck1, notEqualsCheck2);
198246
}
247+
199248
}

0 commit comments

Comments
 (0)