repo stringclasses 1k values | file_url stringlengths 96 373 | file_path stringlengths 11 294 | content stringlengths 0 32.8k | language stringclasses 1 value | license stringclasses 6 values | commit_sha stringclasses 1k values | retrieved_at stringdate 2026-01-04 14:45:56 2026-01-04 18:30:23 | truncated bool 2 classes |
|---|---|---|---|---|---|---|---|---|
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/dynamicprogramming/UniquePathsTests.java | src/test/java/com/thealgorithms/dynamicprogramming/UniquePathsTests.java | package com.thealgorithms.dynamicprogramming;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.Test;
public class UniquePathsTests {
@Test
public void testUniquePaths3x3() {
assertEquals(6, UniquePaths.uniquePaths(3, 3));
}
@Test
public void testUniquePaths1x1() {
assertEquals(1, UniquePaths.uniquePaths(1, 1));
}
@Test
public void testUniquePaths3x7() {
assertEquals(28, UniquePaths.uniquePaths(3, 7));
}
@Test
public void testUniquePaths7x3() {
assertEquals(28, UniquePaths.uniquePaths(7, 3));
}
@Test
public void testUniquePaths100x100() {
assertThrows(ArithmeticException.class, () -> UniquePaths.uniquePaths(100, 100));
}
@Test
public void testUniquePathsII3x3() {
assertEquals(6, UniquePaths.uniquePaths2(3, 3));
}
@Test
public void testUniquePathsII1x1() {
assertEquals(1, UniquePaths.uniquePaths2(1, 1));
}
@Test
public void testUniquePathsII3x7() {
assertEquals(28, UniquePaths.uniquePaths2(3, 7));
}
@Test
public void testUniquePathsII7x3() {
assertEquals(28, UniquePaths.uniquePaths2(7, 3));
}
@Test
public void testUniquePathsII100x100() {
assertThrows(ArithmeticException.class, () -> UniquePaths.uniquePaths2(100, 100));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/dynamicprogramming/KnapsackZeroOneTabulationTest.java | src/test/java/com/thealgorithms/dynamicprogramming/KnapsackZeroOneTabulationTest.java | package com.thealgorithms.dynamicprogramming;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.Test;
public class KnapsackZeroOneTabulationTest {
@Test
public void basicCheck() {
int[] values = {60, 100, 120};
int[] weights = {10, 20, 30};
int capacity = 50;
int itemCount = values.length;
int expected = 220; // Best choice: item 1 (100) and item 2 (120)
int result = KnapsackZeroOneTabulation.compute(values, weights, capacity, itemCount);
assertEquals(expected, result);
}
@Test
public void emptyKnapsack() {
int[] values = {};
int[] weights = {};
int capacity = 50;
int itemCount = 0;
assertEquals(0, KnapsackZeroOneTabulation.compute(values, weights, capacity, itemCount));
}
@Test
public void zeroCapacity() {
int[] values = {60, 100, 120};
int[] weights = {10, 20, 30};
int capacity = 0;
int itemCount = values.length;
assertEquals(0, KnapsackZeroOneTabulation.compute(values, weights, capacity, itemCount));
}
@Test
public void negativeCapacity() {
int[] values = {10, 20, 30};
int[] weights = {1, 1, 1};
int capacity = -10;
int itemCount = values.length;
IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> KnapsackZeroOneTabulation.compute(values, weights, capacity, itemCount));
assertEquals("Capacity must not be negative.", exception.getMessage());
}
@Test
public void mismatchedLengths() {
int[] values = {60, 100}; // Only 2 values
int[] weights = {10, 20, 30}; // 3 weights
int capacity = 50;
int itemCount = 2; // Matches `values.length`
// You could either expect 0 or throw an IllegalArgumentException in your compute function
assertThrows(IllegalArgumentException.class, () -> { KnapsackZeroOneTabulation.compute(values, weights, capacity, itemCount); });
}
@Test
public void nullInputs() {
int[] weights = {1, 2, 3};
int capacity = 10;
int itemCount = 3;
IllegalArgumentException exception1 = assertThrows(IllegalArgumentException.class, () -> KnapsackZeroOneTabulation.compute(null, weights, capacity, itemCount));
assertEquals("Values and weights arrays must not be null.", exception1.getMessage());
int[] values = {1, 2, 3};
IllegalArgumentException exception2 = assertThrows(IllegalArgumentException.class, () -> KnapsackZeroOneTabulation.compute(values, null, capacity, itemCount));
assertEquals("Values and weights arrays must not be null.", exception2.getMessage());
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/dynamicprogramming/MinimumPathSumTest.java | src/test/java/com/thealgorithms/dynamicprogramming/MinimumPathSumTest.java | package com.thealgorithms.dynamicprogramming;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
public class MinimumPathSumTest {
@Test
public void testMinimumPathSumWithRegularGrid() {
int[][] grid = {{1, 3, 1}, {1, 5, 1}, {4, 2, 1}};
assertEquals(7, MinimumPathSum.minimumPathSum(grid));
}
@Test
public void testMinimumPathSumWithOneRowOneColumnGrid() {
int[][] grid = {{2}};
assertEquals(2, MinimumPathSum.minimumPathSum(grid));
}
@Test
public void testMinimumPathSumWithEmptyGrid() {
int[][] grid = {{}};
assertEquals(0, MinimumPathSum.minimumPathSum(grid));
}
@Test
public void testMinimumPathSumWithOneColumnGrid() {
int[][] grid = {{1}, {2}, {3}};
assertEquals(6, MinimumPathSum.minimumPathSum(grid));
}
@Test
public void testMinimumPathSumGridOneRowGrid() {
int[][] grid = {{1, 2, 3}};
assertEquals(6, MinimumPathSum.minimumPathSum(grid));
}
@Test
public void testMinimumPathSumWithDiffRowAndColumnGrid() {
int[][] grid = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
assertEquals(30, MinimumPathSum.minimumPathSum(grid));
}
@Test
public void testMinimumPathSumWithNegativeNumberGrid() {
int[][] grid = {{1, 3, 1}, {3, 4, 1}, {4, -3, 1}};
assertEquals(6, MinimumPathSum.minimumPathSum(grid));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/dynamicprogramming/LongestPalindromicSubstringTest.java | src/test/java/com/thealgorithms/dynamicprogramming/LongestPalindromicSubstringTest.java | package com.thealgorithms.dynamicprogramming;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.stream.Stream;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
public class LongestPalindromicSubstringTest {
private static Stream<Arguments> provideTestCases() {
return Stream.of(
Arguments.of("babad", "aba"), Arguments.of("cbbd", "bb"), Arguments.of("a", "a"), Arguments.of("x", "x"), Arguments.of("", ""), Arguments.of("aaaa", "aaaa"), Arguments.of("mm", "mm"), Arguments.of("level", "level"), Arguments.of("bananas", "anana"), Arguments.of("abacabad", "abacaba"));
}
@ParameterizedTest
@MethodSource("provideTestCases")
public void testLps(String input, String expected) {
assertEquals(expected, LongestPalindromicSubstring.lps(input));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/dynamicprogramming/DamerauLevenshteinDistanceTest.java | src/test/java/com/thealgorithms/dynamicprogramming/DamerauLevenshteinDistanceTest.java | package com.thealgorithms.dynamicprogramming;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
/**
* Unit tests for the {@code DamerauLevenshteinDistance} class.
* Tests cover edge cases, basic operations, and complex transposition scenarios.
*/
class DamerauLevenshteinDistanceTest {
@Test
@DisplayName("Should throw exception for null first string")
void testNullFirstString() {
assertThrows(IllegalArgumentException.class, () -> { DamerauLevenshteinDistance.distance(null, "test"); });
}
@Test
@DisplayName("Should throw exception for null second string")
void testNullSecondString() {
assertThrows(IllegalArgumentException.class, () -> { DamerauLevenshteinDistance.distance("test", null); });
}
@Test
@DisplayName("Should throw exception for both null strings")
void testBothNullStrings() {
assertThrows(IllegalArgumentException.class, () -> { DamerauLevenshteinDistance.distance(null, null); });
}
@Test
@DisplayName("Should return 0 for identical strings")
void testIdenticalStrings() {
assertEquals(0, DamerauLevenshteinDistance.distance("", ""));
assertEquals(0, DamerauLevenshteinDistance.distance("a", "a"));
assertEquals(0, DamerauLevenshteinDistance.distance("abc", "abc"));
assertEquals(0, DamerauLevenshteinDistance.distance("hello", "hello"));
}
@Test
@DisplayName("Should return length when one string is empty")
void testEmptyStrings() {
assertEquals(3, DamerauLevenshteinDistance.distance("", "abc"));
assertEquals(5, DamerauLevenshteinDistance.distance("hello", ""));
assertEquals(0, DamerauLevenshteinDistance.distance("", ""));
}
@Test
@DisplayName("Should handle single character insertions")
void testSingleInsertion() {
assertEquals(1, DamerauLevenshteinDistance.distance("cat", "cats"));
assertEquals(1, DamerauLevenshteinDistance.distance("ab", "abc"));
assertEquals(1, DamerauLevenshteinDistance.distance("", "a"));
}
@Test
@DisplayName("Should handle single character deletions")
void testSingleDeletion() {
assertEquals(1, DamerauLevenshteinDistance.distance("cats", "cat"));
assertEquals(1, DamerauLevenshteinDistance.distance("abc", "ab"));
assertEquals(1, DamerauLevenshteinDistance.distance("a", ""));
}
@Test
@DisplayName("Should handle single character substitutions")
void testSingleSubstitution() {
assertEquals(1, DamerauLevenshteinDistance.distance("cat", "bat"));
assertEquals(1, DamerauLevenshteinDistance.distance("abc", "adc"));
assertEquals(1, DamerauLevenshteinDistance.distance("x", "y"));
}
@Test
@DisplayName("Should handle adjacent character transpositions")
void testAdjacentTransposition() {
assertEquals(1, DamerauLevenshteinDistance.distance("ab", "ba"));
assertEquals(1, DamerauLevenshteinDistance.distance("abc", "bac"));
assertEquals(1, DamerauLevenshteinDistance.distance("hello", "ehllo"));
}
@Test
@DisplayName("Should correctly compute distance for CA to ABC")
void testCAtoABC() {
// This is the critical test case that differentiates full DL from OSA
// Full DL: 2 (insert A at start, insert B in middle)
// OSA would give: 3
assertEquals(2, DamerauLevenshteinDistance.distance("CA", "ABC"));
}
@Test
@DisplayName("Should handle non-adjacent transpositions")
void testNonAdjacentTransposition() {
assertEquals(2, DamerauLevenshteinDistance.distance("abc", "cba"));
assertEquals(3, DamerauLevenshteinDistance.distance("abcd", "dcba"));
}
@Test
@DisplayName("Should handle multiple operations")
void testMultipleOperations() {
assertEquals(3, DamerauLevenshteinDistance.distance("kitten", "sitting"));
assertEquals(3, DamerauLevenshteinDistance.distance("saturday", "sunday"));
assertEquals(5, DamerauLevenshteinDistance.distance("intention", "execution"));
}
@Test
@DisplayName("Should handle completely different strings")
void testCompletelyDifferentStrings() {
assertEquals(3, DamerauLevenshteinDistance.distance("abc", "xyz"));
assertEquals(4, DamerauLevenshteinDistance.distance("hello", "world"));
}
@Test
@DisplayName("Should handle strings with repeated characters")
void testRepeatedCharacters() {
assertEquals(0, DamerauLevenshteinDistance.distance("aaa", "aaa"));
assertEquals(1, DamerauLevenshteinDistance.distance("aaa", "aab"));
assertEquals(1, DamerauLevenshteinDistance.distance("aaa", "aba"));
}
@Test
@DisplayName("Should be symmetric")
void testSymmetry() {
assertEquals(DamerauLevenshteinDistance.distance("abc", "def"), DamerauLevenshteinDistance.distance("def", "abc"));
assertEquals(DamerauLevenshteinDistance.distance("hello", "world"), DamerauLevenshteinDistance.distance("world", "hello"));
}
@Test
@DisplayName("Should handle case sensitivity")
void testCaseSensitivity() {
assertEquals(1, DamerauLevenshteinDistance.distance("Hello", "hello"));
assertEquals(5, DamerauLevenshteinDistance.distance("HELLO", "hello"));
}
@Test
@DisplayName("Should handle single character strings")
void testSingleCharacterStrings() {
assertEquals(1, DamerauLevenshteinDistance.distance("a", "b"));
assertEquals(0, DamerauLevenshteinDistance.distance("a", "a"));
assertEquals(2, DamerauLevenshteinDistance.distance("a", "abc"));
}
@Test
@DisplayName("Should handle long strings efficiently")
void testLongStrings() {
String s1 = "abcdefghijklmnopqrstuvwxyz";
String s2 = "abcdefghijklmnopqrstuvwxyz";
assertEquals(0, DamerauLevenshteinDistance.distance(s1, s2));
String s3 = "abcdefghijklmnopqrstuvwxyz";
String s4 = "zyxwvutsrqponmlkjihgfedcba";
assertEquals(25, DamerauLevenshteinDistance.distance(s3, s4));
}
@Test
@DisplayName("Should satisfy triangle inequality")
void testTriangleInequality() {
// d(a,c) <= d(a,b) + d(b,c)
String a = "cat";
String b = "hat";
String c = "rat";
int ab = DamerauLevenshteinDistance.distance(a, b);
int bc = DamerauLevenshteinDistance.distance(b, c);
int ac = DamerauLevenshteinDistance.distance(a, c);
assertTrue(ac <= ab + bc);
}
@Test
@DisplayName("Should handle special characters")
void testSpecialCharacters() {
assertEquals(0, DamerauLevenshteinDistance.distance("hello!", "hello!"));
assertEquals(1, DamerauLevenshteinDistance.distance("hello!", "hello?"));
assertEquals(1, DamerauLevenshteinDistance.distance("a@b", "a#b"));
}
@Test
@DisplayName("Should handle numeric strings")
void testNumericStrings() {
assertEquals(1, DamerauLevenshteinDistance.distance("123", "124"));
assertEquals(1, DamerauLevenshteinDistance.distance("123", "213"));
assertEquals(0, DamerauLevenshteinDistance.distance("999", "999"));
}
@Test
@DisplayName("Should handle unicode characters")
void testUnicodeCharacters() {
assertEquals(0, DamerauLevenshteinDistance.distance("café", "café"));
assertEquals(1, DamerauLevenshteinDistance.distance("café", "cafe"));
assertEquals(0, DamerauLevenshteinDistance.distance("你好", "你好"));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/LinearDiophantineEquationsSolverTest.java | src/test/java/com/thealgorithms/maths/LinearDiophantineEquationsSolverTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;
/**
* Test class for LinearDiophantineEquationsSolver.
* Tests various cases including:
* - Equations with solutions
* - Equations with no solutions
* - Special cases (zero coefficients, infinite solutions)
* - Edge cases (negative coefficients, large numbers)
*/
class LinearDiophantineEquationsSolverTest {
/**
* Tests the example equation 3x + 4y = 7.
* Expected solution: x = -9, y = 8 (or other valid solutions).
*/
@Test
void testBasicEquation() {
final var equation = new LinearDiophantineEquationsSolver.Equation(3, 4, 7);
final var solution = LinearDiophantineEquationsSolver.findAnySolution(equation);
assertNotNull(solution);
// Verify that the solution satisfies the equation
int result = equation.a() * solution.getX() + equation.b() * solution.getY();
assertEquals(equation.c(), result);
}
/**
* Tests an equation with no solution: 2x + 4y = 5.
* Since gcd(2, 4) = 2 and 2 does not divide 5, no solution exists.
*/
@Test
void testNoSolution() {
final var equation = new LinearDiophantineEquationsSolver.Equation(2, 4, 5);
final var solution = LinearDiophantineEquationsSolver.findAnySolution(equation);
assertEquals(LinearDiophantineEquationsSolver.Solution.NO_SOLUTION, solution);
}
/**
* Tests the trivial equation 0x + 0y = 0.
* This has infinite solutions.
*/
@Test
void testInfiniteSolutions() {
final var equation = new LinearDiophantineEquationsSolver.Equation(0, 0, 0);
final var solution = LinearDiophantineEquationsSolver.findAnySolution(equation);
assertEquals(LinearDiophantineEquationsSolver.Solution.INFINITE_SOLUTIONS, solution);
}
/**
* Tests an equation where a = 0: 0x + 5y = 10.
* Expected solution: x = 0, y = 2.
*/
@Test
void testZeroCoefficient() {
final var equation = new LinearDiophantineEquationsSolver.Equation(0, 5, 10);
final var solution = LinearDiophantineEquationsSolver.findAnySolution(equation);
assertNotNull(solution);
int result = equation.a() * solution.getX() + equation.b() * solution.getY();
assertEquals(equation.c(), result);
}
/**
* Tests an equation where b = 0: 3x + 0y = 9.
* Expected solution: x = 3, y can be anything (solver will return y = 0).
*/
@Test
void testZeroCoefficientB() {
final var equation = new LinearDiophantineEquationsSolver.Equation(3, 0, 9);
final var solution = LinearDiophantineEquationsSolver.findAnySolution(equation);
assertNotNull(solution);
int result = equation.a() * solution.getX() + equation.b() * solution.getY();
assertEquals(equation.c(), result);
}
/**
* Tests an equation with negative coefficients: -3x + 4y = 7.
*/
@Test
void testNegativeCoefficients() {
final var equation = new LinearDiophantineEquationsSolver.Equation(-3, 4, 7);
final var solution = LinearDiophantineEquationsSolver.findAnySolution(equation);
assertNotNull(solution);
int result = equation.a() * solution.getX() + equation.b() * solution.getY();
assertEquals(equation.c(), result);
}
/**
* Tests an equation with negative result: 3x + 4y = -7.
*/
@Test
void testNegativeResult() {
final var equation = new LinearDiophantineEquationsSolver.Equation(3, 4, -7);
final var solution = LinearDiophantineEquationsSolver.findAnySolution(equation);
assertNotNull(solution);
int result = equation.a() * solution.getX() + equation.b() * solution.getY();
assertEquals(equation.c(), result);
}
/**
* Tests an equation with coprime coefficients: 7x + 11y = 1.
* Since gcd(7, 11) = 1, a solution exists.
*/
@Test
void testCoprimeCoefficients() {
final var equation = new LinearDiophantineEquationsSolver.Equation(7, 11, 1);
final var solution = LinearDiophantineEquationsSolver.findAnySolution(equation);
assertNotNull(solution);
int result = equation.a() * solution.getX() + equation.b() * solution.getY();
assertEquals(equation.c(), result);
}
/**
* Tests an equation with larger coefficients: 12x + 18y = 30.
* Since gcd(12, 18) = 6 and 6 divides 30, a solution exists.
*/
@Test
void testLargerCoefficients() {
final var equation = new LinearDiophantineEquationsSolver.Equation(12, 18, 30);
final var solution = LinearDiophantineEquationsSolver.findAnySolution(equation);
assertNotNull(solution);
int result = equation.a() * solution.getX() + equation.b() * solution.getY();
assertEquals(equation.c(), result);
}
/**
* Tests an equation that has no solution due to GCD: 6x + 9y = 5.
* Since gcd(6, 9) = 3 and 3 does not divide 5, no solution exists.
*/
@Test
void testNoSolutionGcdCheck() {
final var equation = new LinearDiophantineEquationsSolver.Equation(6, 9, 5);
final var solution = LinearDiophantineEquationsSolver.findAnySolution(equation);
assertEquals(LinearDiophantineEquationsSolver.Solution.NO_SOLUTION, solution);
}
/**
* Tests the equation x + y = 1.
* Simple case where gcd(1, 1) = 1.
*/
@Test
void testSimpleCase() {
final var equation = new LinearDiophantineEquationsSolver.Equation(1, 1, 1);
final var solution = LinearDiophantineEquationsSolver.findAnySolution(equation);
assertNotNull(solution);
int result = equation.a() * solution.getX() + equation.b() * solution.getY();
assertEquals(equation.c(), result);
}
/**
* Tests Solution equality.
*/
@Test
void testSolutionEquality() {
final var solution1 = new LinearDiophantineEquationsSolver.Solution(3, 5);
final var solution2 = new LinearDiophantineEquationsSolver.Solution(3, 5);
final var solution3 = new LinearDiophantineEquationsSolver.Solution(3, 6);
assertEquals(solution1, solution2);
assertNotEquals(solution3, solution1);
assertEquals(solution1, solution1);
assertNotEquals(null, solution1);
assertNotEquals("string", solution1);
}
/**
* Tests Solution hashCode.
*/
@Test
void testSolutionHashCode() {
final var solution1 = new LinearDiophantineEquationsSolver.Solution(3, 5);
final var solution2 = new LinearDiophantineEquationsSolver.Solution(3, 5);
assertEquals(solution1.hashCode(), solution2.hashCode());
}
/**
* Tests Solution toString.
*/
@Test
void testSolutionToString() {
final var solution = new LinearDiophantineEquationsSolver.Solution(3, 5);
final var str = solution.toString();
assertTrue(str.contains("3"));
assertTrue(str.contains("5"));
assertTrue(str.contains("Solution"));
}
/**
* Tests GcdSolutionWrapper equality.
*/
@Test
void testGcdSolutionWrapperEquality() {
final var solution = new LinearDiophantineEquationsSolver.Solution(1, 2);
final var wrapper1 = new LinearDiophantineEquationsSolver.GcdSolutionWrapper(5, solution);
final var wrapper2 = new LinearDiophantineEquationsSolver.GcdSolutionWrapper(5, solution);
final var wrapper3 = new LinearDiophantineEquationsSolver.GcdSolutionWrapper(6, solution);
assertEquals(wrapper1, wrapper2);
assertNotEquals(wrapper3, wrapper1);
assertEquals(wrapper1, wrapper1);
assertNotEquals(null, wrapper1);
assertNotEquals("string", wrapper1);
}
/**
* Tests GcdSolutionWrapper hashCode.
*/
@Test
void testGcdSolutionWrapperHashCode() {
final var solution = new LinearDiophantineEquationsSolver.Solution(1, 2);
final var wrapper1 = new LinearDiophantineEquationsSolver.GcdSolutionWrapper(5, solution);
final var wrapper2 = new LinearDiophantineEquationsSolver.GcdSolutionWrapper(5, solution);
assertEquals(wrapper1.hashCode(), wrapper2.hashCode());
}
/**
* Tests GcdSolutionWrapper toString.
*/
@Test
void testGcdSolutionWrapperToString() {
final var solution = new LinearDiophantineEquationsSolver.Solution(1, 2);
final var wrapper = new LinearDiophantineEquationsSolver.GcdSolutionWrapper(5, solution);
final var str = wrapper.toString();
assertTrue(str.contains("5"));
assertTrue(str.contains("GcdSolutionWrapper"));
}
/**
* Tests Equation record functionality.
*/
@Test
void testEquationRecord() {
final var equation = new LinearDiophantineEquationsSolver.Equation(3, 4, 7);
assertEquals(3, equation.a());
assertEquals(4, equation.b());
assertEquals(7, equation.c());
}
/**
* Tests an equation with c = 0: 3x + 4y = 0.
* Expected solution: x = 0, y = 0.
*/
@Test
void testZeroResult() {
final var equation = new LinearDiophantineEquationsSolver.Equation(3, 4, 0);
final var solution = LinearDiophantineEquationsSolver.findAnySolution(equation);
assertNotNull(solution);
int result = equation.a() * solution.getX() + equation.b() * solution.getY();
assertEquals(equation.c(), result);
}
/**
* Tests Solution setters.
*/
@Test
void testSolutionSetters() {
final var solution = new LinearDiophantineEquationsSolver.Solution(1, 2);
solution.setX(10);
solution.setY(20);
assertEquals(10, solution.getX());
assertEquals(20, solution.getY());
}
/**
* Tests GcdSolutionWrapper setters.
*/
@Test
void testGcdSolutionWrapperSetters() {
final var solution = new LinearDiophantineEquationsSolver.Solution(1, 2);
final var wrapper = new LinearDiophantineEquationsSolver.GcdSolutionWrapper(5, solution);
final var newSolution = new LinearDiophantineEquationsSolver.Solution(3, 4);
wrapper.setGcd(10);
wrapper.setSolution(newSolution);
assertEquals(10, wrapper.getGcd());
assertEquals(newSolution, wrapper.getSolution());
}
/**
* Tests an equation with both coefficients negative: -3x - 4y = -7.
*/
@Test
void testBothCoefficientsNegative() {
final var equation = new LinearDiophantineEquationsSolver.Equation(-3, -4, -7);
final var solution = LinearDiophantineEquationsSolver.findAnySolution(equation);
assertNotNull(solution);
int result = equation.a() * solution.getX() + equation.b() * solution.getY();
assertEquals(equation.c(), result);
}
/**
* Tests an equation with large prime coefficients: 97x + 101y = 198.
*/
@Test
void testLargePrimeCoefficients() {
final var equation = new LinearDiophantineEquationsSolver.Equation(97, 101, 198);
final var solution = LinearDiophantineEquationsSolver.findAnySolution(equation);
assertNotNull(solution);
int result = equation.a() * solution.getX() + equation.b() * solution.getY();
assertEquals(equation.c(), result);
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/EulerPseudoprimeTest.java | src/test/java/com/thealgorithms/maths/EulerPseudoprimeTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import java.math.BigInteger;
import org.junit.jupiter.api.Test;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
class EulerPseudoprimeTest {
@Test
void testPrimeNumbers() {
assertTrue(EulerPseudoprime.isProbablePrime(BigInteger.valueOf(7), 5));
assertTrue(EulerPseudoprime.isProbablePrime(BigInteger.valueOf(13), 5));
assertTrue(EulerPseudoprime.isProbablePrime(BigInteger.valueOf(101), 5));
}
@Test
void testCompositeNumbers() {
assertFalse(EulerPseudoprime.isProbablePrime(BigInteger.valueOf(9), 5));
assertFalse(EulerPseudoprime.isProbablePrime(BigInteger.valueOf(21), 5));
assertFalse(EulerPseudoprime.isProbablePrime(BigInteger.valueOf(221), 5));
}
@Test
void testEvenNumbers() {
assertFalse(EulerPseudoprime.isProbablePrime(BigInteger.valueOf(4), 5));
assertFalse(EulerPseudoprime.isProbablePrime(BigInteger.valueOf(100), 5));
}
@Test
void testEdgeCases() {
assertFalse(EulerPseudoprime.isProbablePrime(BigInteger.valueOf(0), 5));
assertFalse(EulerPseudoprime.isProbablePrime(BigInteger.valueOf(1), 5));
assertTrue(EulerPseudoprime.isProbablePrime(BigInteger.valueOf(2), 5));
assertTrue(EulerPseudoprime.isProbablePrime(BigInteger.valueOf(3), 5));
}
@Test
void testIsProbablePrimeWhenJacobiSymbolIsZero() {
try (MockedStatic<EulerPseudoprime> mockedPrimality = Mockito.mockStatic(EulerPseudoprime.class, Mockito.CALLS_REAL_METHODS)) {
// Mock jacobiSymbol to return 0 to test the branch
mockedPrimality.when(() -> EulerPseudoprime.jacobiSymbol(any(BigInteger.class), any(BigInteger.class))).thenReturn(0);
boolean result = EulerPseudoprime.isProbablePrime(BigInteger.valueOf(15), 1);
assertFalse(result);
}
}
@Test
void testJacobiSymbolThrowsForEvenOrNonPositiveN() throws Exception {
var method = EulerPseudoprime.class.getDeclaredMethod("jacobiSymbol", BigInteger.class, BigInteger.class);
// Helper lambda to unwrap InvocationTargetException
Runnable invokeJacobi = () -> {
try {
method.invoke(null, BigInteger.valueOf(2), BigInteger.valueOf(8));
} catch (Exception e) {
// unwrap
Throwable cause = e.getCause();
if (cause instanceof IllegalArgumentException) {
throw (IllegalArgumentException) cause;
} else {
throw new RuntimeException(e);
}
}
};
// Now check that it actually throws
assertThrows(IllegalArgumentException.class, invokeJacobi::run);
// Another case: non-positive n
Runnable invokeJacobi2 = () -> {
try {
method.invoke(null, BigInteger.valueOf(5), BigInteger.valueOf(-3));
} catch (Exception e) {
Throwable cause = e.getCause();
if (cause instanceof IllegalArgumentException) {
throw (IllegalArgumentException) cause;
} else {
throw new RuntimeException(e);
}
}
};
assertThrows(IllegalArgumentException.class, invokeJacobi2::run);
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/SieveOfAtkinTest.java | src/test/java/com/thealgorithms/maths/SieveOfAtkinTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.List;
import org.junit.jupiter.api.Test;
/**
* Unit tests for the {@code SieveOfAtkin} class.
*/
class SieveOfAtkinTest {
@Test
void testGeneratePrimesLimit10() {
List<Integer> primes = SieveOfAtkin.generatePrimes(10);
// Assert the full expected list of primes
List<Integer> expected = List.of(2, 3, 5, 7);
assertEquals(expected, primes, "Primes up to 10 should match expected list");
}
@Test
void testGeneratePrimesLimit2() {
List<Integer> primes = SieveOfAtkin.generatePrimes(2);
List<Integer> expected = List.of(2);
assertEquals(expected, primes, "Primes up to 2 should include 2");
}
@Test
void testGeneratePrimesLimit1() {
List<Integer> primes = SieveOfAtkin.generatePrimes(1);
assertTrue(primes.isEmpty(), "Primes list should be empty when limit < 2");
}
@Test
void testGeneratePrimesLimit50() {
List<Integer> primes = SieveOfAtkin.generatePrimes(50);
List<Integer> expected = List.of(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47);
assertEquals(expected, primes, "Primes up to 50 should match expected list");
}
@Test
void testGeneratePrimesNegativeLimit() {
List<Integer> primes = SieveOfAtkin.generatePrimes(-10);
assertTrue(primes.isEmpty(), "Primes list should be empty for negative limit");
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/FindMinRecursionTest.java | src/test/java/com/thealgorithms/maths/FindMinRecursionTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.stream.Stream;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
public class FindMinRecursionTest {
@ParameterizedTest
@MethodSource("inputStream")
void numberTests(int expected, int[] input) {
Assertions.assertEquals(expected, FindMinRecursion.min(input));
}
private static Stream<Arguments> inputStream() {
return Stream.of(Arguments.of(5, new int[] {5, 5, 5, 5, 5}), Arguments.of(-1, new int[] {-1, 0}), Arguments.of(-10, new int[] {-10, -9, -8, -7, -6, -5, -4, -3, -2, -1}), Arguments.of(-4, new int[] {3, -2, 3, 9, -4, -4, 8}), Arguments.of(3, new int[] {3}));
}
@Test
public void testFindMaxThrowsExceptionForEmptyInput() {
assertThrows(IllegalArgumentException.class, () -> FindMinRecursion.min(new int[] {}));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/SquareRootwithBabylonianMethodTest.java | src/test/java/com/thealgorithms/maths/SquareRootwithBabylonianMethodTest.java | package com.thealgorithms.maths;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
public class SquareRootwithBabylonianMethodTest {
@Test
void testfor4() {
Assertions.assertEquals(2, SquareRootWithBabylonianMethod.squareRoot(4));
}
@Test
void testfor1() {
Assertions.assertEquals(1, SquareRootWithBabylonianMethod.squareRoot(1));
}
@Test
void testfor2() {
Assertions.assertEquals(1.4142135381698608, SquareRootWithBabylonianMethod.squareRoot(2));
}
@Test
void testfor625() {
Assertions.assertEquals(25, SquareRootWithBabylonianMethod.squareRoot(625));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/PythagoreanTripleTest.java | src/test/java/com/thealgorithms/maths/PythagoreanTripleTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
public class PythagoreanTripleTest {
@ParameterizedTest
@CsvSource({"3, 4, 5, true", "6, 8, 10, true", "9, 12, 15, true", "12, 16, 20, true", "15, 20, 25, true", "18, 24, 30, true", "5, 20, 30, false", "6, 8, 100, false", "-2, -2, 2, false", "0, 0, 0, false", "5, 5, 5, false"})
void testIsPythagoreanTriple(int a, int b, int c, boolean expected) {
assertEquals(expected, PythagoreanTriple.isPythagTriple(a, b, c));
}
@Test
void testUnorderedInputStillValid() {
// Should still detect Pythagorean triples regardless of argument order
assertTrue(PythagoreanTriple.isPythagTriple(5, 3, 4));
assertTrue(PythagoreanTriple.isPythagTriple(13, 12, 5));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/PerfectSquareTest.java | src/test/java/com/thealgorithms/maths/PerfectSquareTest.java | package com.thealgorithms.maths;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
public class PerfectSquareTest {
@ParameterizedTest
@ValueSource(ints = {0, 1, 2 * 2, 3 * 3, 4 * 4, 5 * 5, 6 * 6, 7 * 7, 8 * 8, 9 * 9, 10 * 10, 11 * 11, 123 * 123})
void positiveTest(final int number) {
Assertions.assertTrue(PerfectSquare.isPerfectSquare(number));
Assertions.assertTrue(PerfectSquare.isPerfectSquareUsingPow(number));
}
@ParameterizedTest
@ValueSource(ints = {-1, -2, -3, -4, -5, -100, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 17, 99, 101, 257, 999, 1001})
void negativeTest(final int number) {
Assertions.assertFalse(PerfectSquare.isPerfectSquare(number));
Assertions.assertFalse(PerfectSquare.isPerfectSquareUsingPow(number));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/HeronsFormulaTest.java | src/test/java/com/thealgorithms/maths/HeronsFormulaTest.java | package com.thealgorithms.maths;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
/**
* Test cases for {@link HeronsFormula}.
*/
class HeronsFormulaTest {
private static final double EPSILON = 1e-10;
@Test
void testRightTriangleThreeFourFive() {
Assertions.assertEquals(6.0, HeronsFormula.herons(3, 4, 5), EPSILON);
}
@Test
void testTriangleTwentyFourThirtyEighteen() {
Assertions.assertEquals(216.0, HeronsFormula.herons(24, 30, 18), EPSILON);
}
@Test
void testEquilateralTriangle() {
Assertions.assertEquals(0.4330127018922193, HeronsFormula.herons(1, 1, 1), EPSILON);
}
@Test
void testScaleneTriangleFourFiveEight() {
Assertions.assertEquals(8.181534085976786, HeronsFormula.herons(4, 5, 8), EPSILON);
}
@Test
void testEquilateralTriangleLargeSides() {
final double side = 10.0;
final double expectedArea = Math.sqrt(3) / 4 * side * side;
Assertions.assertEquals(expectedArea, HeronsFormula.herons(side, side, side), EPSILON);
}
@Test
void testIsoscelesTriangle() {
Assertions.assertEquals(12.0, HeronsFormula.herons(5, 5, 6), EPSILON);
}
@Test
void testSmallTriangle() {
Assertions.assertEquals(0.4330127018922193, HeronsFormula.herons(1.0, 1.0, 1.0), EPSILON);
}
@Test
void testLargeTriangle() {
Assertions.assertEquals(600.0, HeronsFormula.herons(30, 40, 50), EPSILON);
}
@Test
void testDecimalSides() {
final double area = HeronsFormula.herons(2.5, 3.5, 4.0);
Assertions.assertTrue(area > 0);
Assertions.assertEquals(4.330127018922194, area, EPSILON);
}
@Test
void testDegenerateTriangleEqualToSumOfOtherTwo() {
Assertions.assertThrows(IllegalArgumentException.class, () -> { HeronsFormula.herons(1, 2, 3); });
}
@Test
void testDegenerateTriangleVariant2() {
Assertions.assertThrows(IllegalArgumentException.class, () -> { HeronsFormula.herons(2, 1, 3); });
}
@Test
void testDegenerateTriangleVariant3() {
Assertions.assertThrows(IllegalArgumentException.class, () -> { HeronsFormula.herons(3, 2, 1); });
}
@Test
void testDegenerateTriangleVariant4() {
Assertions.assertThrows(IllegalArgumentException.class, () -> { HeronsFormula.herons(1, 3, 2); });
}
@Test
void testInvalidTriangleSideGreaterThanSum() {
Assertions.assertThrows(IllegalArgumentException.class, () -> { HeronsFormula.herons(1, 1, 5); });
}
@Test
void testZeroFirstSide() {
Assertions.assertThrows(IllegalArgumentException.class, () -> { HeronsFormula.herons(0, 1, 1); });
}
@Test
void testZeroSecondSide() {
Assertions.assertThrows(IllegalArgumentException.class, () -> { HeronsFormula.herons(1, 0, 1); });
}
@Test
void testZeroThirdSide() {
Assertions.assertThrows(IllegalArgumentException.class, () -> { HeronsFormula.herons(1, 1, 0); });
}
@Test
void testNegativeFirstSide() {
Assertions.assertThrows(IllegalArgumentException.class, () -> { HeronsFormula.herons(-1, 2, 2); });
}
@Test
void testNegativeSecondSide() {
Assertions.assertThrows(IllegalArgumentException.class, () -> { HeronsFormula.herons(2, -1, 2); });
}
@Test
void testNegativeThirdSide() {
Assertions.assertThrows(IllegalArgumentException.class, () -> { HeronsFormula.herons(2, 2, -1); });
}
@Test
void testAllNegativeSides() {
Assertions.assertThrows(IllegalArgumentException.class, () -> { HeronsFormula.herons(-1, -2, -3); });
}
@Test
void testAllZeroSides() {
Assertions.assertThrows(IllegalArgumentException.class, () -> { HeronsFormula.herons(0, 0, 0); });
}
@Test
void testVerySmallTriangle() {
final double result = HeronsFormula.herons(0.001, 0.001, 0.001);
Assertions.assertTrue(result > 0);
Assertions.assertTrue(result < 0.001);
}
@Test
void testRightTriangleFiveTwelveThirteen() {
Assertions.assertEquals(30.0, HeronsFormula.herons(5, 12, 13), EPSILON);
}
@Test
void testRightTriangleEightFifteenSeventeen() {
Assertions.assertEquals(60.0, HeronsFormula.herons(8, 15, 17), EPSILON);
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/NumberPersistenceTest.java | src/test/java/com/thealgorithms/maths/NumberPersistenceTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import org.junit.jupiter.params.provider.ValueSource;
class NumberPersistenceTest {
@ParameterizedTest(name = "multiplicativePersistence({0}) = {1}")
@CsvSource({"0, 0", "7, 0", "217, 2", "39, 3", "999, 4"})
@DisplayName("Test multiplicative persistence with valid inputs")
void testMultiplicativePersistenceValid(int input, int expected) {
assertEquals(expected, NumberPersistence.multiplicativePersistence(input));
}
@ParameterizedTest(name = "multiplicativePersistence({0}) throws IllegalArgumentException")
@ValueSource(ints = {-1, -100, -9999})
@DisplayName("Test multiplicative persistence with negative numbers")
void testMultiplicativePersistenceNegative(int input) {
Exception exception = assertThrows(IllegalArgumentException.class, () -> NumberPersistence.multiplicativePersistence(input));
assertEquals("multiplicativePersistence() does not accept negative values", exception.getMessage());
}
@ParameterizedTest(name = "additivePersistence({0}) = {1}")
@CsvSource({"0, 0", "5, 0", "199, 3", "999, 2", "1234, 2"})
@DisplayName("Test additive persistence with valid inputs")
void testAdditivePersistenceValid(int input, int expected) {
assertEquals(expected, NumberPersistence.additivePersistence(input));
}
@ParameterizedTest(name = "additivePersistence({0}) throws IllegalArgumentException")
@ValueSource(ints = {-1, -100, -9999})
@DisplayName("Test additive persistence with negative numbers")
void testAdditivePersistenceNegative(int input) {
Exception exception = assertThrows(IllegalArgumentException.class, () -> NumberPersistence.additivePersistence(input));
assertEquals("additivePersistence() does not accept negative values", exception.getMessage());
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/EulersFunctionTest.java | src/test/java/com/thealgorithms/maths/EulersFunctionTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.stream.Stream;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
class EulersFunctionTest {
@ParameterizedTest
@MethodSource("provideNumbersForGetEuler")
void testGetEuler(int input, int expected) {
assertEquals(expected, EulersFunction.getEuler(input));
}
@ParameterizedTest
@MethodSource("provideInvalidNumbersForGetEuler")
void testGetEulerThrowsExceptionForNonPositiveInput(int input) {
assertThrows(IllegalArgumentException.class, () -> EulersFunction.getEuler(input));
}
private static Stream<Arguments> provideNumbersForGetEuler() {
return Stream.of(Arguments.of(1, 1), Arguments.of(2, 1), Arguments.of(3, 2), Arguments.of(4, 2), Arguments.of(5, 4), Arguments.of(6, 2), Arguments.of(10, 4), Arguments.of(21, 12), Arguments.of(69, 44), Arguments.of(47, 46), Arguments.of(46, 22), Arguments.of(55, 40), Arguments.of(34, 16),
Arguments.of(20, 8), Arguments.of(1024, 512));
}
private static Stream<Arguments> provideInvalidNumbersForGetEuler() {
return Stream.of(Arguments.of(0), Arguments.of(-1), Arguments.of(-10));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/ArmstrongTest.java | src/test/java/com/thealgorithms/maths/ArmstrongTest.java | package com.thealgorithms.maths;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.jupiter.api.Test;
/**
* @author satyabarghav
* @since 4/10/2023
*/
class ArmstrongTest {
@Test
void testIsArmstrong() {
Armstrong armstrong = new Armstrong();
assertThat(armstrong.isArmstrong(0)).isTrue();
assertThat(armstrong.isArmstrong(1)).isTrue();
assertThat(armstrong.isArmstrong(153)).isTrue();
assertThat(armstrong.isArmstrong(371)).isTrue();
assertThat(armstrong.isArmstrong(1634)).isTrue();
assertThat(armstrong.isArmstrong(200)).isFalse();
assertThat(armstrong.isArmstrong(548834)).isTrue();
assertThat(armstrong.isArmstrong(9474)).isTrue();
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/MeansTest.java | src/test/java/com/thealgorithms/maths/MeansTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
import java.util.Vector;
import org.junit.jupiter.api.Test;
/**
* Test class for {@link Means}.
* <p>
* This class provides comprehensive test coverage for all mean calculation
* methods,
* including edge cases, various collection types, and error conditions.
* </p>
*/
class MeansTest {
private static final double EPSILON = 1e-9;
// ========== Arithmetic Mean Tests ==========
@Test
void testArithmeticMeanThrowsExceptionForEmptyList() {
List<Double> numbers = new ArrayList<>();
IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> Means.arithmetic(numbers));
assertTrue(exception.getMessage().contains("Empty list"));
}
@Test
void testArithmeticMeanSingleNumber() {
List<Double> numbers = Arrays.asList(2.5);
assertEquals(2.5, Means.arithmetic(numbers), EPSILON);
}
@Test
void testArithmeticMeanTwoNumbers() {
List<Double> numbers = Arrays.asList(2.0, 4.0);
assertEquals(3.0, Means.arithmetic(numbers), EPSILON);
}
@Test
void testArithmeticMeanMultipleNumbers() {
List<Double> numbers = Arrays.asList(1.0, 2.0, 3.0, 4.0, 5.0);
assertEquals(3.0, Means.arithmetic(numbers), EPSILON);
}
@Test
void testArithmeticMeanWithTreeSet() {
Set<Double> numbers = new TreeSet<>(Arrays.asList(1.0, 2.5, 83.3, 25.9999, 46.0001, 74.7, 74.5));
assertEquals(44.0, Means.arithmetic(numbers), EPSILON);
}
@Test
void testArithmeticMeanWithNegativeNumbers() {
List<Double> numbers = Arrays.asList(-5.0, -3.0, -1.0, 1.0, 3.0, 5.0);
assertEquals(0.0, Means.arithmetic(numbers), EPSILON);
}
@Test
void testArithmeticMeanWithDecimalNumbers() {
List<Double> numbers = Arrays.asList(1.1, 2.2, 3.3, 4.4, 5.5);
assertEquals(3.3, Means.arithmetic(numbers), EPSILON);
}
@Test
void testArithmeticMeanWithVector() {
Vector<Double> numbers = new Vector<>(Arrays.asList(10.0, 20.0, 30.0));
assertEquals(20.0, Means.arithmetic(numbers), EPSILON);
}
// ========== Geometric Mean Tests ==========
@Test
void testGeometricMeanThrowsExceptionForEmptyList() {
List<Double> numbers = new ArrayList<>();
IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> Means.geometric(numbers));
assertTrue(exception.getMessage().contains("Empty list"));
}
@Test
void testGeometricMeanSingleNumber() {
Set<Double> numbers = new LinkedHashSet<>(Arrays.asList(2.5));
assertEquals(2.5, Means.geometric(numbers), EPSILON);
}
@Test
void testGeometricMeanTwoNumbers() {
List<Double> numbers = Arrays.asList(2.0, 8.0);
assertEquals(4.0, Means.geometric(numbers), EPSILON);
}
@Test
void testGeometricMeanMultipleNumbers() {
LinkedList<Double> numbers = new LinkedList<>(Arrays.asList(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 1.25));
assertEquals(2.6426195539300585, Means.geometric(numbers), EPSILON);
}
@Test
void testGeometricMeanPerfectSquares() {
List<Double> numbers = Arrays.asList(1.0, 4.0, 9.0, 16.0);
double expected = Math.pow(1.0 * 4.0 * 9.0 * 16.0, 1.0 / 4.0);
assertEquals(expected, Means.geometric(numbers), EPSILON);
}
@Test
void testGeometricMeanIdenticalNumbers() {
List<Double> numbers = Arrays.asList(5.0, 5.0, 5.0, 5.0);
assertEquals(5.0, Means.geometric(numbers), EPSILON);
}
@Test
void testGeometricMeanWithLinkedHashSet() {
LinkedHashSet<Double> numbers = new LinkedHashSet<>(Arrays.asList(2.0, 4.0, 8.0));
double expected = Math.pow(2.0 * 4.0 * 8.0, 1.0 / 3.0);
assertEquals(expected, Means.geometric(numbers), EPSILON);
}
// ========== Harmonic Mean Tests ==========
@Test
void testHarmonicMeanThrowsExceptionForEmptyList() {
List<Double> numbers = new ArrayList<>();
IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> Means.harmonic(numbers));
assertTrue(exception.getMessage().contains("Empty list"));
}
@Test
void testHarmonicMeanSingleNumber() {
LinkedHashSet<Double> numbers = new LinkedHashSet<>(Arrays.asList(2.5));
assertEquals(2.5, Means.harmonic(numbers), EPSILON);
}
@Test
void testHarmonicMeanTwoNumbers() {
List<Double> numbers = Arrays.asList(2.0, 4.0);
double expected = 2.0 / (1.0 / 2.0 + 1.0 / 4.0);
assertEquals(expected, Means.harmonic(numbers), EPSILON);
}
@Test
void testHarmonicMeanMultipleNumbers() {
Vector<Double> numbers = new Vector<>(Arrays.asList(1.0, 2.5, 83.3, 25.9999, 46.0001, 74.7, 74.5));
assertEquals(4.6697322801074135, Means.harmonic(numbers), EPSILON);
}
@Test
void testHarmonicMeanThreeNumbers() {
List<Double> numbers = Arrays.asList(1.0, 2.0, 4.0);
double expected = 3.0 / (1.0 / 1.0 + 1.0 / 2.0 + 1.0 / 4.0);
assertEquals(expected, Means.harmonic(numbers), EPSILON);
}
@Test
void testHarmonicMeanIdenticalNumbers() {
List<Double> numbers = Arrays.asList(6.0, 6.0, 6.0);
assertEquals(6.0, Means.harmonic(numbers), EPSILON);
}
@Test
void testHarmonicMeanWithLinkedList() {
LinkedList<Double> numbers = new LinkedList<>(Arrays.asList(3.0, 6.0, 9.0));
double expected = 3.0 / (1.0 / 3.0 + 1.0 / 6.0 + 1.0 / 9.0);
assertEquals(expected, Means.harmonic(numbers), EPSILON);
}
// ========== Additional Edge Case Tests ==========
@Test
void testArithmeticMeanWithVeryLargeNumbers() {
List<Double> numbers = Arrays.asList(1e100, 2e100, 3e100);
assertEquals(2e100, Means.arithmetic(numbers), 1e90);
}
@Test
void testArithmeticMeanWithVerySmallNumbers() {
List<Double> numbers = Arrays.asList(1e-100, 2e-100, 3e-100);
assertEquals(2e-100, Means.arithmetic(numbers), 1e-110);
}
@Test
void testGeometricMeanWithOnes() {
List<Double> numbers = Arrays.asList(1.0, 1.0, 1.0, 1.0);
assertEquals(1.0, Means.geometric(numbers), EPSILON);
}
@Test
void testAllMeansConsistencyForIdenticalValues() {
List<Double> numbers = Arrays.asList(7.5, 7.5, 7.5, 7.5);
double arithmetic = Means.arithmetic(numbers);
double geometric = Means.geometric(numbers);
double harmonic = Means.harmonic(numbers);
assertEquals(7.5, arithmetic, EPSILON);
assertEquals(7.5, geometric, EPSILON);
assertEquals(7.5, harmonic, EPSILON);
}
@Test
void testMeansRelationship() {
// For positive numbers, harmonic mean ≤ geometric mean ≤ arithmetic mean
List<Double> numbers = Arrays.asList(2.0, 4.0, 8.0);
double arithmetic = Means.arithmetic(numbers);
double geometric = Means.geometric(numbers);
double harmonic = Means.harmonic(numbers);
assertTrue(harmonic <= geometric, "Harmonic mean should be ≤ geometric mean");
assertTrue(geometric <= arithmetic, "Geometric mean should be ≤ arithmetic mean");
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/StandardDeviationTest.java | src/test/java/com/thealgorithms/maths/StandardDeviationTest.java | package com.thealgorithms.maths;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
public class StandardDeviationTest {
@Test
void test1() {
double[] t1 = new double[] {1, 1, 1, 1, 1};
Assertions.assertEquals(StandardDeviation.stdDev(t1), 0.0);
}
@Test
void test2() {
double[] t2 = new double[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
Assertions.assertEquals(StandardDeviation.stdDev(t2), 2.8722813232690143);
}
@Test
void test3() {
double[] t3 = new double[] {1.1, 8.5, 20.3, 2.4, 6.2};
Assertions.assertEquals(StandardDeviation.stdDev(t3), 6.8308125431752265);
}
@Test
void test4() {
double[] t4 = new double[] {
3.14,
2.22222,
9.89898989,
100.00045,
56.7,
};
Assertions.assertEquals(StandardDeviation.stdDev(t4), 38.506117353865775);
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/PowerOfTwoOrNotTest.java | src/test/java/com/thealgorithms/maths/PowerOfTwoOrNotTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;
public class PowerOfTwoOrNotTest {
@Test
public void testPowerOfTwoOrNotForPowersOfTwo() {
final var powersOfTwo = new int[] {1, 2, 4, 8, 16, 32, 64};
for (final var n : powersOfTwo) {
assertTrue(PowerOfTwoOrNot.checkIfPowerOfTwoOrNot(n));
}
}
@Test
public void testPowerOfTwoOrNotForNotPowersOfTwo() {
final var notPowersOfTwo = new int[] {-16, -8, -6, -5, -4, -3, -2, -1, 0, 3, 5, 6, 7, 9, 10, 11, 33, 63, 65, 1000, 9999};
for (final var n : notPowersOfTwo) {
assertFalse(PowerOfTwoOrNot.checkIfPowerOfTwoOrNot(n));
}
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/LuckyNumberTest.java | src/test/java/com/thealgorithms/maths/LuckyNumberTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
class LuckyNumberTest {
@ParameterizedTest
@CsvSource({"1", "3", "13", "49", "109", "459", "949"})
void luckyNumbersTest(int n) {
assertTrue(LuckyNumber.isLucky(n));
assertTrue(LuckyNumber.isLuckyNumber(n));
}
@ParameterizedTest
@CsvSource({"2", "17", "100", "300", "700"})
void nonLuckyNumbersTest(int n) {
assertFalse(LuckyNumber.isLucky(n));
assertFalse(LuckyNumber.isLuckyNumber(n));
}
@ParameterizedTest
@CsvSource({"0", "-1"})
void throwsNegativeNumbersNotAllowed(int n) {
assertThrows(IllegalArgumentException.class, () -> LuckyNumber.isLucky(n));
assertThrows(IllegalArgumentException.class, () -> LuckyNumber.isLuckyNumber(n));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/FindMinTest.java | src/test/java/com/thealgorithms/maths/FindMinTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.stream.Stream;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
public class FindMinTest {
@ParameterizedTest
@MethodSource("inputStream")
void numberTests(int expected, int[] input) {
Assertions.assertEquals(expected, FindMin.findMin(input));
}
private static Stream<Arguments> inputStream() {
return Stream.of(Arguments.of(1, new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}), Arguments.of(5, new int[] {5, 5, 5, 5, 5}), Arguments.of(0, new int[] {0, 192, 384, 576}), Arguments.of(-1, new int[] {-1, 2, 5, 10}), Arguments.of(-10, new int[] {-10, -9, -8, -7, -6, -5, -4, -3, -2, -1}),
Arguments.of(-4, new int[] {4, -3, 8, 9, -4, -4, 10}));
}
@Test
public void testFindMinThrowsExceptionForEmptyInput() {
assertThrows(IllegalArgumentException.class, () -> FindMin.findMin(new int[] {}));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/PowerOfFourTest.java | src/test/java/com/thealgorithms/maths/PowerOfFourTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;
class PowerOfFourTest {
@Test
void testPowersOfFour() {
assertTrue(PowerOfFour.isPowerOfFour(1));
assertTrue(PowerOfFour.isPowerOfFour(4));
assertTrue(PowerOfFour.isPowerOfFour(16));
assertTrue(PowerOfFour.isPowerOfFour(64));
assertTrue(PowerOfFour.isPowerOfFour(256));
assertTrue(PowerOfFour.isPowerOfFour(1024));
}
@Test
void testNonPowersOfFour() {
assertFalse(PowerOfFour.isPowerOfFour(2));
assertFalse(PowerOfFour.isPowerOfFour(3));
assertFalse(PowerOfFour.isPowerOfFour(5));
assertFalse(PowerOfFour.isPowerOfFour(8));
assertFalse(PowerOfFour.isPowerOfFour(15));
assertFalse(PowerOfFour.isPowerOfFour(32));
}
@Test
void testEdgeCases() {
assertFalse(PowerOfFour.isPowerOfFour(0));
assertFalse(PowerOfFour.isPowerOfFour(-1));
assertFalse(PowerOfFour.isPowerOfFour(-4));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/AliquotSumTest.java | src/test/java/com/thealgorithms/maths/AliquotSumTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
public class AliquotSumTest {
@Test
void testGetMaxValue() {
assertEquals(0, AliquotSum.getAliquotValue(1));
assertEquals(6, AliquotSum.getAliquotValue(6));
assertEquals(9, AliquotSum.getAliquotValue(15));
assertEquals(1, AliquotSum.getAliquotValue(19));
assertEquals(0, AliquotSum.getAliquotSum(1));
assertEquals(6, AliquotSum.getAliquotSum(6));
assertEquals(9, AliquotSum.getAliquotSum(15));
assertEquals(1, AliquotSum.getAliquotSum(19));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/LeonardoNumberTest.java | src/test/java/com/thealgorithms/maths/LeonardoNumberTest.java | package com.thealgorithms.maths;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
/**
* Test cases for {@link LeonardoNumber} class.
* <p>
* Tests both recursive and iterative implementations with various input values
* including edge cases and boundary conditions.
*/
class LeonardoNumberTest {
// Tests for recursive implementation
@Test
void testLeonardoNumberNegative() {
Assertions.assertThrows(IllegalArgumentException.class, () -> LeonardoNumber.leonardoNumber(-1));
}
@Test
void testLeonardoNumberNegativeLarge() {
Assertions.assertThrows(IllegalArgumentException.class, () -> LeonardoNumber.leonardoNumber(-100));
}
@Test
void testLeonardoNumberZero() {
Assertions.assertEquals(1, LeonardoNumber.leonardoNumber(0));
}
@Test
void testLeonardoNumberOne() {
Assertions.assertEquals(1, LeonardoNumber.leonardoNumber(1));
}
@Test
void testLeonardoNumberTwo() {
Assertions.assertEquals(3, LeonardoNumber.leonardoNumber(2));
}
@Test
void testLeonardoNumberThree() {
Assertions.assertEquals(5, LeonardoNumber.leonardoNumber(3));
}
@Test
void testLeonardoNumberFour() {
Assertions.assertEquals(9, LeonardoNumber.leonardoNumber(4));
}
@Test
void testLeonardoNumberFive() {
Assertions.assertEquals(15, LeonardoNumber.leonardoNumber(5));
}
@Test
void testLeonardoNumberSix() {
Assertions.assertEquals(25, LeonardoNumber.leonardoNumber(6));
}
@Test
void testLeonardoNumberSeven() {
Assertions.assertEquals(41, LeonardoNumber.leonardoNumber(7));
}
@Test
void testLeonardoNumberEight() {
Assertions.assertEquals(67, LeonardoNumber.leonardoNumber(8));
}
@Test
void testLeonardoNumberTen() {
Assertions.assertEquals(177, LeonardoNumber.leonardoNumber(10));
}
@Test
void testLeonardoNumberFifteen() {
Assertions.assertEquals(1973, LeonardoNumber.leonardoNumber(15));
}
@Test
void testLeonardoNumberTwenty() {
Assertions.assertEquals(21891, LeonardoNumber.leonardoNumber(20));
}
// Tests for iterative implementation
@Test
void testLeonardoNumberIterativeNegative() {
Assertions.assertThrows(IllegalArgumentException.class, () -> LeonardoNumber.leonardoNumberIterative(-1));
}
@Test
void testLeonardoNumberIterativeNegativeLarge() {
Assertions.assertThrows(IllegalArgumentException.class, () -> LeonardoNumber.leonardoNumberIterative(-50));
}
@Test
void testLeonardoNumberIterativeZero() {
Assertions.assertEquals(1, LeonardoNumber.leonardoNumberIterative(0));
}
@Test
void testLeonardoNumberIterativeOne() {
Assertions.assertEquals(1, LeonardoNumber.leonardoNumberIterative(1));
}
@Test
void testLeonardoNumberIterativeTwo() {
Assertions.assertEquals(3, LeonardoNumber.leonardoNumberIterative(2));
}
@Test
void testLeonardoNumberIterativeThree() {
Assertions.assertEquals(5, LeonardoNumber.leonardoNumberIterative(3));
}
@Test
void testLeonardoNumberIterativeFour() {
Assertions.assertEquals(9, LeonardoNumber.leonardoNumberIterative(4));
}
@Test
void testLeonardoNumberIterativeFive() {
Assertions.assertEquals(15, LeonardoNumber.leonardoNumberIterative(5));
}
@Test
void testLeonardoNumberIterativeSix() {
Assertions.assertEquals(25, LeonardoNumber.leonardoNumberIterative(6));
}
@Test
void testLeonardoNumberIterativeSeven() {
Assertions.assertEquals(41, LeonardoNumber.leonardoNumberIterative(7));
}
@Test
void testLeonardoNumberIterativeEight() {
Assertions.assertEquals(67, LeonardoNumber.leonardoNumberIterative(8));
}
@Test
void testLeonardoNumberIterativeTen() {
Assertions.assertEquals(177, LeonardoNumber.leonardoNumberIterative(10));
}
@Test
void testLeonardoNumberIterativeFifteen() {
Assertions.assertEquals(1973, LeonardoNumber.leonardoNumberIterative(15));
}
@Test
void testLeonardoNumberIterativeTwenty() {
Assertions.assertEquals(21891, LeonardoNumber.leonardoNumberIterative(20));
}
@Test
void testLeonardoNumberIterativeTwentyFive() {
Assertions.assertEquals(242785, LeonardoNumber.leonardoNumberIterative(25));
}
// Consistency tests between recursive and iterative implementations
@Test
void testConsistencyBetweenImplementations() {
for (int i = 0; i <= 15; i++) {
Assertions.assertEquals(LeonardoNumber.leonardoNumber(i), LeonardoNumber.leonardoNumberIterative(i), "Mismatch at index " + i);
}
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/SumOfArithmeticSeriesTest.java | src/test/java/com/thealgorithms/maths/SumOfArithmeticSeriesTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.Test;
public class SumOfArithmeticSeriesTest {
@Test
public void testSumFrom1To10() {
assertEquals(55.0, SumOfArithmeticSeries.sumOfSeries(1.0, 1.0, 10));
}
@Test
public void testSumOfOddNumbers1To19() {
assertEquals(100.0, SumOfArithmeticSeries.sumOfSeries(1.0, 2.0, 10));
}
@Test
public void testA() {
assertEquals(460.0, SumOfArithmeticSeries.sumOfSeries(1.0, 10.0, 10));
}
@Test
public void testB() {
assertEquals(5.5, SumOfArithmeticSeries.sumOfSeries(0.1, 0.1, 10));
}
@Test
public void testC() {
assertEquals(49600.0, SumOfArithmeticSeries.sumOfSeries(1, 10, 100));
}
@Test
public void testForZeroTerms() {
assertEquals(0.0, SumOfArithmeticSeries.sumOfSeries(1.0, 100.0, 0), 0.00001);
}
@Test
public void testIfThrowsExceptionForNegativeNumberOfTerms() {
assertThrows(IllegalArgumentException.class, () -> SumOfArithmeticSeries.sumOfSeries(1.0, 1.0, -1));
}
@Test
public void testWithSingleTerm() {
assertEquals(123.0, SumOfArithmeticSeries.sumOfSeries(123.0, 5.0, 1));
}
@Test
public void testWithZeroCommonDiff() {
assertEquals(100.0, SumOfArithmeticSeries.sumOfSeries(1.0, 0.0, 100));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/QuadraticEquationSolverTest.java | src/test/java/com/thealgorithms/maths/QuadraticEquationSolverTest.java | package com.thealgorithms.maths;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
public class QuadraticEquationSolverTest {
private final QuadraticEquationSolver quadraticEquationSolver = new QuadraticEquationSolver();
@Test
public void testSolveEquationRealRoots() {
// 4.2x^2 + 8x + 1.9 = 0
double a = 4.2;
double b = 8;
double c = 1.9;
ComplexNumber[] roots = quadraticEquationSolver.solveEquation(a, b, c);
Assertions.assertEquals(roots.length, 2);
Assertions.assertEquals(roots[0].real, -0.27810465435684306);
Assertions.assertNull(roots[0].imaginary);
Assertions.assertEquals(roots[1].real, -1.6266572504050616);
Assertions.assertNull(roots[1].imaginary);
}
@Test
public void testSolveEquationEqualRoots() {
// x^2 + 2x + 1 = 0
double a = 1;
double b = 2;
double c = 1;
ComplexNumber[] roots = quadraticEquationSolver.solveEquation(a, b, c);
Assertions.assertEquals(roots.length, 1);
Assertions.assertEquals(roots[0].real, -1);
}
@Test
public void testSolveEquationComplexRoots() {
// 2.3x^2 + 4x + 5.6 = 0
double a = 2.3;
double b = 4;
double c = 5.6;
ComplexNumber[] roots = quadraticEquationSolver.solveEquation(a, b, c);
Assertions.assertEquals(roots.length, 2);
Assertions.assertEquals(roots[0].real, -0.8695652173913044);
Assertions.assertEquals(roots[0].imaginary, 1.2956229935435948);
Assertions.assertEquals(roots[1].real, -0.8695652173913044);
Assertions.assertEquals(roots[1].imaginary, -1.2956229935435948);
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/StrobogrammaticNumberTest.java | src/test/java/com/thealgorithms/maths/StrobogrammaticNumberTest.java | package com.thealgorithms.maths;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.jupiter.api.Test;
class StrobogrammaticNumberTest {
@Test
void testIsStrobogrammatic() {
StrobogrammaticNumber strobogrammaticNumber = new StrobogrammaticNumber();
assertThat(strobogrammaticNumber.isStrobogrammatic("69")).isTrue();
assertThat(strobogrammaticNumber.isStrobogrammatic("88")).isTrue();
assertThat(strobogrammaticNumber.isStrobogrammatic("818")).isTrue();
assertThat(strobogrammaticNumber.isStrobogrammatic("101")).isTrue();
assertThat(strobogrammaticNumber.isStrobogrammatic("609")).isTrue();
assertThat(strobogrammaticNumber.isStrobogrammatic("120")).isFalse();
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/AbsoluteMaxTest.java | src/test/java/com/thealgorithms/maths/AbsoluteMaxTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.Test;
public class AbsoluteMaxTest {
@Test
void testGetMaxValue() {
assertEquals(16, AbsoluteMax.getMaxValue(-2, 0, 16));
assertEquals(-22, AbsoluteMax.getMaxValue(-3, -10, -22));
assertEquals(-888, AbsoluteMax.getMaxValue(-888));
assertEquals(-1, AbsoluteMax.getMaxValue(-1, -1, -1, -1, -1));
}
@Test
void testGetMaxValueWithNoArguments() {
assertThrows(IllegalArgumentException.class, AbsoluteMax::getMaxValue);
}
@Test
void testGetMaxValueWithSameAbsoluteValues() {
assertEquals(5, AbsoluteMax.getMaxValue(-5, 5));
assertEquals(5, AbsoluteMax.getMaxValue(5, -5));
assertEquals(12, AbsoluteMax.getMaxValue(-12, 9, 3, 12, 1));
assertEquals(12, AbsoluteMax.getMaxValue(12, 9, 3, -12, 1));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/ParseIntegerTest.java | src/test/java/com/thealgorithms/maths/ParseIntegerTest.java | package com.thealgorithms.maths;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
/**
* @author Albina Gimaletdinova on 01/07/2023
*/
public class ParseIntegerTest {
private static final String NULL_PARAMETER_MESSAGE = "Input parameter must not be null!";
private static final String EMPTY_PARAMETER_MESSAGE = "Input parameter must not be empty!";
private static final String INCORRECT_FORMAT_MESSAGE = "Input parameter of incorrect format";
@Test
public void testNullInput() {
IllegalArgumentException exception = Assertions.assertThrows(IllegalArgumentException.class, () -> ParseInteger.parseInt(null));
Assertions.assertEquals(exception.getMessage(), NULL_PARAMETER_MESSAGE);
}
@Test
public void testEmptyInput() {
IllegalArgumentException exception = Assertions.assertThrows(IllegalArgumentException.class, () -> ParseInteger.parseInt(""));
Assertions.assertEquals(exception.getMessage(), EMPTY_PARAMETER_MESSAGE);
}
@Test
public void testInputOfIncorrectFormat() {
IllegalArgumentException exception = Assertions.assertThrows(NumberFormatException.class, () -> ParseInteger.parseInt("+0a123"));
Assertions.assertTrue(exception.getMessage().contains(INCORRECT_FORMAT_MESSAGE));
exception = Assertions.assertThrows(NumberFormatException.class, () -> ParseInteger.parseInt("b"));
Assertions.assertTrue(exception.getMessage().contains(INCORRECT_FORMAT_MESSAGE));
}
@Test
public void testPositiveValueIsSuccessfullyConverted() {
Assertions.assertEquals(ParseInteger.parseInt("0"), Integer.parseInt("0"));
Assertions.assertEquals(ParseInteger.parseInt("123"), Integer.parseInt("123"));
Assertions.assertEquals(ParseInteger.parseInt("0123"), Integer.parseInt("0123"));
Assertions.assertEquals(ParseInteger.parseInt("+0123"), Integer.parseInt("+0123"));
Assertions.assertEquals(ParseInteger.parseInt("+123"), Integer.parseInt("+123"));
}
@Test
public void testNegativeValueIsSuccessfullyConverted() {
Assertions.assertEquals(ParseInteger.parseInt("-1"), Integer.parseInt("-1"));
Assertions.assertEquals(ParseInteger.parseInt("-123"), Integer.parseInt("-123"));
Assertions.assertEquals(ParseInteger.parseInt("-0123"), Integer.parseInt("-0123"));
Assertions.assertEquals(ParseInteger.parseInt("-00123"), Integer.parseInt("-00123"));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/FrizzyNumberTest.java | src/test/java/com/thealgorithms/maths/FrizzyNumberTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
public class FrizzyNumberTest {
@Test
public void testFrizziesForBase2() {
assertEquals(1, FrizzyNumber.getNthFrizzy(2, 1));
assertEquals(3, FrizzyNumber.getNthFrizzy(2, 3));
assertEquals(1000, FrizzyNumber.getNthFrizzy(2, 1000));
}
@Test
public void testFrizziesForBase3() {
assertEquals(1, FrizzyNumber.getNthFrizzy(3, 1));
assertEquals(3, FrizzyNumber.getNthFrizzy(3, 2));
assertEquals(29430, FrizzyNumber.getNthFrizzy(3, 1000));
}
@Test
public void testFrizziesForBase69() {
assertEquals(1, FrizzyNumber.getNthFrizzy(69, 1));
assertEquals(69, FrizzyNumber.getNthFrizzy(69, 2));
assertEquals(328510, FrizzyNumber.getNthFrizzy(69, 9));
assertEquals(333340, FrizzyNumber.getNthFrizzy(69, 15));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/SumOfDigitsTest.java | src/test/java/com/thealgorithms/maths/SumOfDigitsTest.java | package com.thealgorithms.maths;
import java.util.stream.Stream;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
class SumOfDigitsTest {
@ParameterizedTest
@MethodSource("testCases")
void sumOfDigitsTest(final int expected, final int input) {
Assertions.assertEquals(expected, SumOfDigits.sumOfDigits(input));
}
@ParameterizedTest
@MethodSource("testCases")
void sumOfDigitsRecursionTest(final int expected, final int input) {
Assertions.assertEquals(expected, SumOfDigits.sumOfDigitsRecursion(input));
}
@ParameterizedTest
@MethodSource("testCases")
void sumOfDigitsFastTest(final int expected, final int input) {
Assertions.assertEquals(expected, SumOfDigits.sumOfDigitsFast(input));
}
private static Stream<Arguments> testCases() {
return Stream.of(Arguments.of(0, 0), Arguments.of(1, 1), Arguments.of(15, 12345), Arguments.of(6, -123), Arguments.of(1, -100000), Arguments.of(8, 512));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/KeithNumberTest.java | src/test/java/com/thealgorithms/maths/KeithNumberTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;
/**
* Test cases for {@link KeithNumber}.
*/
class KeithNumberTest {
/**
* Tests single-digit Keith numbers.
* All single-digit numbers (1-9) are Keith numbers by definition.
*/
@Test
void testSingleDigitKeithNumbers() {
assertTrue(KeithNumber.isKeith(1));
assertTrue(KeithNumber.isKeith(2));
assertTrue(KeithNumber.isKeith(3));
assertTrue(KeithNumber.isKeith(4));
assertTrue(KeithNumber.isKeith(5));
assertTrue(KeithNumber.isKeith(6));
assertTrue(KeithNumber.isKeith(7));
assertTrue(KeithNumber.isKeith(8));
assertTrue(KeithNumber.isKeith(9));
}
/**
* Tests two-digit Keith numbers.
* Known two-digit Keith numbers: 14, 19, 28, 47, 61, 75.
*/
@Test
void testTwoDigitKeithNumbers() {
assertTrue(KeithNumber.isKeith(14));
assertTrue(KeithNumber.isKeith(19));
assertTrue(KeithNumber.isKeith(28));
assertTrue(KeithNumber.isKeith(47));
assertTrue(KeithNumber.isKeith(61));
assertTrue(KeithNumber.isKeith(75));
}
/**
* Tests three-digit Keith numbers.
* Known three-digit Keith numbers: 197, 742.
*/
@Test
void testThreeDigitKeithNumbers() {
assertTrue(KeithNumber.isKeith(197));
assertTrue(KeithNumber.isKeith(742));
}
/**
* Tests four-digit Keith numbers.
* Known four-digit Keith numbers: 1104, 1537, 2208, 2580, 3684, 4788, 7385,
* 7647, 7909.
*/
@Test
void testFourDigitKeithNumbers() {
assertTrue(KeithNumber.isKeith(1104));
assertTrue(KeithNumber.isKeith(1537));
assertTrue(KeithNumber.isKeith(2208));
}
/**
* Tests two-digit non-Keith numbers.
*/
@Test
void testTwoDigitNonKeithNumbers() {
assertFalse(KeithNumber.isKeith(10));
assertFalse(KeithNumber.isKeith(11));
assertFalse(KeithNumber.isKeith(12));
assertFalse(KeithNumber.isKeith(13));
assertFalse(KeithNumber.isKeith(15));
assertFalse(KeithNumber.isKeith(20));
assertFalse(KeithNumber.isKeith(30));
assertFalse(KeithNumber.isKeith(50));
}
/**
* Tests three-digit non-Keith numbers.
*/
@Test
void testThreeDigitNonKeithNumbers() {
assertFalse(KeithNumber.isKeith(100));
assertFalse(KeithNumber.isKeith(123));
assertFalse(KeithNumber.isKeith(196));
assertFalse(KeithNumber.isKeith(198));
assertFalse(KeithNumber.isKeith(456));
assertFalse(KeithNumber.isKeith(741));
assertFalse(KeithNumber.isKeith(743));
assertFalse(KeithNumber.isKeith(999));
}
/**
* Tests validation for edge case 14 in detail.
* 14 is a Keith number: 1, 4, 5 (1+4), 9 (4+5), 14 (5+9).
*/
@Test
void testKeithNumber14() {
assertTrue(KeithNumber.isKeith(14));
}
/**
* Tests validation for edge case 197 in detail.
* 197 is a Keith number: 1, 9, 7, 17, 33, 57, 107, 197.
*/
@Test
void testKeithNumber197() {
assertTrue(KeithNumber.isKeith(197));
}
/**
* Tests that zero throws an IllegalArgumentException.
*/
@Test
void testZeroThrowsException() {
assertThrows(IllegalArgumentException.class, () -> KeithNumber.isKeith(0));
}
/**
* Tests that negative numbers throw an IllegalArgumentException.
*/
@Test
void testNegativeNumbersThrowException() {
assertThrows(IllegalArgumentException.class, () -> KeithNumber.isKeith(-1));
assertThrows(IllegalArgumentException.class, () -> KeithNumber.isKeith(-14));
assertThrows(IllegalArgumentException.class, () -> KeithNumber.isKeith(-100));
}
/**
* Tests various edge cases with larger numbers.
*/
@Test
void testLargerNumbers() {
assertTrue(KeithNumber.isKeith(2208));
assertFalse(KeithNumber.isKeith(2207));
assertFalse(KeithNumber.isKeith(2209));
}
/**
* Tests the expected behavior with all two-digit Keith numbers.
*/
@Test
void testAllKnownTwoDigitKeithNumbers() {
int[] knownKeithNumbers = {14, 19, 28, 47, 61, 75};
for (int number : knownKeithNumbers) {
assertTrue(KeithNumber.isKeith(number), "Expected " + number + " to be a Keith number");
}
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/FibonacciNumberGoldenRationTest.java | src/test/java/com/thealgorithms/maths/FibonacciNumberGoldenRationTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.math.BigInteger;
import org.junit.jupiter.api.Test;
public class FibonacciNumberGoldenRationTest {
@Test
public void returnsCorrectValues() {
for (int n = 0; n <= FibonacciNumberGoldenRation.MAX_ARG; ++n) {
final var actual = FibonacciNumberGoldenRation.compute(n);
final var expected = FibonacciLoop.compute(n);
assertEquals(expected, BigInteger.valueOf(actual));
}
}
@Test
public void throwsIllegalArgumentExceptionForNegativeInput() {
assertThrows(IllegalArgumentException.class, () -> { FibonacciNumberGoldenRation.compute(-1); });
}
@Test
public void throwsIllegalArgumentExceptionForLargeInput() {
assertThrows(IllegalArgumentException.class, () -> { FibonacciNumberGoldenRation.compute(FibonacciNumberGoldenRation.MAX_ARG + 1); });
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/DudeneyNumberTest.java | src/test/java/com/thealgorithms/maths/DudeneyNumberTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
class DudeneyNumberTest {
@ParameterizedTest
@CsvSource({"1", "512", "4913", "5832", "17576", "19683"})
void positiveDudeneyBase10Power3(final int n) {
assertTrue(DudeneyNumber.isDudeney(n));
}
@ParameterizedTest
@CsvSource({"2", "19", "21", "125", "27", "343", "729", "19682", "19684"})
void negativeDudeneyBase10Power3(final int n) {
assertFalse(DudeneyNumber.isDudeney(n));
}
@ParameterizedTest
@CsvSource({"0", "-1"})
void throwsInputLessThanOne(final int n) {
assertThrows(IllegalArgumentException.class, () -> DudeneyNumber.isDudeney(n));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/SecondMinMaxTest.java | src/test/java/com/thealgorithms/maths/SecondMinMaxTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.stream.Stream;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
public class SecondMinMaxTest {
private static final String EXP_MSG_ARR_LEN_LESS_2 = "Input array must have length of at least two";
private static final String EXP_MSG_ARR_SAME_ELE = "Input array should have at least 2 distinct elements";
public static class TestCase {
public TestCase(final int[] inInputArray, final int inSecondMin, final int inSecondMax) {
inputArray = inInputArray;
secondMin = inSecondMin;
secondMax = inSecondMax;
}
final int[] inputArray;
final int secondMin;
final int secondMax;
}
@Test
public void testForEmptyInputArray() {
IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> SecondMinMax.findSecondMin(new int[] {}));
assertEquals(exception.getMessage(), EXP_MSG_ARR_LEN_LESS_2);
}
@Test
public void testForArrayWithSingleElement() {
IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> SecondMinMax.findSecondMax(new int[] {1}));
assertEquals(exception.getMessage(), EXP_MSG_ARR_LEN_LESS_2);
}
@Test
public void testForArrayWithSameElements() {
IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> SecondMinMax.findSecondMin(new int[] {1, 1, 1, 1}));
assertEquals(exception.getMessage(), EXP_MSG_ARR_SAME_ELE);
}
@ParameterizedTest
@MethodSource("inputStream")
void numberTests(final TestCase tc) {
Assertions.assertEquals(tc.secondMax, SecondMinMax.findSecondMax(tc.inputArray));
Assertions.assertEquals(tc.secondMin, SecondMinMax.findSecondMin(tc.inputArray));
}
private static Stream<Arguments> inputStream() {
return Stream.of(Arguments.of(new TestCase(new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 2, 9)), Arguments.of(new TestCase(new int[] {5, 4, 5, 5, 5}, 5, 4)), Arguments.of(new TestCase(new int[] {-1, 0}, 0, -1)),
Arguments.of(new TestCase(new int[] {-10, -9, -8, -7, -6, -5, -4, -3, -2, -1}, -9, -2)), Arguments.of(new TestCase(new int[] {3, -2, 3, 9, -4, -4, 8}, -2, 8)));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/UniformNumbersTest.java | src/test/java/com/thealgorithms/maths/UniformNumbersTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
class UniformNumbersTest {
@Test
void testSingleUniformDigitRange() {
assertEquals(1, UniformNumbers.countUniformIntegers(1, 1));
assertEquals(9, UniformNumbers.countUniformIntegers(1, 9));
}
@Test
void testSmallRange() {
assertEquals(1, UniformNumbers.countUniformIntegers(10, 11));
assertEquals(2, UniformNumbers.countUniformIntegers(22, 33));
}
@Test
void testRangeWithNoUniformNumbers() {
assertEquals(0, UniformNumbers.countUniformIntegers(12, 21));
assertEquals(0, UniformNumbers.countUniformIntegers(123, 128));
}
@Test
void testRangeWithAllUniformNumbers() {
assertEquals(9, UniformNumbers.countUniformIntegers(1, 9));
assertEquals(18, UniformNumbers.countUniformIntegers(1, 99));
}
@Test
void testMultiDigitRangeWithUniformNumbers() {
assertEquals(1, UniformNumbers.countUniformIntegers(100, 111));
assertEquals(2, UniformNumbers.countUniformIntegers(111, 222));
}
@Test
void testExactUniformBoundary() {
assertEquals(1, UniformNumbers.countUniformIntegers(111, 111));
assertEquals(2, UniformNumbers.countUniformIntegers(111, 222));
}
@Test
void testLargeRange() {
assertEquals(27, UniformNumbers.countUniformIntegers(1, 999));
assertEquals(36, UniformNumbers.countUniformIntegers(1, 9999));
}
@Test
void testInvalidRange() {
assertEquals(0, UniformNumbers.countUniformIntegers(500, 100));
assertEquals(0, UniformNumbers.countUniformIntegers(-100, -1));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/PerimeterTest.java | src/test/java/com/thealgorithms/maths/PerimeterTest.java | package com.thealgorithms.maths;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
public class PerimeterTest {
// Perimeter of Regular polygon
@Test
void testcase1() {
Assertions.assertEquals(20.0, Perimeter.perimeterRegularPolygon(4, 5));
}
@Test
void testcase2() {
Assertions.assertEquals(30.0, Perimeter.perimeterRegularPolygon(5, 6));
}
// Perimeter of Rectangle
@Test
void testcase3() {
Assertions.assertEquals(18.0, Perimeter.perimeterRectangle(4, 5));
}
@Test
void testcase4() {
Assertions.assertEquals(14.0, Perimeter.perimeterRectangle(4, 3));
}
// Circumference/Perimeter of a circle
@Test
void testcase5() {
Assertions.assertEquals(31.41592653589793, Perimeter.perimeterCircle(5));
}
@Test
void testcase6() {
Assertions.assertEquals(43.982297150257104, Perimeter.perimeterCircle(7));
}
// Perimeter of Irregular polygon
@Test
void testcase7() {
Assertions.assertEquals(12.0, Perimeter.perimeterIrregularPolygon(4, 5, 3));
}
@Test
void testcase8() {
Assertions.assertEquals(21.0, Perimeter.perimeterIrregularPolygon(3, 4, 5, 3, 6));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/ADTFractionTest.java | src/test/java/com/thealgorithms/maths/ADTFractionTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;
public class ADTFractionTest {
private final ADTFraction fraction1 = new ADTFraction(3, 5);
private final ADTFraction fraction2 = new ADTFraction(7, 8);
@Test
void testConstructorWithDenominatorEqualToZero() {
Exception exception = assertThrows(IllegalArgumentException.class, () -> new ADTFraction(1, 0));
assertEquals("Denominator cannot be 0", exception.getMessage());
}
@Test
public void testPlus() {
assertEquals(new ADTFraction(59, 40), fraction1.plus(fraction2));
}
@Test
public void testTimes() {
assertEquals(new ADTFraction(12, 5), fraction1.times(4));
assertEquals(new ADTFraction(21, 40), fraction1.times(fraction2));
}
@Test
public void testReciprocal() {
assertEquals(new ADTFraction(5, 3), fraction1.reciprocal());
}
@Test
public void testValue() {
assertEquals(0.6F, fraction1.value());
}
@Test
public void testEqualsAndHashCode() {
ADTFraction fraction3 = new ADTFraction(3, 5);
assertTrue(fraction1.equals(fraction3) && fraction3.equals(fraction1));
assertEquals(fraction1.hashCode(), fraction3.hashCode());
}
@Test
public void testToString() {
assertEquals("3/5", fraction1.toString());
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/ModeTest.java | src/test/java/com/thealgorithms/maths/ModeTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import java.util.stream.Stream;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
public class ModeTest {
@ParameterizedTest
@MethodSource("tcStream")
void basicTest(final int[] expected, final int[] numbers) {
assertArrayEquals(expected, Mode.mode(numbers));
}
private static Stream<Arguments> tcStream() {
return Stream.of(Arguments.of(null, new int[] {}), Arguments.of(new int[] {5}, new int[] {5}), Arguments.of(new int[] {1, 2, 3, 4, 5}, new int[] {1, 2, 3, 4, 5}), Arguments.of(new int[] {1, 2, 3, 4, 5}, new int[] {5, 4, 3, 2, 1}),
Arguments.of(new int[] {7}, new int[] {7, 9, 9, 4, 5, 6, 7, 7, 8}), Arguments.of(new int[] {7, 9}, new int[] {7, 9, 9, 4, 5, 6, 7, 7, 9}));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/FactorialTest.java | src/test/java/com/thealgorithms/maths/FactorialTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.Test;
public class FactorialTest {
private static final String EXCEPTION_MESSAGE = "Input number cannot be negative";
@Test
public void testWhenInvalidInoutProvidedShouldThrowException() {
IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> Factorial.factorial(-1));
assertEquals(exception.getMessage(), EXCEPTION_MESSAGE);
}
@Test
public void testCorrectFactorialCalculation() {
assertEquals(1, Factorial.factorial(0));
assertEquals(1, Factorial.factorial(1));
assertEquals(120, Factorial.factorial(5));
assertEquals(3628800, Factorial.factorial(10));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/NthUglyNumberTest.java | src/test/java/com/thealgorithms/maths/NthUglyNumberTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.HashMap;
import org.junit.jupiter.api.Test;
public class NthUglyNumberTest {
@Test
public void testGetWithNewObject() {
HashMap<Integer, Long> testCases = new HashMap<>();
testCases.put(0, 1L);
testCases.put(1, 2L);
testCases.put(2, 3L);
testCases.put(3, 4L);
testCases.put(4, 5L);
testCases.put(5, 6L);
testCases.put(9, 12L);
testCases.put(19, 36L);
testCases.put(52, 270L);
testCases.put(1078, 84934656L);
testCases.put(1963, 6973568802L);
for (final var tc : testCases.entrySet()) {
var uglyNumbers = new NthUglyNumber(new int[] {2, 3, 5});
assertEquals(uglyNumbers.get(tc.getKey()), tc.getValue());
var otherUglyNumbers = new NthUglyNumber(new int[] {5, 25, 6, 2, 3, 5});
assertEquals(otherUglyNumbers.get(tc.getKey()), tc.getValue());
}
}
@Test
public void testGetWithSameObject() {
HashMap<Integer, Long> testCases = new HashMap<>();
testCases.put(0, 1L);
testCases.put(1, 2L);
testCases.put(2, 3L);
testCases.put(3, 4L);
testCases.put(4, 5L);
testCases.put(5, 6L);
testCases.put(6, 7L);
testCases.put(1499, 1984500L);
testCases.put(1572, 2449440L);
testCases.put(1658, 3072000L);
testCases.put(6625, 4300800000L);
var uglyNumbers = new NthUglyNumber(new int[] {7, 2, 5, 3});
for (final var tc : testCases.entrySet()) {
assertEquals(uglyNumbers.get(tc.getKey()), tc.getValue());
}
assertEquals(uglyNumbers.get(999), 385875);
}
@Test
public void testGetWithBase1() {
var uglyNumbers = new NthUglyNumber(new int[] {1});
assertEquals(uglyNumbers.get(10), 1);
}
@Test
public void testGetWithBase2() {
var uglyNumbers = new NthUglyNumber(new int[] {2});
assertEquals(uglyNumbers.get(5), 32);
}
@Test
public void testGetThrowsAnErrorForNegativeInput() {
var uglyNumbers = new NthUglyNumber(new int[] {1, 2});
assertThrows(IllegalArgumentException.class, () -> uglyNumbers.get(-1));
}
@Test
public void testConstructorThrowsAnErrorForEmptyInput() {
assertThrows(IllegalArgumentException.class, () -> new NthUglyNumber(new int[] {}));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/FibonacciNumberCheckTest.java | src/test/java/com/thealgorithms/maths/FibonacciNumberCheckTest.java | package com.thealgorithms.maths;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
/**
* Fibonacci Sequence: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144...
*
* @author Albina Gimaletdinova on 01/07/2023
*/
public class FibonacciNumberCheckTest {
@Test
public void testNumberIsFibonacciNumber() {
Assertions.assertTrue(FibonacciNumberCheck.isFibonacciNumber(1));
Assertions.assertTrue(FibonacciNumberCheck.isFibonacciNumber(2));
Assertions.assertTrue(FibonacciNumberCheck.isFibonacciNumber(21));
Assertions.assertTrue(FibonacciNumberCheck.isFibonacciNumber(6765)); // 20th number
Assertions.assertTrue(FibonacciNumberCheck.isFibonacciNumber(832040)); // 30th number
Assertions.assertTrue(FibonacciNumberCheck.isFibonacciNumber(102334155)); // 40th number
Assertions.assertTrue(FibonacciNumberCheck.isFibonacciNumber(701408733)); // 45th number
}
@Test
public void testNumberIsNotFibonacciNumber() {
Assertions.assertFalse(FibonacciNumberCheck.isFibonacciNumber(9));
Assertions.assertFalse(FibonacciNumberCheck.isFibonacciNumber(10));
Assertions.assertFalse(FibonacciNumberCheck.isFibonacciNumber(145));
Assertions.assertFalse(FibonacciNumberCheck.isFibonacciNumber(701408734));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/SmithNumberTest.java | src/test/java/com/thealgorithms/maths/SmithNumberTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
class SmithNumberTest {
@ParameterizedTest
@CsvSource({"4", "22", "121", "562", "985", "4937775"})
void positiveSmithNumbersTest(int n) {
assertTrue(SmithNumber.isSmithNumber(n));
}
@ParameterizedTest
@CsvSource({"2", "11", "100", "550", "999", "1234557"})
void negativeSmithNumbersTest(int n) {
assertFalse(SmithNumber.isSmithNumber(n));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/AverageTest.java | src/test/java/com/thealgorithms/maths/AverageTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.stream.Stream;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
public class AverageTest {
private static final double SMALL_VALUE = 0.00001d;
@ParameterizedTest(name = "average({0}) should be approximately {1}")
@MethodSource("provideDoubleArrays")
void testAverageDouble(double[] numbers, double expected) {
assertEquals(expected, Average.average(numbers), SMALL_VALUE);
}
@ParameterizedTest(name = "average({0}) should be {1}")
@MethodSource("provideIntArrays")
void testAverageInt(int[] numbers, long expected) {
assertEquals(expected, Average.average(numbers));
}
@Test
void testAverageDoubleThrowsExceptionOnNullOrEmpty() {
assertThrows(IllegalArgumentException.class, () -> Average.average((double[]) null));
assertThrows(IllegalArgumentException.class, () -> Average.average(new double[0]));
}
@Test
void testAverageIntThrowsExceptionOnNullOrEmpty() {
assertThrows(IllegalArgumentException.class, () -> Average.average((int[]) null));
assertThrows(IllegalArgumentException.class, () -> Average.average(new int[0]));
}
private static Stream<Arguments> provideDoubleArrays() {
return Stream.of(Arguments.of(new double[] {3d, 6d, 9d, 12d, 15d, 18d, 21d}, 12d), Arguments.of(new double[] {5d, 10d, 15d, 20d, 25d, 30d, 35d}, 20d), Arguments.of(new double[] {1d, 2d, 3d, 4d, 5d, 6d, 7d, 8d}, 4.5d), Arguments.of(new double[] {0d, 0d, 0d}, 0d),
Arguments.of(new double[] {-1d, -2d, -3d}, -2d), Arguments.of(new double[] {1e-10, 1e-10, 1e-10}, 1e-10));
}
private static Stream<Arguments> provideIntArrays() {
return Stream.of(Arguments.of(new int[] {2, 4, 10}, 5L), Arguments.of(new int[] {0, 0, 0}, 0L), Arguments.of(new int[] {-1, -2, -3}, -2L), Arguments.of(new int[] {1, 1, 1, 1, 1}, 1L));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/SumOfOddNumbersTest.java | src/test/java/com/thealgorithms/maths/SumOfOddNumbersTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.stream.Stream;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
public class SumOfOddNumbersTest {
@ParameterizedTest
@MethodSource("inputStream")
void sumOfFirstNOddNumbersTests(int expected, int input) {
Assertions.assertEquals(expected, SumOfOddNumbers.sumOfFirstNOddNumbers(input));
}
private static Stream<Arguments> inputStream() {
return Stream.of(Arguments.of(1, 1), Arguments.of(4, 2), Arguments.of(9, 3), Arguments.of(16, 4), Arguments.of(25, 5), Arguments.of(100, 10));
}
@Test
public void testSumOfFirstNOddNumbersThrowsExceptionForNegativeInput() {
assertThrows(IllegalArgumentException.class, () -> SumOfOddNumbers.sumOfFirstNOddNumbers(-1));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/KaprekarNumbersTest.java | src/test/java/com/thealgorithms/maths/KaprekarNumbersTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Arrays;
import java.util.List;
import org.junit.jupiter.api.Test;
/**
* Test class for {@link KaprekarNumbers}.
* Tests various Kaprekar numbers and edge cases to ensure full coverage.
*/
class KaprekarNumbersTest {
@Test
void testZeroIsKaprekarNumber() {
assertTrue(KaprekarNumbers.isKaprekarNumber(0));
}
@Test
void testOneIsKaprekarNumber() {
assertTrue(KaprekarNumbers.isKaprekarNumber(1));
}
@Test
void testNineIsKaprekarNumber() {
// 9^2 = 81, 8 + 1 = 9
assertTrue(KaprekarNumbers.isKaprekarNumber(9));
}
@Test
void testFortyFiveIsKaprekarNumber() {
// 45^2 = 2025, 20 + 25 = 45
assertTrue(KaprekarNumbers.isKaprekarNumber(45));
}
@Test
void testFiftyFiveIsKaprekarNumber() {
// 55^2 = 3025, 30 + 25 = 55
assertTrue(KaprekarNumbers.isKaprekarNumber(55));
}
@Test
void testNinetyNineIsKaprekarNumber() {
// 99^2 = 9801, 98 + 01 = 99
assertTrue(KaprekarNumbers.isKaprekarNumber(99));
}
@Test
void testTwoNinetySevenIsKaprekarNumber() {
// 297^2 = 88209, 88 + 209 = 297
assertTrue(KaprekarNumbers.isKaprekarNumber(297));
}
@Test
void testSevenZeroThreeIsKaprekarNumber() {
// 703^2 = 494209, 494 + 209 = 703
assertTrue(KaprekarNumbers.isKaprekarNumber(703));
}
@Test
void testNineNineNineIsKaprekarNumber() {
// 999^2 = 998001, 998 + 001 = 999
assertTrue(KaprekarNumbers.isKaprekarNumber(999));
}
@Test
void testTwoTwoTwoThreeIsKaprekarNumber() {
// 2223^2 = 4941729, 4941 + 729 = 5670 (not directly obvious)
// Actually: 494 + 1729 = 2223
assertTrue(KaprekarNumbers.isKaprekarNumber(2223));
}
@Test
void testEightFiveSevenOneFortyThreeIsKaprekarNumber() {
assertTrue(KaprekarNumbers.isKaprekarNumber(857143));
}
@Test
void testTwoIsNotKaprekarNumber() {
assertFalse(KaprekarNumbers.isKaprekarNumber(2));
}
@Test
void testThreeIsNotKaprekarNumber() {
assertFalse(KaprekarNumbers.isKaprekarNumber(3));
}
@Test
void testTenIsNotKaprekarNumber() {
assertFalse(KaprekarNumbers.isKaprekarNumber(10));
}
@Test
void testTwentySixIsNotKaprekarNumber() {
assertFalse(KaprekarNumbers.isKaprekarNumber(26));
}
@Test
void testNinetyEightIsNotKaprekarNumber() {
assertFalse(KaprekarNumbers.isKaprekarNumber(98));
}
@Test
void testOneHundredIsNotKaprekarNumber() {
assertFalse(KaprekarNumbers.isKaprekarNumber(100));
}
@Test
void testNegativeNumberThrowsException() {
assertThrows(IllegalArgumentException.class, () -> KaprekarNumbers.isKaprekarNumber(-5));
}
@Test
void testKaprekarNumbersInSmallRange() {
List<Long> result = KaprekarNumbers.kaprekarNumberInRange(1, 10);
List<Long> expected = Arrays.asList(1L, 9L);
assertEquals(expected, result);
}
@Test
void testKaprekarNumbersInMediumRange() {
List<Long> result = KaprekarNumbers.kaprekarNumberInRange(1, 100);
List<Long> expected = Arrays.asList(1L, 9L, 45L, 55L, 99L);
assertEquals(expected, result);
}
@Test
void testKaprekarNumbersInLargeRange() {
List<Long> rangedNumbers = KaprekarNumbers.kaprekarNumberInRange(1, 100000);
List<Long> expectedNumbers = Arrays.asList(1L, 9L, 45L, 55L, 99L, 297L, 703L, 999L, 2223L, 2728L, 4950L, 5050L, 7272L, 7777L, 9999L, 17344L, 22222L, 77778L, 82656L, 95121L, 99999L);
assertEquals(expectedNumbers, rangedNumbers);
}
@Test
void testKaprekarNumbersInSingleElementRange() {
List<Long> result = KaprekarNumbers.kaprekarNumberInRange(9, 9);
List<Long> expected = Arrays.asList(9L);
assertEquals(expected, result);
}
@Test
void testKaprekarNumbersInRangeWithNoKaprekarNumbers() {
List<Long> result = KaprekarNumbers.kaprekarNumberInRange(2, 8);
assertTrue(result.isEmpty());
}
@Test
void testKaprekarNumbersInRangeStartingFromZero() {
List<Long> result = KaprekarNumbers.kaprekarNumberInRange(0, 5);
List<Long> expected = Arrays.asList(0L, 1L);
assertEquals(expected, result);
}
@Test
void testInvalidRangeThrowsException() {
assertThrows(IllegalArgumentException.class, () -> KaprekarNumbers.kaprekarNumberInRange(100, 50));
}
@Test
void testNegativeStartThrowsException() {
assertThrows(IllegalArgumentException.class, () -> KaprekarNumbers.kaprekarNumberInRange(-10, 100));
}
@Test
void testEmptyRange() {
List<Long> result = KaprekarNumbers.kaprekarNumberInRange(10, 44);
assertTrue(result.isEmpty());
}
@Test
void testLargeKaprekarNumber() {
// Test a larger known Kaprekar number
assertTrue(KaprekarNumbers.isKaprekarNumber(142857));
}
@Test
void testFourDigitKaprekarNumbers() {
// Test some 4-digit Kaprekar numbers
assertTrue(KaprekarNumbers.isKaprekarNumber(2728));
assertTrue(KaprekarNumbers.isKaprekarNumber(4950));
assertTrue(KaprekarNumbers.isKaprekarNumber(5050));
assertTrue(KaprekarNumbers.isKaprekarNumber(7272));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/MathBuilderTest.java | src/test/java/com/thealgorithms/maths/MathBuilderTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
class MathBuilderTest {
@Test
void simpleMath() {
double result = new MathBuilder.Builder(100).add(200).multiply(10).print().divideIf(20, (a, b) -> a % 2 == 0).sqrt().print().ceil().build().get();
assertEquals(13, result);
}
@Test
void memoryTest() {
long result = new MathBuilder.Builder().set(100).sqrt().remember().add(21).recallIf(a -> a < 50, true).mod(2).build().toLong();
assertEquals(0, result);
}
@Test
void freeFallDistance() {
long distance = new MathBuilder.Builder(9.81).multiply(0.5).multiply(5 * 5).round().build().toLong();
assertEquals(123, distance); // Expected result: 0.5 * 9.81 * 25 = 122.625 ≈ 123
}
@Test
void batchSalaryProcessing() {
double[] salaries = {2000, 3000, 4000, 5000};
long[] processedSalaries = new long[salaries.length];
for (int i = 0; i < salaries.length; i++) {
processedSalaries[i] = new MathBuilder.Builder(salaries[i]).addIf(salaries[i] * 0.1, (sal, bonus) -> sal > 2500).multiply(0.92).round().build().toLong();
}
long[] expectedSalaries = {1840, 3036, 4048, 5060};
assertArrayEquals(expectedSalaries, processedSalaries);
}
@Test
void parenthesis() {
// 10 + (20*5) - 40 + (100 / 10) = 80
double result = new MathBuilder.Builder(10).openParenthesis(20).multiply(5).closeParenthesisAndPlus().minus(40).openParenthesis(100).divide(10).closeParenthesisAndPlus().build().get();
assertEquals(80, result);
}
@Test
void areaOfCircle() {
// Radius is 4
double area = new MathBuilder.Builder().pi().openParenthesis(4).multiply(4).closeParenthesisAndMultiply().build().get();
assertEquals(Math.PI * 4 * 4, area);
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/VampireNumberTest.java | src/test/java/com/thealgorithms/maths/VampireNumberTest.java | package com.thealgorithms.maths;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
class VampireNumberTest {
@Test
void areVampireNumbers() {
Assertions.assertTrue(VampireNumber.isVampireNumber(15, 93, true));
Assertions.assertTrue(VampireNumber.isVampireNumber(135, 801, true));
Assertions.assertTrue(VampireNumber.isVampireNumber(201, 600, true));
}
@Test
void arePseudoVampireNumbers() {
Assertions.assertTrue(VampireNumber.isVampireNumber(150, 93, false));
Assertions.assertTrue(VampireNumber.isVampireNumber(546, 84, false));
Assertions.assertTrue(VampireNumber.isVampireNumber(641, 65, false));
}
@Test
void areNotVampireNumbers() {
Assertions.assertFalse(VampireNumber.isVampireNumber(51, 39, false));
Assertions.assertFalse(VampireNumber.isVampireNumber(51, 39, true));
}
@Test
void testSplitIntoSortedDigits() {
Assertions.assertEquals("123", VampireNumber.splitIntoSortedDigits(321));
Assertions.assertEquals("02234", VampireNumber.splitIntoSortedDigits(20, 324));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/HappyNumberTest.java | src/test/java/com/thealgorithms/maths/HappyNumberTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;
public class HappyNumberTest {
@Test
void testHappyNumbers() {
// Known happy numbers
assertTrue(HappyNumber.isHappy(1));
assertTrue(HappyNumber.isHappy(7));
assertTrue(HappyNumber.isHappy(19));
assertTrue(HappyNumber.isHappy(100));
}
@Test
void testUnhappyNumbers() {
// Known unhappy numbers
assertFalse(HappyNumber.isHappy(2));
assertFalse(HappyNumber.isHappy(4));
assertFalse(HappyNumber.isHappy(20));
}
@Test
void testLargeNumber() {
// Just to check behavior with larger input
assertTrue(HappyNumber.isHappy(1000000)); // reduces to 1 eventually
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/KaratsubaMultiplicationTest.java | src/test/java/com/thealgorithms/maths/KaratsubaMultiplicationTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.math.BigInteger;
import java.util.stream.Stream;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
/**
* Unit test class for {@link KaratsubaMultiplication} class.
*
* <p>
* This class tests various edge cases and normal cases for the
* Karatsuba multiplication algorithm implemented in the KaratsubaMultiplication class.
* It uses parameterized tests to handle multiple test cases.
* </p>
*/
class KaratsubaMultiplicationTest {
/**
* Provides test data for the parameterized test.
* Each entry in the stream contains three elements: x, y, and the expected result.
*
* @return a stream of arguments for the parameterized test
*/
static Stream<Arguments> provideTestCases() {
return Stream.of(
// Test case 1: Two small numbers
Arguments.of(new BigInteger("1234"), new BigInteger("5678"), new BigInteger("7006652")),
// Test case 2: Two large numbers
Arguments.of(new BigInteger("342364"), new BigInteger("393958"), new BigInteger("134877036712")),
// Test case 3: One number is zero
Arguments.of(BigInteger.ZERO, new BigInteger("5678"), BigInteger.ZERO),
// Test case 4: Both numbers are zero
Arguments.of(BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO),
// Test case 5: Single-digit numbers
Arguments.of(new BigInteger("9"), new BigInteger("8"), new BigInteger("72")));
}
/**
* Parameterized test for Karatsuba multiplication.
*
* <p>
* This method runs the Karatsuba multiplication algorithm for multiple test cases.
* </p>
*
* @param x the first number to multiply
* @param y the second number to multiply
* @param expected the expected result of x * y
*/
@ParameterizedTest
@MethodSource("provideTestCases")
void testKaratsubaMultiplication(BigInteger x, BigInteger y, BigInteger expected) {
assertEquals(expected, KaratsubaMultiplication.karatsuba(x, y));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/TestArmstrong.java | src/test/java/com/thealgorithms/maths/TestArmstrong.java | package com.thealgorithms.maths;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.jupiter.api.Test;
public class TestArmstrong {
@Test
public void testArmstrong() {
Armstrong armstrong = new Armstrong();
assertThat(armstrong.isArmstrong(371)).isTrue();
assertThat(armstrong.isArmstrong(200)).isFalse();
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/CrossCorrelationTest.java | src/test/java/com/thealgorithms/maths/CrossCorrelationTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
/**
* Test class for CrossCorrelation class
*
* @author Athina-Frederiki Swinkels
* @version 2.0
*/
public class CrossCorrelationTest {
@ParameterizedTest
@CsvSource({"1;2;1;1, 1;1;2;1, 1;4;6;6;5;2;1", "1;2;3, 1;2;3;4;5, 5;14;26;20;14;8;3", "1;2;3;4;5, 1;2;3, 3;8;14;20;26;14;5", "1.5;2.3;3.1;4.2, 1.1;2.2;3.3, 4.95;10.89;16.94;23.21;12.65;4.62"})
public void testCrossCorrelationParameterized(String input1, String input2, String expected) {
double[] array1 = convertStringToArray(input1);
double[] array2 = convertStringToArray(input2);
double[] expectedResult = convertStringToArray(expected);
double[] result = CrossCorrelation.crossCorrelation(array1, array2);
assertArrayEquals(expectedResult, result, 0.0001);
}
private double[] convertStringToArray(String input) {
String[] elements = input.split(";");
double[] result = new double[elements.length];
for (int i = 0; i < elements.length; i++) {
result[i] = Double.parseDouble(elements[i]);
}
return result;
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/AmicableNumberTest.java | src/test/java/com/thealgorithms/maths/AmicableNumberTest.java | package com.thealgorithms.maths;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.Set;
import org.apache.commons.lang3.tuple.Pair;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
public class AmicableNumberTest {
private static final String INVALID_RANGE_EXCEPTION_MESSAGE = "Given range of values is invalid!";
private static final String INVALID_NUMBERS_EXCEPTION_MESSAGE = "Input numbers must be natural!";
@Test
public void testShouldThrowExceptionWhenInvalidRangeProvided() {
checkInvalidRange(0, 0);
checkInvalidRange(0, 1);
checkInvalidRange(1, 0);
checkInvalidRange(10, -1);
checkInvalidRange(-1, 10);
}
@Test
public void testShouldThrowExceptionWhenInvalidNumbersProvided() {
checkInvalidNumbers(0, 0);
checkInvalidNumbers(0, 1);
checkInvalidNumbers(1, 0);
}
@Test
public void testAmicableNumbers() {
assertThat(AmicableNumber.isAmicableNumber(220, 284)).isTrue();
assertThat(AmicableNumber.isAmicableNumber(1184, 1210)).isTrue();
assertThat(AmicableNumber.isAmicableNumber(2620, 2924)).isTrue();
}
@Test
public void testShouldFindAllAmicableNumbersInRange() {
// given
var expectedResult = Set.of(Pair.of(220, 284), Pair.of(1184, 1210), Pair.of(2620, 2924));
// when
Set<Pair<Integer, Integer>> result = AmicableNumber.findAllInRange(1, 3000);
// then
Assertions.assertTrue(result.containsAll(expectedResult));
}
private static void checkInvalidRange(int from, int to) {
IllegalArgumentException exception = Assertions.assertThrows(IllegalArgumentException.class, () -> AmicableNumber.findAllInRange(from, to));
Assertions.assertEquals(exception.getMessage(), INVALID_RANGE_EXCEPTION_MESSAGE);
}
private static void checkInvalidNumbers(int a, int b) {
IllegalArgumentException exception = Assertions.assertThrows(IllegalArgumentException.class, () -> AmicableNumber.isAmicableNumber(a, b));
Assertions.assertEquals(exception.getMessage(), INVALID_NUMBERS_EXCEPTION_MESSAGE);
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/PronicNumberTest.java | src/test/java/com/thealgorithms/maths/PronicNumberTest.java | package com.thealgorithms.maths;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
public class PronicNumberTest {
@ParameterizedTest
@ValueSource(ints = {0, 2, 6, 12, 20, 30, 42, 110, 272, 380, 420, 1260, 2550})
void testForPronicNumber(final int number) {
Assertions.assertTrue(PronicNumber.isPronic(number));
Assertions.assertTrue(PronicNumber.isPronicNumber(number));
}
@ParameterizedTest
@ValueSource(ints = {1, 4, 21, 36, 150, 2500})
void testForNonPronicNumber(final int number) {
Assertions.assertFalse(PronicNumber.isPronic(number));
Assertions.assertFalse(PronicNumber.isPronicNumber(number));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/DeterminantOfMatrixTest.java | src/test/java/com/thealgorithms/maths/DeterminantOfMatrixTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
public class DeterminantOfMatrixTest {
@Test
public void testDeterminant2x2Matrix() {
int[][] matrix = {{1, 2}, {3, 4}};
int expected = -2;
assertEquals(expected, DeterminantOfMatrix.determinant(matrix, 2));
}
@Test
public void testDeterminant3x3Matrix() {
int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int expected = 0;
assertEquals(expected, DeterminantOfMatrix.determinant(matrix, 3));
}
@Test
public void testDeterminant3x3MatrixNonZero() {
int[][] matrix = {{1, 2, 3}, {0, 1, 4}, {5, 6, 0}};
int expected = 1;
assertEquals(expected, DeterminantOfMatrix.determinant(matrix, 3));
}
@Test
public void testDeterminant1x1Matrix() {
int[][] matrix = {{7}};
int expected = 7;
assertEquals(expected, DeterminantOfMatrix.determinant(matrix, 1));
}
@Test
public void testDeterminant4x4Matrix() {
int[][] matrix = {{1, 0, 0, 1}, {0, 1, 0, 0}, {0, 0, 1, 0}, {1, 0, 0, 1}};
int expected = 0;
assertEquals(expected, DeterminantOfMatrix.determinant(matrix, 4));
}
@Test
public void testDeterminant4x4MatrixZero() {
int[][] matrix = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}};
int expected = 0;
assertEquals(expected, DeterminantOfMatrix.determinant(matrix, 4));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/ChineseRemainderTheoremTest.java | src/test/java/com/thealgorithms/maths/ChineseRemainderTheoremTest.java | package com.thealgorithms.maths;
import static java.util.Collections.singletonList;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.Arrays;
import java.util.List;
import org.junit.jupiter.api.Test;
public class ChineseRemainderTheoremTest {
@Test
public void testCRTSimpleCase() {
List<Integer> remainders = Arrays.asList(2, 3, 2);
List<Integer> moduli = Arrays.asList(3, 5, 7);
int expected = 23;
int result = ChineseRemainderTheorem.solveCRT(remainders, moduli);
assertEquals(expected, result);
}
@Test
public void testCRTLargeModuli() {
List<Integer> remainders = Arrays.asList(1, 2, 3);
List<Integer> moduli = Arrays.asList(5, 7, 9);
int expected = 156;
int result = ChineseRemainderTheorem.solveCRT(remainders, moduli);
assertEquals(expected, result);
}
@Test
public void testCRTWithSingleCongruence() {
List<Integer> remainders = singletonList(4);
List<Integer> moduli = singletonList(7);
int expected = 4;
int result = ChineseRemainderTheorem.solveCRT(remainders, moduli);
assertEquals(expected, result);
}
@Test
public void testCRTWithMultipleSolutions() {
List<Integer> remainders = Arrays.asList(0, 3);
List<Integer> moduli = Arrays.asList(4, 5);
int expected = 8;
int result = ChineseRemainderTheorem.solveCRT(remainders, moduli);
assertEquals(expected, result);
}
@Test
public void testCRTLargeNumbers() {
List<Integer> remainders = Arrays.asList(0, 4, 6);
List<Integer> moduli = Arrays.asList(11, 13, 17);
int expected = 550;
int result = ChineseRemainderTheorem.solveCRT(remainders, moduli);
assertEquals(expected, result);
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/FibonacciJavaStreamsTest.java | src/test/java/com/thealgorithms/maths/FibonacciJavaStreamsTest.java | package com.thealgorithms.maths;
import java.math.BigDecimal;
import java.util.Optional;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
/**
* @author Albina Gimaletdinova on 25/07/2023
*/
public class FibonacciJavaStreamsTest {
private static final String EXCEPTION_MESSAGE = "Input index cannot be null or negative!";
@Test
public void testWithNegativeIndexShouldThrowException() {
Exception exception = Assertions.assertThrows(IllegalArgumentException.class, () -> FibonacciJavaStreams.calculate(new BigDecimal(-1)));
Assertions.assertEquals(EXCEPTION_MESSAGE, exception.getMessage());
}
@Test
public void testCheckTheFirst4SequenceElements() {
checkElement(BigDecimal.ZERO, BigDecimal.ZERO);
checkElement(BigDecimal.ONE, BigDecimal.ONE);
checkElement(BigDecimal.TWO, BigDecimal.ONE);
checkElement(new BigDecimal(3), BigDecimal.TWO);
}
@Test
public void testCheck10thSequenceElement() {
checkElement(BigDecimal.TEN, new BigDecimal(55));
}
@Test
public void testCheck20thSequenceElement() {
checkElement(new BigDecimal(20), new BigDecimal(6765));
}
@Test
public void testCheck30thSequenceElement() {
checkElement(new BigDecimal(30), new BigDecimal(832040));
}
@Test
public void testCheck40thSequenceElement() {
checkElement(new BigDecimal(40), new BigDecimal(102334155));
}
@Test
public void testCheck50thSequenceElement() {
checkElement(new BigDecimal(50), new BigDecimal(12586269025L));
}
@Test
public void testCheck100thSequenceElement() {
checkElement(new BigDecimal(100), new BigDecimal("354224848179261915075"));
}
@Test
public void testCheck200thSequenceElement() {
checkElement(new BigDecimal(200), new BigDecimal("280571172992510140037611932413038677189525"));
}
private static void checkElement(BigDecimal index, BigDecimal expected) {
// when
Optional<BigDecimal> result = FibonacciJavaStreams.calculate(index);
// then
Assertions.assertTrue(result.isPresent());
Assertions.assertEquals(result.get(), expected);
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/ExtendedEuclideanAlgorithmTest.java | src/test/java/com/thealgorithms/maths/ExtendedEuclideanAlgorithmTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
public class ExtendedEuclideanAlgorithmTest {
/**
* Verifies that the returned values satisfy Bézout's identity: a*x + b*y =
* gcd(a, b)
*/
private void verifyBezoutIdentity(long a, long b, long[] result) {
long gcd = result[0];
long x = result[1];
long y = result[2];
assertEquals(a * x + b * y, gcd, "Bézout's identity failed for gcd(" + a + ", " + b + ")");
}
@Test
public void testExtendedGCD() {
// Test case 1: General case gcd(30, 50) = 10
long[] result1 = ExtendedEuclideanAlgorithm.extendedGCD(30, 50);
assertEquals(10, result1[0], "Test Case 1 Failed: gcd(30, 50) should be 10");
verifyBezoutIdentity(30, 50, result1);
// Test case 2: Another general case gcd(240, 46) = 2
long[] result2 = ExtendedEuclideanAlgorithm.extendedGCD(240, 46);
assertEquals(2, result2[0], "Test Case 2 Failed: gcd(240, 46) should be 2");
verifyBezoutIdentity(240, 46, result2);
// Test case 3: Base case where b is 0, gcd(10, 0) = 10
long[] result3 = ExtendedEuclideanAlgorithm.extendedGCD(10, 0);
assertEquals(10, result3[0], "Test Case 3 Failed: gcd(10, 0) should be 10");
verifyBezoutIdentity(10, 0, result3);
// Test case 4: Numbers are co-prime gcd(17, 13) = 1
long[] result4 = ExtendedEuclideanAlgorithm.extendedGCD(17, 13);
assertEquals(1, result4[0], "Test Case 4 Failed: gcd(17, 13) should be 1");
verifyBezoutIdentity(17, 13, result4);
// Test case 5: One number is a multiple of the other gcd(100, 20) = 20
long[] result5 = ExtendedEuclideanAlgorithm.extendedGCD(100, 20);
assertEquals(20, result5[0], "Test Case 5 Failed: gcd(100, 20) should be 20");
verifyBezoutIdentity(100, 20, result5);
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/SolovayStrassenPrimalityTestTest.java | src/test/java/com/thealgorithms/maths/SolovayStrassenPrimalityTestTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
/**
* Unit tests for the {@link SolovayStrassenPrimalityTest} class.
* This class tests the functionality of the Solovay-Strassen primality test implementation.
*/
class SolovayStrassenPrimalityTestTest {
private static final int RANDOM_SEED = 123; // Seed for reproducibility
private SolovayStrassenPrimalityTest testInstance;
/**
* Sets up a new instance of {@link SolovayStrassenPrimalityTest}
* before each test case, using a fixed random seed for consistency.
*/
@BeforeEach
void setUp() {
testInstance = SolovayStrassenPrimalityTest.getSolovayStrassenPrimalityTest(RANDOM_SEED);
}
/**
* Provides test cases for prime numbers with various values of n and k (iterations).
*
* @return an array of objects containing pairs of n and k values
*/
static Object[][] primeNumbers() {
return new Object[][] {{2, 1}, {3, 1}, {5, 5}, {7, 10}, {11, 20}, {13, 10}, {17, 5}, {19, 1}};
}
/**
* Tests known prime numbers with various values of n and k (iterations).
*
* @param n the number to be tested for primality
* @param k the number of iterations to use in the primality test
*/
@ParameterizedTest
@MethodSource("primeNumbers")
void testPrimeNumbersWithDifferentNAndK(int n, int k) {
assertTrue(testInstance.solovayStrassen(n, k), n + " should be prime");
}
/**
* Provides test cases for composite numbers with various values of n and k (iterations).
*
* @return an array of objects containing pairs of n and k values
*/
static Object[][] compositeNumbers() {
return new Object[][] {{4, 1}, {6, 5}, {8, 10}, {9, 20}, {10, 1}, {12, 5}, {15, 10}};
}
/**
* Tests known composite numbers with various values of n and k (iterations).
*
* @param n the number to be tested for primality
* @param k the number of iterations to use in the primality test
*/
@ParameterizedTest
@MethodSource("compositeNumbers")
void testCompositeNumbersWithDifferentNAndK(int n, int k) {
assertFalse(testInstance.solovayStrassen(n, k), n + " should be composite");
}
/**
* Tests edge cases for the primality test.
* This includes negative numbers and small integers (0 and 1).
*/
@Test
void testEdgeCases() {
assertFalse(testInstance.solovayStrassen(-1, 10), "-1 should not be prime");
assertFalse(testInstance.solovayStrassen(0, 10), "0 should not be prime");
assertFalse(testInstance.solovayStrassen(1, 10), "1 should not be prime");
// Test small primes and composites
assertTrue(testInstance.solovayStrassen(2, 1), "2 is a prime number (single iteration)");
assertFalse(testInstance.solovayStrassen(9, 1), "9 is a composite number (single iteration)");
// Test larger primes and composites
long largePrime = 104729; // Known large prime number
long largeComposite = 104730; // Composite number (even)
assertTrue(testInstance.solovayStrassen(largePrime, 20), "104729 is a prime number");
assertFalse(testInstance.solovayStrassen(largeComposite, 20), "104730 is a composite number");
// Test very large numbers (may take longer)
long veryLargePrime = 512927357; // Known very large prime number
long veryLargeComposite = 512927358; // Composite number (even)
assertTrue(testInstance.solovayStrassen(veryLargePrime, 20), Long.MAX_VALUE - 1 + " is likely a prime number.");
assertFalse(testInstance.solovayStrassen(veryLargeComposite, 20), Long.MAX_VALUE + " is a composite number.");
}
/**
* Tests the Jacobi symbol calculation directly for known values.
* This verifies that the Jacobi symbol method behaves as expected.
*/
@Test
void testJacobiSymbolCalculation() {
// Jacobi symbol (a/n) where n is odd and positive
int jacobi1 = testInstance.calculateJacobi(6, 11); // Should return -1
int jacobi2 = testInstance.calculateJacobi(5, 11); // Should return +1
assertEquals(-1, jacobi1);
assertEquals(+1, jacobi2);
// Edge case: Jacobi symbol with even n or non-positive n
int jacobi4 = testInstance.calculateJacobi(5, -11); // Should return 0 (invalid)
int jacobi5 = testInstance.calculateJacobi(5, 0); // Should return 0 (invalid)
assertEquals(0, jacobi4);
assertEquals(0, jacobi5);
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/EvilNumberTest.java | src/test/java/com/thealgorithms/maths/EvilNumberTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
class EvilNumberTest {
@ParameterizedTest
@CsvSource({"0", "3", "10", "129", "222", "500", "777", "1198"})
void evilNumbersTest(int n) {
assertTrue(EvilNumber.isEvilNumber(n));
}
@ParameterizedTest
@CsvSource({"1", "7", "100", "333", "555", "1199"})
void odiousNumbersTest(int n) {
assertFalse(EvilNumber.isEvilNumber(n));
}
@ParameterizedTest
@CsvSource({"-1"})
void throwsNegativeNumbersNotAllowed(int n) {
assertThrows(IllegalArgumentException.class, () -> EvilNumber.isEvilNumber(n));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/CombinationsTest.java | src/test/java/com/thealgorithms/maths/CombinationsTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
public class CombinationsTest {
@Test
void testCombination() {
assertEquals(1, Combinations.combinations(1, 1));
assertEquals(252, Combinations.combinations(10, 5));
assertEquals(20, Combinations.combinations(6, 3));
assertEquals(15504, Combinations.combinations(20, 5));
}
@Test
void testCombinationOptimised() {
assertEquals(100, Combinations.combinationsOptimized(100, 1));
assertEquals(1, Combinations.combinationsOptimized(1, 1));
assertEquals(252, Combinations.combinationsOptimized(10, 5));
assertEquals(20, Combinations.combinationsOptimized(6, 3));
assertEquals(15504, Combinations.combinationsOptimized(20, 5));
assertEquals(2535650040L, Combinations.combinationsOptimized(200, 5));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/FastExponentiationTest.java | src/test/java/com/thealgorithms/maths/FastExponentiationTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.Test;
/**
* Unit tests for the {@link FastExponentiation} class.
*
* <p>This class contains various test cases to verify the correctness of the fastExponentiation method.
* It covers basic functionality, edge cases, and exceptional cases.
*/
class FastExponentiationTest {
/**
* Tests fast exponentiation with small numbers.
*/
@Test
void testSmallNumbers() {
assertEquals(1024, FastExponentiation.fastExponentiation(2, 10, 10000), "2^10 mod 10000 should be 1024");
assertEquals(81, FastExponentiation.fastExponentiation(3, 4, 1000), "3^4 mod 1000 should be 81");
}
/**
* Tests the behavior of the fast exponentiation method when using a modulus.
*/
@Test
void testWithModulo() {
assertEquals(24, FastExponentiation.fastExponentiation(2, 10, 1000), "2^10 mod 1000 should be 24");
assertEquals(0, FastExponentiation.fastExponentiation(10, 5, 10), "10^5 mod 10 should be 0");
}
/**
* Tests the edge cases where base or exponent is 0.
*/
@Test
void testBaseCases() {
assertEquals(1, FastExponentiation.fastExponentiation(2, 0, 1000), "Any number raised to the power 0 mod anything should be 1");
assertEquals(0, FastExponentiation.fastExponentiation(0, 10, 1000), "0 raised to any power should be 0");
assertEquals(1, FastExponentiation.fastExponentiation(0, 0, 1000), "0^0 is considered 0 in modular arithmetic.");
}
/**
* Tests fast exponentiation with a negative base to ensure correctness under modular arithmetic.
*/
@Test
void testNegativeBase() {
assertEquals(9765625, FastExponentiation.fastExponentiation(-5, 10, 1000000007), "-5^10 mod 1000000007 should be 9765625");
}
/**
* Tests that a negative exponent throws an ArithmeticException.
*/
@Test
void testNegativeExponent() {
assertThrows(ArithmeticException.class, () -> { FastExponentiation.fastExponentiation(2, -5, 1000); });
}
/**
* Tests that the method throws an IllegalArgumentException for invalid modulus values.
*/
@Test
void testInvalidModulus() {
assertThrows(IllegalArgumentException.class, () -> { FastExponentiation.fastExponentiation(2, 5, 0); });
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/SumOfSquaresTest.java | src/test/java/com/thealgorithms/maths/SumOfSquaresTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
/**
* Test class for SumOfSquares
*
* @author BEASTSHRIRAM
*/
class SumOfSquaresTest {
@Test
void testPerfectSquares() {
// Perfect squares should return 1
assertEquals(1, SumOfSquares.minSquares(1)); // 1^2
assertEquals(1, SumOfSquares.minSquares(4)); // 2^2
assertEquals(1, SumOfSquares.minSquares(9)); // 3^2
assertEquals(1, SumOfSquares.minSquares(16)); // 4^2
assertEquals(1, SumOfSquares.minSquares(25)); // 5^2
}
@Test
void testTwoSquares() {
// Numbers that can be expressed as sum of two squares
assertEquals(2, SumOfSquares.minSquares(2)); // 1^2 + 1^2
assertEquals(2, SumOfSquares.minSquares(5)); // 1^2 + 2^2
assertEquals(2, SumOfSquares.minSquares(8)); // 2^2 + 2^2
assertEquals(2, SumOfSquares.minSquares(10)); // 1^2 + 3^2
assertEquals(2, SumOfSquares.minSquares(13)); // 2^2 + 3^2
}
@Test
void testThreeSquares() {
// Numbers that require exactly three squares
assertEquals(3, SumOfSquares.minSquares(3)); // 1^2 + 1^2 + 1^2
assertEquals(3, SumOfSquares.minSquares(6)); // 1^2 + 1^2 + 2^2
assertEquals(3, SumOfSquares.minSquares(11)); // 1^2 + 1^2 + 3^2
assertEquals(3, SumOfSquares.minSquares(12)); // 2^2 + 2^2 + 2^2
assertEquals(3, SumOfSquares.minSquares(14)); // 1^2 + 2^2 + 3^2
}
@Test
void testFourSquares() {
// Numbers that require exactly four squares (form 4^a * (8b + 7))
assertEquals(4, SumOfSquares.minSquares(7)); // 1^2 + 1^2 + 1^2 + 2^2
assertEquals(4, SumOfSquares.minSquares(15)); // 1^2 + 1^2 + 2^2 + 3^2
assertEquals(4, SumOfSquares.minSquares(23)); // 1^2 + 1^2 + 3^2 + 3^2
assertEquals(4, SumOfSquares.minSquares(28)); // 4 * 7, so needs 4 squares
assertEquals(4, SumOfSquares.minSquares(31)); // 1^2 + 2^2 + 3^2 + 3^2
}
@Test
void testLargerNumbers() {
// Test some larger numbers
assertEquals(1, SumOfSquares.minSquares(100)); // 10^2
assertEquals(2, SumOfSquares.minSquares(65)); // 1^2 + 8^2
assertEquals(3, SumOfSquares.minSquares(19)); // 1^2 + 3^2 + 3^2
assertEquals(4, SumOfSquares.minSquares(60)); // 4 * 15, and 15 = 8*1 + 7
}
@Test
void testEdgeCases() {
// Test edge case
assertEquals(1, SumOfSquares.minSquares(0)); // 0^2
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/MedianTest.java | src/test/java/com/thealgorithms/maths/MedianTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.Test;
/**
* Test class for {@link Median}.
* Tests various scenarios including edge cases, odd/even length arrays,
* negative values, and unsorted inputs.
*/
class MedianTest {
@Test
void testMedianSingleValue() {
int[] arr = {0};
assertEquals(0, Median.median(arr));
}
@Test
void testMedianSinglePositiveValue() {
int[] arr = {42};
assertEquals(42, Median.median(arr));
}
@Test
void testMedianSingleNegativeValue() {
int[] arr = {-15};
assertEquals(-15, Median.median(arr));
}
@Test
void testMedianTwoValues() {
int[] arr = {1, 2};
assertEquals(1.5, Median.median(arr));
}
@Test
void testMedianTwoIdenticalValues() {
int[] arr = {5, 5};
assertEquals(5.0, Median.median(arr));
}
@Test
void testMedianThreeValues() {
int[] arr = {1, 2, 3};
assertEquals(2, Median.median(arr));
}
@Test
void testMedianThreeUnsortedValues() {
int[] arr = {3, 1, 2};
assertEquals(2, Median.median(arr));
}
@Test
void testMedianDecimalValueReturn() {
int[] arr = {1, 2, 3, 4, 5, 6, 8, 9};
assertEquals(4.5, Median.median(arr));
}
@Test
void testMedianNegativeValues() {
int[] arr = {-27, -16, -7, -4, -2, -1};
assertEquals(-5.5, Median.median(arr));
}
@Test
void testMedianMixedPositiveAndNegativeValues() {
int[] arr = {-10, -5, 0, 5, 10};
assertEquals(0, Median.median(arr));
}
@Test
void testMedianMixedUnsortedValues() {
int[] arr = {10, -5, 0, 5, -10};
assertEquals(0, Median.median(arr));
}
@Test
void testMedianLargeOddArray() {
int[] arr = {9, 7, 5, 3, 1, 2, 4, 6, 8};
assertEquals(5, Median.median(arr));
}
@Test
void testMedianLargeEvenArray() {
int[] arr = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
assertEquals(55.0, Median.median(arr));
}
@Test
void testMedianAllSameValues() {
int[] arr = {7, 7, 7, 7, 7};
assertEquals(7.0, Median.median(arr));
}
@Test
void testMedianWithZeros() {
int[] arr = {0, 0, 0, 0, 0};
assertEquals(0.0, Median.median(arr));
}
@Test
void testMedianAlreadySorted() {
int[] arr = {1, 2, 3, 4, 5};
assertEquals(3, Median.median(arr));
}
@Test
void testMedianReverseSorted() {
int[] arr = {5, 4, 3, 2, 1};
assertEquals(3, Median.median(arr));
}
@Test
void testMedianWithDuplicates() {
int[] arr = {1, 2, 2, 3, 3, 3, 4};
assertEquals(3, Median.median(arr));
}
@Test
void testMedianEmptyArrayThrows() {
int[] arr = {};
assertThrows(IllegalArgumentException.class, () -> Median.median(arr));
}
@Test
void testMedianNullArrayThrows() {
assertThrows(IllegalArgumentException.class, () -> Median.median(null));
}
@Test
void testMedianExtremeValues() {
int[] arr = {Integer.MAX_VALUE, Integer.MIN_VALUE};
assertEquals(-0.5, Median.median(arr));
}
@Test
void testMedianTwoNegativeValues() {
int[] arr = {-10, -20};
assertEquals(-15.0, Median.median(arr));
}
@Test
void testMedianFourValuesEven() {
int[] arr = {1, 2, 3, 4};
assertEquals(2.5, Median.median(arr));
}
@Test
void testMedianFiveValuesOdd() {
int[] arr = {10, 20, 30, 40, 50};
assertEquals(30.0, Median.median(arr));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/GenericRootTest.java | src/test/java/com/thealgorithms/maths/GenericRootTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.stream.Stream;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
public class GenericRootTest {
@ParameterizedTest
@MethodSource("tcStream")
public void testGenericRoot(final int input, final int expected) {
assertEquals(expected, GenericRoot.genericRoot(input));
}
@ParameterizedTest
@MethodSource("tcStream")
public void testGenericRootWithNegativeInputs(final int input, final int expected) {
assertEquals(expected, GenericRoot.genericRoot(-input));
}
private static Stream<Arguments> tcStream() {
return Stream.of(Arguments.of(0, 0), Arguments.of(1, 1), Arguments.of(12345, 6), Arguments.of(123, 6), Arguments.of(15937, 7), Arguments.of(222222, 3), Arguments.of(99999, 9));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/DigitalRootTest.java | src/test/java/com/thealgorithms/maths/DigitalRootTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
public class DigitalRootTest {
@Test
void testDigitalroot() {
assertEquals(4, DigitalRoot.digitalRoot(4));
assertEquals(9, DigitalRoot.digitalRoot(9));
assertEquals(4, DigitalRoot.digitalRoot(49));
assertEquals(6, DigitalRoot.digitalRoot(78));
assertEquals(4, DigitalRoot.digitalRoot(1228));
assertEquals(5, DigitalRoot.digitalRoot(71348));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/FindKthNumberTest.java | src/test/java/com/thealgorithms/maths/FindKthNumberTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.Arrays;
import java.util.Random;
import org.junit.jupiter.api.Test;
public class FindKthNumberTest {
@Test
public void testFindKthMaxTypicalCases() {
int[] array1 = {3, 2, 1, 4, 5};
assertEquals(3, FindKthNumber.findKthMax(array1, 3));
assertEquals(4, FindKthNumber.findKthMax(array1, 2));
assertEquals(5, FindKthNumber.findKthMax(array1, 1));
assertEquals(3, FindKthNumber.findKthMaxUsingHeap(array1, 3));
assertEquals(4, FindKthNumber.findKthMaxUsingHeap(array1, 2));
assertEquals(5, FindKthNumber.findKthMaxUsingHeap(array1, 1));
int[] array2 = {7, 5, 8, 2, 1, 6};
assertEquals(5, FindKthNumber.findKthMax(array2, 4));
assertEquals(6, FindKthNumber.findKthMax(array2, 3));
assertEquals(8, FindKthNumber.findKthMax(array2, 1));
assertEquals(5, FindKthNumber.findKthMaxUsingHeap(array2, 4));
assertEquals(6, FindKthNumber.findKthMaxUsingHeap(array2, 3));
assertEquals(8, FindKthNumber.findKthMaxUsingHeap(array2, 1));
}
@Test
public void testFindKthMaxEdgeCases() {
int[] array1 = {1};
assertEquals(1, FindKthNumber.findKthMax(array1, 1));
assertEquals(1, FindKthNumber.findKthMaxUsingHeap(array1, 1));
int[] array2 = {5, 3};
assertEquals(5, FindKthNumber.findKthMax(array2, 1));
assertEquals(3, FindKthNumber.findKthMax(array2, 2));
assertEquals(5, FindKthNumber.findKthMaxUsingHeap(array2, 1));
assertEquals(3, FindKthNumber.findKthMaxUsingHeap(array2, 2));
}
@Test
public void testFindKthMaxInvalidK() {
int[] array = {1, 2, 3, 4, 5};
assertThrows(IllegalArgumentException.class, () -> FindKthNumber.findKthMax(array, 0));
assertThrows(IllegalArgumentException.class, () -> FindKthNumber.findKthMax(array, 6));
assertThrows(IllegalArgumentException.class, () -> FindKthNumber.findKthMaxUsingHeap(array, 0));
assertThrows(IllegalArgumentException.class, () -> FindKthNumber.findKthMaxUsingHeap(array, 6));
}
@Test
public void testFindKthMaxLargeArray() {
int[] array = generateArray(1000);
int k = new Random().nextInt(1, array.length);
int result = FindKthNumber.findKthMax(array, k);
int maxK = FindKthNumber.findKthMaxUsingHeap(array, k);
Arrays.sort(array);
assertEquals(array[array.length - k], result);
assertEquals(array[array.length - k], maxK);
}
public static int[] generateArray(int capacity) {
int size = new Random().nextInt(2, capacity);
int[] array = new int[size];
for (int i = 0; i < size; i++) {
array[i] = new Random().nextInt(100); // Ensure positive values for testing
}
return array;
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/AbundantNumberTest.java | src/test/java/com/thealgorithms/maths/AbundantNumberTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
class AbundantNumberTest {
@ParameterizedTest
@CsvSource({"12", "66", "222", "444", "888", "2424"})
void abundantNumbersTest(int n) {
assertTrue(AbundantNumber.isAbundant(n));
assertTrue(AbundantNumber.isAbundantNumber(n));
}
@ParameterizedTest
@CsvSource({"1", "2", "6", "111", "333", "2222"})
void nonAbundantNumbersTest(int n) {
assertFalse(AbundantNumber.isAbundant(n));
assertFalse(AbundantNumber.isAbundantNumber(n));
}
@ParameterizedTest
@CsvSource({"0", "-1"})
void throwsNegativeNumbersNotAllowed(int n) {
assertThrows(IllegalArgumentException.class, () -> AbundantNumber.isAbundant(n));
assertThrows(IllegalArgumentException.class, () -> AbundantNumber.isAbundantNumber(n));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/KrishnamurthyNumberTest.java | src/test/java/com/thealgorithms/maths/KrishnamurthyNumberTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;
/**
* Unit tests for the {@link KrishnamurthyNumber} class.
*/
class KrishnamurthyNumberTest {
/**
* Test with known Krishnamurthy number 145.
* 1! + 4! + 5! = 1 + 24 + 120 = 145
*/
@Test
void testIsKrishnamurthyWith145() {
assertTrue(KrishnamurthyNumber.isKrishnamurthy(145));
}
/**
* Test with a number that is not a Krishnamurthy number.
*/
@Test
void testIsKrishnamurthyWithNonKrishnamurthyNumber() {
assertFalse(KrishnamurthyNumber.isKrishnamurthy(123));
}
/**
* Test with zero, which is not a Krishnamurthy number.
*/
@Test
void testIsKrishnamurthyWithZero() {
assertFalse(KrishnamurthyNumber.isKrishnamurthy(0));
}
/**
* Test with negative numbers, which cannot be Krishnamurthy numbers.
*/
@Test
void testIsKrishnamurthyWithNegativeNumbers() {
assertFalse(KrishnamurthyNumber.isKrishnamurthy(-1));
assertFalse(KrishnamurthyNumber.isKrishnamurthy(-145));
assertFalse(KrishnamurthyNumber.isKrishnamurthy(-100));
}
/**
* Test with single-digit Krishnamurthy numbers.
* 1! = 1 and 2! = 2, so both 1 and 2 are Krishnamurthy numbers.
*/
@Test
void testIsKrishnamurthyWithSingleDigitKrishnamurthyNumbers() {
assertTrue(KrishnamurthyNumber.isKrishnamurthy(1));
assertTrue(KrishnamurthyNumber.isKrishnamurthy(2));
}
/**
* Test with single-digit numbers that are not Krishnamurthy numbers.
*/
@Test
void testIsKrishnamurthyWithSingleDigitNonKrishnamurthyNumbers() {
assertFalse(KrishnamurthyNumber.isKrishnamurthy(3));
assertFalse(KrishnamurthyNumber.isKrishnamurthy(4));
assertFalse(KrishnamurthyNumber.isKrishnamurthy(5));
assertFalse(KrishnamurthyNumber.isKrishnamurthy(6));
assertFalse(KrishnamurthyNumber.isKrishnamurthy(7));
assertFalse(KrishnamurthyNumber.isKrishnamurthy(8));
assertFalse(KrishnamurthyNumber.isKrishnamurthy(9));
}
/**
* Test with the largest Krishnamurthy number: 40585.
* 4! + 0! + 5! + 8! + 5! = 24 + 1 + 120 + 40320 + 120 = 40585
*/
@Test
void testIsKrishnamurthyWithLargestKrishnamurthyNumber() {
assertTrue(KrishnamurthyNumber.isKrishnamurthy(40585));
}
/**
* Test with various non-Krishnamurthy numbers.
*/
@Test
void testIsKrishnamurthyWithVariousNonKrishnamurthyNumbers() {
assertFalse(KrishnamurthyNumber.isKrishnamurthy(10));
assertFalse(KrishnamurthyNumber.isKrishnamurthy(50));
assertFalse(KrishnamurthyNumber.isKrishnamurthy(100));
assertFalse(KrishnamurthyNumber.isKrishnamurthy(144));
assertFalse(KrishnamurthyNumber.isKrishnamurthy(146));
assertFalse(KrishnamurthyNumber.isKrishnamurthy(150));
assertFalse(KrishnamurthyNumber.isKrishnamurthy(200));
assertFalse(KrishnamurthyNumber.isKrishnamurthy(999));
assertFalse(KrishnamurthyNumber.isKrishnamurthy(1000));
assertFalse(KrishnamurthyNumber.isKrishnamurthy(40584));
assertFalse(KrishnamurthyNumber.isKrishnamurthy(40586));
}
/**
* Test with numbers close to known Krishnamurthy numbers.
*/
@Test
void testIsKrishnamurthyWithNumbersCloseToKrishnamurthy() {
assertFalse(KrishnamurthyNumber.isKrishnamurthy(144));
assertFalse(KrishnamurthyNumber.isKrishnamurthy(146));
assertFalse(KrishnamurthyNumber.isKrishnamurthy(40584));
assertFalse(KrishnamurthyNumber.isKrishnamurthy(40586));
}
/**
* Test with all known Krishnamurthy numbers in base 10.
*/
@Test
void testAllKnownKrishnamurthyNumbers() {
assertTrue(KrishnamurthyNumber.isKrishnamurthy(1));
assertTrue(KrishnamurthyNumber.isKrishnamurthy(2));
assertTrue(KrishnamurthyNumber.isKrishnamurthy(145));
assertTrue(KrishnamurthyNumber.isKrishnamurthy(40585));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/AutomorphicNumberTest.java | src/test/java/com/thealgorithms/maths/AutomorphicNumberTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;
public class AutomorphicNumberTest {
@Test
void testAutomorphicNumber() {
int[] trueTestCases = {0, 1, 25, 625, 12890625};
int[] falseTestCases = {-5, 2, 26, 1234};
for (Integer n : trueTestCases) {
assertTrue(AutomorphicNumber.isAutomorphic(n));
assertTrue(AutomorphicNumber.isAutomorphic2(n));
assertTrue(AutomorphicNumber.isAutomorphic3(String.valueOf(n)));
}
for (Integer n : falseTestCases) {
assertFalse(AutomorphicNumber.isAutomorphic(n));
assertFalse(AutomorphicNumber.isAutomorphic2(n));
assertFalse(AutomorphicNumber.isAutomorphic3(String.valueOf(n)));
}
assertTrue(AutomorphicNumber.isAutomorphic3("59918212890625")); // Special case for BigInteger
assertFalse(AutomorphicNumber.isAutomorphic3("12345678912345")); // Special case for BigInteger
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/HarshadNumberTest.java | src/test/java/com/thealgorithms/maths/HarshadNumberTest.java | package com.thealgorithms.maths;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
/**
* Test class for {@link HarshadNumber}.
* Tests various scenarios including positive cases, edge cases, and exception
* handling.
*/
class HarshadNumberTest {
@Test
void testValidHarshadNumbers() {
// Single digit Harshad numbers (all single digits except 0 are Harshad numbers)
Assertions.assertTrue(HarshadNumber.isHarshad(1));
Assertions.assertTrue(HarshadNumber.isHarshad(2));
Assertions.assertTrue(HarshadNumber.isHarshad(3));
Assertions.assertTrue(HarshadNumber.isHarshad(4));
Assertions.assertTrue(HarshadNumber.isHarshad(5));
Assertions.assertTrue(HarshadNumber.isHarshad(6));
Assertions.assertTrue(HarshadNumber.isHarshad(7));
Assertions.assertTrue(HarshadNumber.isHarshad(8));
Assertions.assertTrue(HarshadNumber.isHarshad(9));
// Two digit Harshad numbers
Assertions.assertTrue(HarshadNumber.isHarshad(10)); // 10 / (1 + 0) = 10
Assertions.assertTrue(HarshadNumber.isHarshad(12)); // 12 / (1 + 2) = 4
Assertions.assertTrue(HarshadNumber.isHarshad(18)); // 18 / (1 + 8) = 2
Assertions.assertTrue(HarshadNumber.isHarshad(20)); // 20 / (2 + 0) = 10
Assertions.assertTrue(HarshadNumber.isHarshad(21)); // 21 / (2 + 1) = 7
// Three digit Harshad numbers
Assertions.assertTrue(HarshadNumber.isHarshad(100)); // 100 / (1 + 0 + 0) = 100
Assertions.assertTrue(HarshadNumber.isHarshad(102)); // 102 / (1 + 0 + 2) = 34
Assertions.assertTrue(HarshadNumber.isHarshad(108)); // 108 / (1 + 0 + 8) = 12
// Large Harshad numbers
Assertions.assertTrue(HarshadNumber.isHarshad(1000)); // 1000 / (1 + 0 + 0 + 0) = 1000
Assertions.assertTrue(HarshadNumber.isHarshad(1002)); // 1002 / (1 + 0 + 0 + 2) = 334
Assertions.assertTrue(HarshadNumber.isHarshad(999999999)); // 999999999 / (9*9) = 12345679
}
@Test
void testInvalidHarshadNumbers() {
// Numbers that are not Harshad numbers
Assertions.assertFalse(HarshadNumber.isHarshad(11)); // 11 / (1 + 1) = 5.5
Assertions.assertFalse(HarshadNumber.isHarshad(13)); // 13 / (1 + 3) = 3.25
Assertions.assertFalse(HarshadNumber.isHarshad(17)); // 17 / (1 + 7) = 2.125
Assertions.assertFalse(HarshadNumber.isHarshad(19)); // 19 / (1 + 9) = 1.9
Assertions.assertFalse(HarshadNumber.isHarshad(23)); // 23 / (2 + 3) = 4.6
Assertions.assertFalse(HarshadNumber.isHarshad(101)); // 101 / (1 + 0 + 1) = 50.5
}
@Test
void testZeroThrowsException() {
Assertions.assertThrows(IllegalArgumentException.class, () -> HarshadNumber.isHarshad(0));
}
@Test
void testNegativeNumbersThrowException() {
Assertions.assertThrows(IllegalArgumentException.class, () -> HarshadNumber.isHarshad(-1));
Assertions.assertThrows(IllegalArgumentException.class, () -> HarshadNumber.isHarshad(-18));
Assertions.assertThrows(IllegalArgumentException.class, () -> HarshadNumber.isHarshad(-100));
}
@Test
void testValidHarshadNumbersWithString() {
// Single digit Harshad numbers
Assertions.assertTrue(HarshadNumber.isHarshad("1"));
Assertions.assertTrue(HarshadNumber.isHarshad("2"));
Assertions.assertTrue(HarshadNumber.isHarshad("9"));
// Two digit Harshad numbers
Assertions.assertTrue(HarshadNumber.isHarshad("10"));
Assertions.assertTrue(HarshadNumber.isHarshad("12"));
Assertions.assertTrue(HarshadNumber.isHarshad("18"));
// Large Harshad numbers
Assertions.assertTrue(HarshadNumber.isHarshad("1000"));
Assertions.assertTrue(HarshadNumber.isHarshad("999999999"));
Assertions.assertTrue(HarshadNumber.isHarshad("99999999999100"));
}
@Test
void testInvalidHarshadNumbersWithString() {
// Numbers that are not Harshad numbers
Assertions.assertFalse(HarshadNumber.isHarshad("11"));
Assertions.assertFalse(HarshadNumber.isHarshad("13"));
Assertions.assertFalse(HarshadNumber.isHarshad("19"));
Assertions.assertFalse(HarshadNumber.isHarshad("23"));
}
@Test
void testStringWithZeroThrowsException() {
Assertions.assertThrows(IllegalArgumentException.class, () -> HarshadNumber.isHarshad("0"));
}
@Test
void testStringWithNegativeNumbersThrowsException() {
Assertions.assertThrows(IllegalArgumentException.class, () -> HarshadNumber.isHarshad("-1"));
Assertions.assertThrows(IllegalArgumentException.class, () -> HarshadNumber.isHarshad("-18"));
Assertions.assertThrows(IllegalArgumentException.class, () -> HarshadNumber.isHarshad("-100"));
}
@Test
void testNullStringThrowsException() {
Assertions.assertThrows(IllegalArgumentException.class, () -> HarshadNumber.isHarshad(null));
}
@Test
void testEmptyStringThrowsException() {
Assertions.assertThrows(IllegalArgumentException.class, () -> HarshadNumber.isHarshad(""));
}
@Test
void testInvalidStringThrowsException() {
Assertions.assertThrows(IllegalArgumentException.class, () -> HarshadNumber.isHarshad("abc"));
Assertions.assertThrows(IllegalArgumentException.class, () -> HarshadNumber.isHarshad("12.5"));
Assertions.assertThrows(IllegalArgumentException.class, () -> HarshadNumber.isHarshad("12a"));
Assertions.assertThrows(IllegalArgumentException.class, () -> HarshadNumber.isHarshad(" 12 "));
}
@Test
void testMaxLongValue() {
// Test with a large number close to Long.MAX_VALUE
long largeHarshadCandidate = 9223372036854775800L;
// This specific number may or may not be Harshad, just testing it doesn't crash
try {
HarshadNumber.isHarshad(largeHarshadCandidate);
} catch (Exception e) {
Assertions.fail("Should not throw exception for valid large numbers");
}
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/ChebyshevIterationTest.java | src/test/java/com/thealgorithms/maths/ChebyshevIterationTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.Test;
public class ChebyshevIterationTest {
@Test
public void testSolveSimple2x2Diagonal() {
double[][] a = {{2, 0}, {0, 1}};
double[] b = {2, 2};
double[] x0 = {0, 0};
double minEig = 1.0;
double maxEig = 2.0;
int maxIter = 50;
double tol = 1e-9;
double[] expected = {1.0, 2.0};
double[] result = ChebyshevIteration.solve(a, b, x0, minEig, maxEig, maxIter, tol);
assertArrayEquals(expected, result, 1e-9);
}
@Test
public void testSolve2x2Symmetric() {
double[][] a = {{4, 1}, {1, 3}};
double[] b = {1, 2};
double[] x0 = {0, 0};
double minEig = (7.0 - Math.sqrt(5.0)) / 2.0;
double maxEig = (7.0 + Math.sqrt(5.0)) / 2.0;
int maxIter = 100;
double tol = 1e-10;
double[] expected = {1.0 / 11.0, 7.0 / 11.0};
double[] result = ChebyshevIteration.solve(a, b, x0, minEig, maxEig, maxIter, tol);
assertArrayEquals(expected, result, 1e-9);
}
@Test
public void testAlreadyAtSolution() {
double[][] a = {{2, 0}, {0, 1}};
double[] b = {2, 2};
double[] x0 = {1, 2};
double minEig = 1.0;
double maxEig = 2.0;
int maxIter = 10;
double tol = 1e-5;
double[] expected = {1.0, 2.0};
double[] result = ChebyshevIteration.solve(a, b, x0, minEig, maxEig, maxIter, tol);
assertArrayEquals(expected, result, 0.0);
}
@Test
public void testMismatchedDimensionsAB() {
double[][] a = {{1, 0}, {0, 1}};
double[] b = {1};
double[] x0 = {0, 0};
assertThrows(IllegalArgumentException.class, () -> ChebyshevIteration.solve(a, b, x0, 1, 2, 10, 1e-5));
}
@Test
public void testMismatchedDimensionsAX() {
double[][] a = {{1, 0}, {0, 1}};
double[] b = {1, 1};
double[] x0 = {0};
assertThrows(IllegalArgumentException.class, () -> ChebyshevIteration.solve(a, b, x0, 1, 2, 10, 1e-5));
}
@Test
public void testNonSquareMatrix() {
double[][] a = {{1, 0, 0}, {0, 1, 0}};
double[] b = {1, 1};
double[] x0 = {0, 0};
assertThrows(IllegalArgumentException.class, () -> ChebyshevIteration.solve(a, b, x0, 1, 2, 10, 1e-5));
}
@Test
public void testInvalidEigenvalues() {
double[][] a = {{1, 0}, {0, 1}};
double[] b = {1, 1};
double[] x0 = {0, 0};
assertThrows(IllegalArgumentException.class, () -> ChebyshevIteration.solve(a, b, x0, 2, 1, 10, 1e-5));
assertThrows(IllegalArgumentException.class, () -> ChebyshevIteration.solve(a, b, x0, 1, 1, 10, 1e-5));
}
@Test
public void testNonPositiveDefinite() {
double[][] a = {{1, 0}, {0, 1}};
double[] b = {1, 1};
double[] x0 = {0, 0};
assertThrows(IllegalArgumentException.class, () -> ChebyshevIteration.solve(a, b, x0, 0, 1, 10, 1e-5));
assertThrows(IllegalArgumentException.class, () -> ChebyshevIteration.solve(a, b, x0, -1, 1, 10, 1e-5));
}
@Test
public void testInvalidIterationCount() {
double[][] a = {{1, 0}, {0, 1}};
double[] b = {1, 1};
double[] x0 = {0, 0};
assertThrows(IllegalArgumentException.class, () -> ChebyshevIteration.solve(a, b, x0, 1, 2, 0, 1e-5));
assertThrows(IllegalArgumentException.class, () -> ChebyshevIteration.solve(a, b, x0, 1, 2, -1, 1e-5));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/CatalanNumbersTest.java | src/test/java/com/thealgorithms/maths/CatalanNumbersTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.stream.Stream;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
/**
* Test class for CatalanNumbers
*/
class CatalanNumbersTest {
/**
* Provides test data for the parameterized Catalan number test.
* Each array contains two elements:
* [input number, expected Catalan number for that input]
*/
static Stream<Object[]> catalanNumbersProvider() {
return Stream.of(new Object[] {0, 1}, new Object[] {1, 1}, new Object[] {2, 2}, new Object[] {3, 5}, new Object[] {4, 14}, new Object[] {5, 42}, new Object[] {6, 132}, new Object[] {7, 429}, new Object[] {8, 1430}, new Object[] {9, 4862}, new Object[] {10, 16796});
}
/**
* Parameterized test for checking the correctness of Catalan numbers.
* Uses the data from the provider method 'catalanNumbersProvider'.
*/
@ParameterizedTest
@MethodSource("catalanNumbersProvider")
void testCatalanNumbers(int input, int expected) {
assertEquals(expected, CatalanNumbers.catalan(input), () -> String.format("Catalan number for input %d should be %d", input, expected));
}
/**
* Test for invalid inputs which should throw an IllegalArgumentException.
*/
@Test
void testIllegalInput() {
assertThrows(IllegalArgumentException.class, () -> CatalanNumbers.catalan(-1));
assertThrows(IllegalArgumentException.class, () -> CatalanNumbers.catalan(-5));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/AreaTest.java | src/test/java/com/thealgorithms/maths/AreaTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertAll;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.Test;
/**
* @author Amarildo Aliaj
*/
class AreaTest {
@Test
void testSurfaceAreaCube() {
assertEquals(6.0, Area.surfaceAreaCube(1));
}
@Test
void testSurfaceAreaSphere() {
assertEquals(12.566370614359172, Area.surfaceAreaSphere(1));
}
@Test
void testSurfaceAreaRectangle() {
assertEquals(200.0, Area.surfaceAreaRectangle(10, 20));
}
@Test
void testSurfaceAreaCylinder() {
assertEquals(18.84955592153876, Area.surfaceAreaCylinder(1, 2));
}
@Test
void testSurfaceAreaSquare() {
assertEquals(100.0, Area.surfaceAreaSquare(10));
}
@Test
void testSurfaceAreaTriangle() {
assertEquals(50.0, Area.surfaceAreaTriangle(10, 10));
}
@Test
void testSurfaceAreaParallelogram() {
assertEquals(200.0, Area.surfaceAreaParallelogram(10, 20));
}
@Test
void testSurfaceAreaTrapezium() {
assertEquals(450.0, Area.surfaceAreaTrapezium(10, 20, 30));
}
@Test
void testSurfaceAreaCircle() {
assertEquals(1256.6370614359173, Area.surfaceAreaCircle(20));
}
@Test
void surfaceAreaHemisphere() {
assertEquals(235.61944901923448, Area.surfaceAreaHemisphere(5));
}
@Test
void surfaceAreaCone() {
assertEquals(301.59289474462014, Area.surfaceAreaCone(6, 8));
}
@Test
void testAllIllegalInput() {
assertAll(()
-> assertThrows(IllegalArgumentException.class, () -> Area.surfaceAreaCube(0)),
()
-> assertThrows(IllegalArgumentException.class, () -> Area.surfaceAreaSphere(0)),
()
-> assertThrows(IllegalArgumentException.class, () -> Area.surfaceAreaRectangle(0, 10)),
()
-> assertThrows(IllegalArgumentException.class, () -> Area.surfaceAreaRectangle(10, 0)),
()
-> assertThrows(IllegalArgumentException.class, () -> Area.surfaceAreaCylinder(0, 1)),
()
-> assertThrows(IllegalArgumentException.class, () -> Area.surfaceAreaCylinder(1, 0)),
()
-> assertThrows(IllegalArgumentException.class, () -> Area.surfaceAreaSquare(0)),
()
-> assertThrows(IllegalArgumentException.class, () -> Area.surfaceAreaTriangle(0, 1)),
()
-> assertThrows(IllegalArgumentException.class, () -> Area.surfaceAreaTriangle(1, 0)),
()
-> assertThrows(IllegalArgumentException.class, () -> Area.surfaceAreaParallelogram(0, 1)),
()
-> assertThrows(IllegalArgumentException.class, () -> Area.surfaceAreaParallelogram(1, 0)),
()
-> assertThrows(IllegalArgumentException.class, () -> Area.surfaceAreaTrapezium(0, 1, 1)),
()
-> assertThrows(IllegalArgumentException.class, () -> Area.surfaceAreaTrapezium(1, 0, 1)),
()
-> assertThrows(IllegalArgumentException.class, () -> Area.surfaceAreaTrapezium(1, 1, 0)),
()
-> assertThrows(IllegalArgumentException.class, () -> Area.surfaceAreaCircle(0)),
() -> assertThrows(IllegalArgumentException.class, () -> Area.surfaceAreaHemisphere(0)), () -> assertThrows(IllegalArgumentException.class, () -> Area.surfaceAreaCone(1, 0)), () -> assertThrows(IllegalArgumentException.class, () -> Area.surfaceAreaCone(0, 1)));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/FFTTest.java | src/test/java/com/thealgorithms/maths/FFTTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import java.util.ArrayList;
import org.junit.jupiter.api.Test;
class FFTTest {
// Testing the simple function getReal
@Test
void getRealtest() {
FFT.Complex complex = new FFT.Complex(1.0, 1.0);
assertEquals(1.0, complex.getReal());
}
// Testing the simple function getImaginary
@Test
void getImaginaryTest() {
FFT.Complex complex = new FFT.Complex();
assertEquals(0.0, complex.getImaginary());
}
// Testing the function add, assertEqual test
@Test
void addTest() {
FFT.Complex complex1 = new FFT.Complex(1.0, 1.0);
FFT.Complex complex2 = new FFT.Complex(2.0, 2.0);
double add = complex1.add(complex2).getReal();
assertEquals(3.0, add);
}
// Testing the function add, assertNotEqual test
@Test
void addFalseTest() {
FFT.Complex complex1 = new FFT.Complex(1.0, 1.0);
FFT.Complex complex2 = new FFT.Complex(2.0, 2.0);
double add = complex1.add(complex2).getReal();
assertNotEquals(2.0, add);
}
// Testing the function subtract, assertEqual test
@Test
void subtractTest() {
FFT.Complex complex1 = new FFT.Complex(2.0, 2.0);
FFT.Complex complex2 = new FFT.Complex(1.0, 1.0);
double sub = complex1.subtract(complex2).getReal();
assertEquals(1.0, sub);
}
// Testing the function multiply complex, assertEqual test
@Test
void multiplyWithComplexTest() {
FFT.Complex complex1 = new FFT.Complex(2.0, 2.0);
FFT.Complex complex2 = new FFT.Complex(1.0, 1.0);
double multiReal = complex1.multiply(complex2).getReal();
double multiImg = complex1.multiply(complex2).getImaginary();
assertEquals(0.0, multiReal);
assertEquals(4.0, multiImg);
}
// Testing the function multiply scalar, assertEqual test
@Test
void multiplyWithScalarTest() {
FFT.Complex complex1 = new FFT.Complex(2.0, 2.0);
double multiReal = complex1.multiply(2).getReal();
double multiImg = complex1.multiply(3).getImaginary();
assertEquals(4.0, multiReal);
assertEquals(6.0, multiImg);
}
// Testing the function conjugate, assertEqual test
@Test
void conjugateTest() {
FFT.Complex complex1 = new FFT.Complex(2.0, 2.0);
double conReal = complex1.conjugate().getReal();
double conImg = complex1.conjugate().getImaginary();
assertEquals(2.0, conReal);
assertEquals(-2.0, conImg);
}
// Testing the function abs, assertEqual test
@Test
void abs() {
FFT.Complex complex1 = new FFT.Complex(2.0, 3.0);
double abs = complex1.abs();
assertEquals(Math.sqrt(13), abs);
}
// Testing the function divide complex, assertEqual test.
@Test
void divideWithComplexTest() {
FFT.Complex complex1 = new FFT.Complex(2.0, 2.0);
FFT.Complex complex2 = new FFT.Complex(1.0, 2.0);
double divReal = complex1.divide(complex2).getReal();
double divImg = complex1.divide(complex2).getImaginary();
assertEquals(1.2, divReal);
assertEquals(-0.4, divImg);
}
// Testing the function divide scalar, assertEqual test.
@Test
void divideWithScalarTest() {
FFT.Complex complex1 = new FFT.Complex(2.0, 2.0);
double divReal = complex1.divide(2).getReal();
double divImg = complex1.divide(2).getImaginary();
assertEquals(1, divReal);
assertEquals(1, divImg);
}
// Testing the function fft, assertEqual test.
// https://scistatcalc.blogspot.com/2013/12/fft-calculator.html used this link to
// ensure the result
@Test
void fft() {
ArrayList<FFT.Complex> arr = new ArrayList<FFT.Complex>();
FFT.Complex complex1 = new FFT.Complex(2.0, 2.0);
FFT.Complex complex2 = new FFT.Complex(1.0, 3.0);
FFT.Complex complex3 = new FFT.Complex(3.0, 1.0);
FFT.Complex complex4 = new FFT.Complex(2.0, 2.0);
arr.add(complex1);
arr.add(complex2);
arr.add(complex3);
arr.add(complex4);
arr = FFT.fft(arr, false);
double realV1 = arr.get(0).getReal();
double realV2 = arr.get(2).getReal();
double imgV1 = arr.get(0).getImaginary();
double imgV2 = arr.get(2).getImaginary();
assertEquals(8.0, realV1);
assertEquals(2.0, realV2);
assertEquals(8.0, imgV1);
assertEquals(-2.0, imgV2);
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/StandardScoreTest.java | src/test/java/com/thealgorithms/maths/StandardScoreTest.java | package com.thealgorithms.maths;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
public class StandardScoreTest {
@Test
void test1() {
Assertions.assertEquals(StandardScore.zScore(2, 0, 5), 0.4);
}
@Test
void test2() {
Assertions.assertEquals(StandardScore.zScore(1, 1, 1), 0.0);
}
@Test
void test3() {
Assertions.assertEquals(StandardScore.zScore(2.5, 1.8, 0.7), 1.0);
}
@Test
void test4() {
Assertions.assertEquals(StandardScore.zScore(8.9, 3, 4.2), 1.4047619047619049);
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/MinValueTest.java | src/test/java/com/thealgorithms/maths/MinValueTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
public class MinValueTest {
@Test
public void minTest() {
assertEquals(-1, MinValue.min(-1, 3));
assertEquals(2, MinValue.min(3, 2));
assertEquals(5, MinValue.min(5, 5));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/DistanceFormulaTest.java | src/test/java/com/thealgorithms/maths/DistanceFormulaTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
public class DistanceFormulaTest {
@Test
void euclideanTest1() {
Assertions.assertEquals(DistanceFormula.euclideanDistance(1, 1, 2, 2), 1.4142135623730951);
}
@Test
void euclideanTest2() {
Assertions.assertEquals(DistanceFormula.euclideanDistance(1, 3, 8, 0), 7.0710678118654755);
}
@Test
void euclideanTest3() {
Assertions.assertEquals(DistanceFormula.euclideanDistance(2.4, 9.1, 55.1, 100), 110.91911467371168);
}
@Test
void euclideanTest4() {
Assertions.assertEquals(DistanceFormula.euclideanDistance(1000, 13, 20000, 84), 19022.067605809836);
}
@Test
public void manhattantest1() {
assertEquals(DistanceFormula.manhattanDistance(1, 2, 3, 4), 4);
}
@Test
public void manhattantest2() {
assertEquals(DistanceFormula.manhattanDistance(6.5, 8.4, 20.1, 13.6), 18.8);
}
@Test
public void manhattanTest3() {
assertEquals(DistanceFormula.manhattanDistance(10.112, 50, 8, 25.67), 26.442);
}
@Test
public void hammingTest1() {
int[] array1 = {1, 1, 1, 1};
int[] array2 = {0, 0, 0, 0};
assertEquals(DistanceFormula.hammingDistance(array1, array2), 4);
}
@Test
public void hammingTest2() {
int[] array1 = {1, 1, 1, 1};
int[] array2 = {1, 1, 1, 1};
assertEquals(DistanceFormula.hammingDistance(array1, array2), 0);
}
@Test
public void hammingTest3() {
int[] array1 = {1, 0, 0, 1, 1, 0, 1, 1, 0};
int[] array2 = {0, 1, 0, 0, 1, 1, 1, 0, 0};
assertEquals(DistanceFormula.hammingDistance(array1, array2), 5);
}
@Test
public void minkowskiTest1() {
double[] array1 = {1, 3, 8, 5};
double[] array2 = {4, 2, 6, 9};
assertEquals(DistanceFormula.minkowskiDistance(array1, array2, 1), 10);
}
@Test
public void minkowskiTest2() {
double[] array1 = {1, 3, 8, 5};
double[] array2 = {4, 2, 6, 9};
assertEquals(DistanceFormula.minkowskiDistance(array1, array2, 2), 5.477225575051661);
}
@Test
public void minkowskiTest3() {
double[] array1 = {1, 3, 8, 5};
double[] array2 = {4, 2, 6, 9};
assertEquals(DistanceFormula.minkowskiDistance(array1, array2, 3), 4.641588833612778);
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/FibonacciLoopTest.java | src/test/java/com/thealgorithms/maths/FibonacciLoopTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.math.BigInteger;
import org.junit.jupiter.api.Test;
public class FibonacciLoopTest {
@Test
public void checkValueAtZero() {
assertEquals(BigInteger.ZERO, FibonacciLoop.compute(0));
}
@Test
public void checkValueAtOne() {
assertEquals(BigInteger.ONE, FibonacciLoop.compute(1));
}
@Test
public void checkValueAtTwo() {
assertEquals(BigInteger.ONE, FibonacciLoop.compute(2));
}
@Test
public void checkRecurrenceRelation() {
for (int i = 0; i < 100; ++i) {
assertEquals(FibonacciLoop.compute(i + 2), FibonacciLoop.compute(i + 1).add(FibonacciLoop.compute(i)));
}
}
@Test
public void checkNegativeInput() {
assertThrows(IllegalArgumentException.class, () -> { FibonacciLoop.compute(-1); });
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/PowTest.java | src/test/java/com/thealgorithms/maths/PowTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
public class PowTest {
@ParameterizedTest
@CsvSource({"2, 0, 1", "0, 2, 0", "2, 10, 1024", "10, 2, 100", "5, 3, 125", "3, 4, 81"})
void testPow(int base, int exponent, long expected) {
assertEquals(expected, Pow.pow(base, exponent), "Failed for base: " + base + " and exponent: " + exponent);
}
@Test
void testPowThrowsExceptionForNegativeExponent() {
assertThrows(IllegalArgumentException.class, () -> Pow.pow(2, -1));
}
@Test
void testPowHandlesLargeNumbers() {
assertEquals(1048576, Pow.pow(2, 20));
}
@Test
void testPowHandlesZeroBase() {
assertEquals(0, Pow.pow(0, 5));
}
@Test
void testPowHandlesOneBase() {
assertEquals(1, Pow.pow(1, 100));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/JosephusProblemTest.java | src/test/java/com/thealgorithms/maths/JosephusProblemTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
public class JosephusProblemTest {
@Test
void testJosephusProblem() {
assertEquals(3, JosephusProblem.findTheWinner(5, 2));
assertEquals(5, JosephusProblem.findTheWinner(6, 4));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/LongDivisionTest.java | src/test/java/com/thealgorithms/maths/LongDivisionTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
public class LongDivisionTest {
// Requirement: Dividend (positive) is greater than divisor (positive), returns correct integer
// after division
@Test
void testOne() {
assertEquals(3, LongDivision.divide(10, 3));
}
// Requirement: Dividend (positive) is greater than divisor (negative), returns correct integer
// after division
@Test
void testTwo() {
assertEquals(-2, LongDivision.divide(7, -3));
}
// Requirement: Dividend (positive) is greater than divisor (negative), returns correct integer
// after division Basically the same as in the first test
@Test
void testThree() {
assertEquals(10, LongDivision.divide(105, 10));
}
// Requirement: Dividend (negative), divisor (positive), returns correct integer after division
// Tests the case where the dividend is less than 0.
@Test
void testNegativeDividend() {
assertEquals(-1, LongDivision.divide(-5, 3));
}
// Requirement: Dividend (positive), divisor (positive), returns correct integer after division
// Tests the case where the dividend is less than the divisor. The test should return 0 in this
// case.
@Test
void testDividendLessThanDivisor() {
assertEquals(0, LongDivision.divide(3, 5));
}
// Requirement: Dividend (neither), divisor (positive), returns correct integer after division
// Tests the case where the dividend is 0. This should return a 0.
@Test
void testDividendIsZero() {
assertEquals(0, LongDivision.divide(0, 5));
}
// Requirement: Dividend (positive), divisor (neither), returns correct integer after division
// Tests the case where the divisor is 0. This should return a 0.
@Test
void testDivisionByZero() {
assertEquals(0, LongDivision.divide(5, 0));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/LucasSeriesTest.java | src/test/java/com/thealgorithms/maths/LucasSeriesTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.Test;
/**
* Test cases for {@link LucasSeries} class.
* Tests both recursive and iterative implementations for correctness,
* edge cases, and error handling.
*/
class LucasSeriesTest {
/**
* Test the first Lucas number L(1) = 2
*/
@Test
void testFirstLucasNumber() {
assertEquals(2, LucasSeries.lucasSeries(1));
assertEquals(2, LucasSeries.lucasSeriesIteration(1));
}
/**
* Test the second Lucas number L(2) = 1
*/
@Test
void testSecondLucasNumber() {
assertEquals(1, LucasSeries.lucasSeries(2));
assertEquals(1, LucasSeries.lucasSeriesIteration(2));
}
/**
* Test the third Lucas number L(3) = 3
*/
@Test
void testThirdLucasNumber() {
assertEquals(3, LucasSeries.lucasSeries(3));
assertEquals(3, LucasSeries.lucasSeriesIteration(3));
}
/**
* Test the fourth Lucas number L(4) = 4
*/
@Test
void testFourthLucasNumber() {
assertEquals(4, LucasSeries.lucasSeries(4));
assertEquals(4, LucasSeries.lucasSeriesIteration(4));
}
/**
* Test the fifth Lucas number L(5) = 7
*/
@Test
void testFifthLucasNumber() {
assertEquals(7, LucasSeries.lucasSeries(5));
assertEquals(7, LucasSeries.lucasSeriesIteration(5));
}
/**
* Test the sixth Lucas number L(6) = 11
*/
@Test
void testSixthLucasNumber() {
assertEquals(11, LucasSeries.lucasSeries(6));
assertEquals(11, LucasSeries.lucasSeriesIteration(6));
}
/**
* Test the seventh Lucas number L(7) = 18
*/
@Test
void testSeventhLucasNumber() {
assertEquals(18, LucasSeries.lucasSeries(7));
assertEquals(18, LucasSeries.lucasSeriesIteration(7));
}
/**
* Test the eighth Lucas number L(8) = 29
*/
@Test
void testEighthLucasNumber() {
assertEquals(29, LucasSeries.lucasSeries(8));
assertEquals(29, LucasSeries.lucasSeriesIteration(8));
}
/**
* Test the ninth Lucas number L(9) = 47
*/
@Test
void testNinthLucasNumber() {
assertEquals(47, LucasSeries.lucasSeries(9));
assertEquals(47, LucasSeries.lucasSeriesIteration(9));
}
/**
* Test the tenth Lucas number L(10) = 76
*/
@Test
void testTenthLucasNumber() {
assertEquals(76, LucasSeries.lucasSeries(10));
assertEquals(76, LucasSeries.lucasSeriesIteration(10));
}
/**
* Test the eleventh Lucas number L(11) = 123
*/
@Test
void testEleventhLucasNumber() {
assertEquals(123, LucasSeries.lucasSeries(11));
assertEquals(123, LucasSeries.lucasSeriesIteration(11));
}
/**
* Test larger Lucas numbers to ensure correctness
*/
@Test
void testLargerLucasNumbers() {
assertEquals(199, LucasSeries.lucasSeries(12));
assertEquals(199, LucasSeries.lucasSeriesIteration(12));
assertEquals(322, LucasSeries.lucasSeries(13));
assertEquals(322, LucasSeries.lucasSeriesIteration(13));
assertEquals(521, LucasSeries.lucasSeries(14));
assertEquals(521, LucasSeries.lucasSeriesIteration(14));
assertEquals(843, LucasSeries.lucasSeries(15));
assertEquals(843, LucasSeries.lucasSeriesIteration(15));
}
/**
* Test that both methods produce the same results
*/
@Test
void testRecursiveAndIterativeConsistency() {
for (int i = 1; i <= 15; i++) {
assertEquals(LucasSeries.lucasSeries(i), LucasSeries.lucasSeriesIteration(i), "Mismatch at position " + i);
}
}
/**
* Test invalid input: zero
*/
@Test
void testZeroInputThrowsException() {
assertThrows(IllegalArgumentException.class, () -> LucasSeries.lucasSeries(0));
assertThrows(IllegalArgumentException.class, () -> LucasSeries.lucasSeriesIteration(0));
}
/**
* Test invalid input: negative number
*/
@Test
void testNegativeInputThrowsException() {
assertThrows(IllegalArgumentException.class, () -> LucasSeries.lucasSeries(-1));
assertThrows(IllegalArgumentException.class, () -> LucasSeries.lucasSeriesIteration(-1));
assertThrows(IllegalArgumentException.class, () -> LucasSeries.lucasSeries(-5));
assertThrows(IllegalArgumentException.class, () -> LucasSeries.lucasSeriesIteration(-5));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/GaussianTest.java | src/test/java/com/thealgorithms/maths/GaussianTest.java | package com.thealgorithms.maths;
import static com.thealgorithms.maths.Gaussian.gaussian;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.ArrayList;
import org.junit.jupiter.api.Test;
public class GaussianTest {
// easy pass test for the whole class. Matrix of 2*3.
@Test
void passTest1() {
ArrayList<Double> list = new ArrayList<Double>();
ArrayList<Double> answer = new ArrayList<Double>();
answer.add(0.0);
answer.add(1.0);
int matrixSize = 2;
list.add(1.0);
list.add(1.0);
list.add(1.0);
list.add(2.0);
list.add(1.0);
list.add(1.0);
assertEquals(answer, gaussian(matrixSize, list));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/NonRepeatingElementTest.java | src/test/java/com/thealgorithms/maths/NonRepeatingElementTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import java.util.stream.Stream;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
public class NonRepeatingElementTest {
private record TestData(int[] input, int[] expected) {
}
private static Stream<TestData> provideTestCases() {
return Stream.of(new TestData(new int[] {1, 2, 1, 3, 2, 4}, new int[] {3, 4}), new TestData(new int[] {-1, -2, -1, -3, -2, -4}, new int[] {-3, -4}), new TestData(new int[] {-1, 2, 2, -3, -1, 4}, new int[] {-3, 4}));
}
@ParameterizedTest
@MethodSource("provideTestCases")
void testFindNonRepeatingElements(TestData testData) {
int[] result = NonRepeatingElement.findNonRepeatingElements(testData.input);
assertArrayEquals(testData.expected, result);
}
@Test
public void testFindNonRepeatingElementsWithLargeNumbers() {
assertArrayEquals(new int[] {200000, 400000}, NonRepeatingElement.findNonRepeatingElements(new int[] {100000, 200000, 100000, 300000, 400000, 300000}));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/SieveOfEratosthenesTest.java | src/test/java/com/thealgorithms/maths/SieveOfEratosthenesTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Arrays;
import java.util.List;
import org.junit.jupiter.api.Test;
/**
* Test cases for Sieve of Eratosthenes algorithm
*
* @author Navadeep0007
*/
class SieveOfEratosthenesTest {
@Test
void testPrimesUpTo10() {
List<Integer> expected = Arrays.asList(2, 3, 5, 7);
assertEquals(expected, SieveOfEratosthenes.findPrimes(10));
}
@Test
void testPrimesUpTo30() {
List<Integer> expected = Arrays.asList(2, 3, 5, 7, 11, 13, 17, 19, 23, 29);
assertEquals(expected, SieveOfEratosthenes.findPrimes(30));
}
@Test
void testPrimesUpTo2() {
List<Integer> expected = Arrays.asList(2);
assertEquals(expected, SieveOfEratosthenes.findPrimes(2));
}
@Test
void testPrimesUpTo1() {
assertTrue(SieveOfEratosthenes.findPrimes(1).isEmpty());
}
@Test
void testPrimesUpTo0() {
assertTrue(SieveOfEratosthenes.findPrimes(0).isEmpty());
}
@Test
void testNegativeInput() {
assertThrows(IllegalArgumentException.class, () -> { SieveOfEratosthenes.findPrimes(-1); });
}
@Test
void testCountPrimes() {
assertEquals(4, SieveOfEratosthenes.countPrimes(10));
assertEquals(25, SieveOfEratosthenes.countPrimes(100));
}
@Test
void testLargeNumber() {
List<Integer> primes = SieveOfEratosthenes.findPrimes(1000);
assertEquals(168, primes.size()); // There are 168 primes up to 1000
assertEquals(2, primes.get(0)); // First prime
assertEquals(997, primes.get(primes.size() - 1)); // Last prime up to 1000
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/SquareRootWithNewtonRaphsonTestMethod.java | src/test/java/com/thealgorithms/maths/SquareRootWithNewtonRaphsonTestMethod.java | package com.thealgorithms.maths;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
public class SquareRootWithNewtonRaphsonTestMethod {
@Test
void testfor1() {
Assertions.assertEquals(1, SquareRootWithNewtonRaphsonMethod.squareRoot(1));
}
@Test
void testfor2() {
Assertions.assertEquals(1.414213562373095, SquareRootWithNewtonRaphsonMethod.squareRoot(2));
}
@Test
void testfor625() {
Assertions.assertEquals(25.0, SquareRootWithNewtonRaphsonMethod.squareRoot(625));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/ZellersCongruenceTest.java | src/test/java/com/thealgorithms/maths/ZellersCongruenceTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.stream.Stream;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
class ZellersCongruenceTest {
static Stream<Arguments> validDates() {
return Stream.of(Arguments.of("01-01-2000", "Saturday"), Arguments.of("12-25-2021", "Saturday"), Arguments.of("07-04-1776", "Thursday"), Arguments.of("02-29-2020", "Saturday"), Arguments.of("03-01-1900", "Thursday"), Arguments.of("03/01/1900", "Thursday"));
}
static Stream<Arguments> invalidDates() {
return Stream.of(Arguments.of("13-01-2000", "Month must be between 1 and 12."), Arguments.of("02-30-2020", "Invalid date."), Arguments.of("00-15-2020", "Month must be between 1 and 12."), Arguments.of("01-01-0000", "Year must be between 46 and 8499."),
Arguments.of("01/01/200", "Input date must be 10 characters long in the format MM-DD-YYYY or MM/DD/YYYY."), Arguments.of("01@01>2000", "Date separator must be '-' or '/'."), Arguments.of("aa-01-1900", "Invalid numeric part: aa"),
Arguments.of(null, "Input date must be 10 characters long in the format MM-DD-YYYY or MM/DD/YYYY."));
}
@ParameterizedTest
@MethodSource("validDates")
void testValidDates(String inputDate, String expectedDay) {
String result = ZellersCongruence.calculateDay(inputDate);
assertEquals("The date " + inputDate + " falls on a " + expectedDay + ".", result);
}
@ParameterizedTest
@MethodSource("invalidDates")
void testInvalidDates(String inputDate, String expectedErrorMessage) {
Exception exception = assertThrows(IllegalArgumentException.class, () -> ZellersCongruence.calculateDay(inputDate));
assertEquals(expectedErrorMessage, exception.getMessage());
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/PowerUsingRecursionTest.java | src/test/java/com/thealgorithms/maths/PowerUsingRecursionTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
/**
* Test case for Power using Recursion
* @author Bama Charan Chhandogi (https://github.com/BamaCharanChhandogi)
*/
class PowerUsingRecursionTest {
@Test
void testPowerUsingRecursion() {
assertEquals(32.0, PowerUsingRecursion.power(2.0, 5));
assertEquals(97.65625, PowerUsingRecursion.power(2.5, 5));
assertEquals(81, PowerUsingRecursion.power(3, 4));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/FastInverseSqrtTests.java | src/test/java/com/thealgorithms/maths/FastInverseSqrtTests.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertFalse;
import org.junit.jupiter.api.Test;
public class FastInverseSqrtTests {
@Test
void testForOneElement() {
assertFalse(FastInverseSqrt.inverseSqrt(1332));
// calls for the 2nd inverse method
}
@Test
void testForsecond() {
assertFalse(FastInverseSqrt.inverseSqrt(1332f));
// calls for the 1st inverse method
}
@Test
void testForThird() {
assertFalse(FastInverseSqrt.inverseSqrt(1));
}
@Test
void testForFourth() {
assertFalse(FastInverseSqrt.inverseSqrt(1f));
}
@Test
void testForFifth() {
assertFalse(FastInverseSqrt.inverseSqrt(4522));
}
@Test
void testForSixth() {
assertFalse(FastInverseSqrt.inverseSqrt(4522f));
}
@Test
void testForSeventh() {
assertFalse(FastInverseSqrt.inverseSqrt(21));
}
@Test
void testForEighth() {
assertFalse(FastInverseSqrt.inverseSqrt(21f));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/BinomialCoefficientTest.java | src/test/java/com/thealgorithms/maths/BinomialCoefficientTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
public class BinomialCoefficientTest {
@Test
void testBinomialCoefficient() {
assertEquals(190, BinomialCoefficient.binomialCoefficient(20, 2));
assertEquals(792, BinomialCoefficient.binomialCoefficient(12, 5));
assertEquals(84, BinomialCoefficient.binomialCoefficient(9, 3));
assertEquals(1, BinomialCoefficient.binomialCoefficient(17, 17));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/PollardRhoTest.java | src/test/java/com/thealgorithms/maths/PollardRhoTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.Test;
class PollardRhoTest {
@Test
void testPollardRhoForNumber315MustReturn5() {
// given
int number = 315;
int expectedResult = 5;
// when
int actualResult = PollardRho.pollardRho(number);
// then
assertEquals(expectedResult, actualResult);
}
@Test
void testPollardRhoForNumber187MustReturn11() {
// given
int number = 187;
int expectedResult = 11;
// when
int actualResult = PollardRho.pollardRho(number);
// then
assertEquals(expectedResult, actualResult);
}
@Test
void testPollardRhoForNumber239MustThrowException() {
// given
int number = 239;
String expectedMessage = "GCD cannot be found.";
// when
Exception exception = assertThrows(RuntimeException.class, () -> { PollardRho.pollardRho(number); });
String actualMessage = exception.getMessage();
// then
assertEquals(expectedMessage, actualMessage);
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/LeastCommonMultipleTest.java | src/test/java/com/thealgorithms/maths/LeastCommonMultipleTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.stream.Stream;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
class LeastCommonMultipleTest {
@ParameterizedTest
@MethodSource("provideTestCases")
void testLcm(int num1, int num2, int expected) {
assertEquals(expected, LeastCommonMultiple.lcm(num1, num2));
}
private static Stream<Arguments> provideTestCases() {
return Stream.of(Arguments.of(12, 18, 36), Arguments.of(5, 10, 10), Arguments.of(7, 3, 21), Arguments.of(21, 6, 42), Arguments.of(1, 1, 1), Arguments.of(8, 12, 24), Arguments.of(14, 35, 70), Arguments.of(15, 25, 75), Arguments.of(100, 25, 100), Arguments.of(0, 10, 0));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/VolumeTest.java | src/test/java/com/thealgorithms/maths/VolumeTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;
public class VolumeTest {
@Test
public void volume() {
/* test cube */
assertTrue(Volume.volumeCube(7) == 343.0);
/* test cuboid */
assertTrue(Volume.volumeCuboid(2, 5, 7) == 70.0);
/* test sphere */
assertTrue(Volume.volumeSphere(7) == 1436.7550402417319);
/* test cylinder */
assertTrue(Volume.volumeCylinder(3, 7) == 197.92033717615698);
/* test hemisphere */
assertTrue(Volume.volumeHemisphere(7) == 718.3775201208659);
/* test cone */
assertTrue(Volume.volumeCone(3, 7) == 65.97344572538566);
/* test prism */
assertTrue(Volume.volumePrism(10, 2) == 20.0);
/* test pyramid */
assertTrue(Volume.volumePyramid(10, 3) == 10.0);
/* test frustum */
assertTrue(Volume.volumeFrustumOfCone(3, 5, 7) == 359.188760060433);
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/FloorTest.java | src/test/java/com/thealgorithms/maths/FloorTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
public class FloorTest {
@Test
public void testFloorWholeNumber() {
assertEquals(0, Floor.floor(0));
assertEquals(1, Floor.floor(1));
assertEquals(-1, Floor.floor(-1));
assertEquals(42, Floor.floor(42));
assertEquals(-42, Floor.floor(-42));
}
@Test
public void testFloorDoubleNumber() {
assertEquals(0, Floor.floor(0.1));
assertEquals(1, Floor.floor(1.9));
assertEquals(-2, Floor.floor(-1.1));
assertEquals(-43, Floor.floor(-42.7));
}
@Test
public void testFloorNegativeZero() {
assertEquals(-0.0, Floor.floor(-0.0));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/PalindromeNumberTest.java | src/test/java/com/thealgorithms/maths/PalindromeNumberTest.java | package com.thealgorithms.maths;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
/**
* @author Albina Gimaletdinova on 01/07/2023
*/
public class PalindromeNumberTest {
@Test
public void testNumbersArePalindromes() {
Assertions.assertTrue(PalindromeNumber.isPalindrome(0));
Assertions.assertTrue(PalindromeNumber.isPalindrome(1));
Assertions.assertTrue(PalindromeNumber.isPalindrome(2332));
Assertions.assertTrue(PalindromeNumber.isPalindrome(12321));
}
@Test
public void testNumbersAreNotPalindromes() {
Assertions.assertFalse(PalindromeNumber.isPalindrome(12));
Assertions.assertFalse(PalindromeNumber.isPalindrome(990));
Assertions.assertFalse(PalindromeNumber.isPalindrome(1234));
}
@Test
public void testIfNegativeInputThenExceptionExpected() {
IllegalArgumentException exception = Assertions.assertThrows(IllegalArgumentException.class, () -> PalindromeNumber.isPalindrome(-1));
Assertions.assertEquals(exception.getMessage(), "Input parameter must not be negative!");
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/MaxValueTest.java | src/test/java/com/thealgorithms/maths/MaxValueTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
public class MaxValueTest {
@Test
public void maxTest() {
assertEquals(-1, MaxValue.max(-1, -3));
assertEquals(3, MaxValue.max(3, 2));
assertEquals(5, MaxValue.max(5, 5));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/ConvolutionTest.java | src/test/java/com/thealgorithms/maths/ConvolutionTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import java.util.stream.Stream;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
public class ConvolutionTest {
record ConvolutionTestCase(String description, double[] signalA, double[] signalB, double[] expected) {
}
@ParameterizedTest(name = "{0}")
@MethodSource("provideTestCases")
void testConvolution(ConvolutionTestCase testCase) {
double[] result = Convolution.convolution(testCase.signalA, testCase.signalB);
assertArrayEquals(testCase.expected, result, 1e-9, testCase.description);
}
private static Stream<ConvolutionTestCase> provideTestCases() {
return Stream.of(new ConvolutionTestCase("Basic convolution", new double[] {1, 2, 3}, new double[] {4, 5, 6}, new double[] {4, 13, 28, 27, 18}), new ConvolutionTestCase("Convolution with zero elements", new double[] {0, 0, 0}, new double[] {1, 2, 3}, new double[] {0, 0, 0, 0, 0}),
new ConvolutionTestCase("Convolution with single element", new double[] {2}, new double[] {3}, new double[] {6}), new ConvolutionTestCase("Convolution with different sizes", new double[] {1, 2}, new double[] {3, 4, 5}, new double[] {3, 10, 13, 10}),
new ConvolutionTestCase("Convolution with negative values", new double[] {1, -2, 3}, new double[] {-1, 2, -3}, new double[] {-1, 4, -10, 12, -9}),
new ConvolutionTestCase("Convolution with large numbers", new double[] {1e6, 2e6}, new double[] {3e6, 4e6}, new double[] {3e12, 1e13, 8e12}));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/PascalTriangleTest.java | src/test/java/com/thealgorithms/maths/PascalTriangleTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import org.junit.jupiter.api.Test;
class PascalTriangleTest {
@Test
void testForOne() {
int[][] result = PascalTriangle.pascal(1);
int[][] expected = {{1}};
assertArrayEquals(result, expected);
}
@Test
void testForTwo() {
int[][] result = PascalTriangle.pascal(2);
int[][] expected = {{1, 0}, {1, 1}};
assertArrayEquals(result, expected);
}
@Test
void testForFive() {
int[][] result = PascalTriangle.pascal(5);
int[][] expected = {
{1, 0, 0, 0, 0},
{1, 1, 0, 0, 0},
{1, 2, 1, 0, 0},
{1, 3, 3, 1, 0},
{1, 4, 6, 4, 1},
};
assertArrayEquals(result, expected);
}
@Test
void testForEight() {
int[][] result = PascalTriangle.pascal(8);
int[][] expected = {
{1, 0, 0, 0, 0, 0, 0, 0},
{1, 1, 0, 0, 0, 0, 0, 0},
{1, 2, 1, 0, 0, 0, 0, 0},
{1, 3, 3, 1, 0, 0, 0, 0},
{1, 4, 6, 4, 1, 0, 0, 0},
{1, 5, 10, 10, 5, 1, 0, 0},
{1, 6, 15, 20, 15, 6, 1, 0},
{1, 7, 21, 35, 35, 21, 7, 1},
};
assertArrayEquals(expected, result);
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
TheAlgorithms/Java | https://github.com/TheAlgorithms/Java/blob/e945f1622490ff3b32e59d31780df27d0dc2ede4/src/test/java/com/thealgorithms/maths/BinaryPowTest.java | src/test/java/com/thealgorithms/maths/BinaryPowTest.java | package com.thealgorithms.maths;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
public class BinaryPowTest {
@Test
void testBinPow() {
assertEquals(4, BinaryPow.binPow(2, 2));
assertEquals(256, BinaryPow.binPow(4, 4));
assertEquals(729, BinaryPow.binPow(9, 3));
assertEquals(262144, BinaryPow.binPow(8, 6));
}
@Test
void testZeroExponent() {
assertEquals(1, BinaryPow.binPow(2, 0));
assertEquals(1, BinaryPow.binPow(100, 0));
assertEquals(1, BinaryPow.binPow(-5, 0));
}
@Test
void testZeroBase() {
assertEquals(0, BinaryPow.binPow(0, 5));
assertEquals(1, BinaryPow.binPow(0, 0));
}
@Test
void testOneBase() {
assertEquals(1, BinaryPow.binPow(1, 100));
assertEquals(1, BinaryPow.binPow(1, 0));
}
@Test
void testNegativeBase() {
assertEquals(-8, BinaryPow.binPow(-2, 3));
assertEquals(16, BinaryPow.binPow(-2, 4));
}
@Test
void testLargeExponent() {
assertEquals(1073741824, BinaryPow.binPow(2, 30));
}
}
| java | MIT | e945f1622490ff3b32e59d31780df27d0dc2ede4 | 2026-01-04T14:45:56.733479Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.