EulerMethodTest.java

packagecom.thealgorithms.maths;

importstaticorg.junit.jupiter.api.Assertions.assertArrayEquals;
importstaticorg.junit.jupiter.api.Assertions.assertEquals;
importstaticorg.junit.jupiter.api.Assertions.assertThrows;

importjava.util.ArrayList;
importjava.util.function.BiFunction;
importjava.util.stream.Stream;
importorg.junit.jupiter.params.ParameterizedTest;
importorg.junit.jupiter.params.provider.Arguments;
importorg.junit.jupiter.params.provider.MethodSource;

classEulerMethodTest {

privatestaticclassEulerFullTestCase {
double[] params;
BiFunction<Double, Double, Double> equation;
intexpectedSize;
double[] expectedFirstPoint;
double[] expectedLastPoint;

EulerFullTestCase(double[] params, BiFunction<Double, Double, Double> equation, intexpectedSize, double[] expectedFirstPoint, double[] expectedLastPoint) {
this.params = params;
this.equation = equation;
this.expectedSize = expectedSize;
this.expectedFirstPoint = expectedFirstPoint;
this.expectedLastPoint = expectedLastPoint;
 }
 }

@ParameterizedTest
@MethodSource("eulerStepTestCases")
voidtestEulerStep(doublex, doubleh, doubley, BiFunction<Double, Double, Double> equation, doubleexpected) {
doubleresult = EulerMethod.eulerStep(x, h, y, equation);
assertEquals(expected, result, 1e-9, "Euler step failed for the given equation.");
 }

staticStream<Arguments> eulerStepTestCases() {
returnStream.of(Arguments.of(0.0, 0.1, 1.0, (BiFunction<Double, Double, Double>) ((x, y) -> x + y), 1.1));
 }

@ParameterizedTest
@MethodSource("eulerStepInvalidCases")
voidtestEulerStepInvalidInput(doublex, doubleh, doubley, BiFunction<Double, Double, Double> equation, Class<? extendsException> expectedExceptionClass) {
assertThrows(expectedExceptionClass, () -> EulerMethod.eulerStep(x, h, y, equation));
 }

staticStream<Arguments> eulerStepInvalidCases() {
BiFunction<Double, Double, Double> dummyEquation = (x, y) -> x + y;
returnStream.of(Arguments.of(0.0, -0.1, 1.0, dummyEquation, IllegalArgumentException.class), Arguments.of(0.0, 0.0, 1.0, dummyEquation, IllegalArgumentException.class));
 }

@ParameterizedTest
@MethodSource("eulerFullTestCases")
voidtestEulerFull(EulerFullTestCasetestCase) {
ArrayList<double[]> result = EulerMethod.eulerFull(testCase.params[0], testCase.params[1], testCase.params[2], testCase.params[3], testCase.equation);
assertEquals(testCase.expectedSize, result.size(), "Incorrect number of points in the result.");
assertArrayEquals(testCase.expectedFirstPoint, result.get(0), 1e-9, "Incorrect first point.");
assertArrayEquals(testCase.expectedLastPoint, result.get(result.size() - 1), 1e-9, "Incorrect last point.");
 }

staticStream<Arguments> eulerFullTestCases() {
returnStream.of(Arguments.of(newEulerFullTestCase(newdouble[] {0.0, 1.0, 0.5, 0.0}, (x, y) -> x, 3, newdouble[] {0.0, 0.0}, newdouble[] {1.0, 0.25})),
Arguments.of(newEulerFullTestCase(newdouble[] {0.0, 1.0, 0.1, 1.0}, (x, y) -> y, 12, newdouble[] {0.0, 1.0}, newdouble[] {1.0999999999999999, 2.8531167061100002})),
Arguments.of(newEulerFullTestCase(newdouble[] {0.0, 0.1, 0.1, 1.0}, (x, y) -> x + y, 2, newdouble[] {0.0, 1.0}, newdouble[] {0.1, 1.1})));
 }

@ParameterizedTest
@MethodSource("eulerFullInvalidCases")
voidtestEulerFullInvalidInput(doublexStart, doublexEnd, doublestepSize, doubleyInitial, BiFunction<Double, Double, Double> equation, Class<? extendsException> expectedExceptionClass) {
assertThrows(expectedExceptionClass, () -> EulerMethod.eulerFull(xStart, xEnd, stepSize, yInitial, equation));
 }

staticStream<Arguments> eulerFullInvalidCases() {
BiFunction<Double, Double, Double> dummyEquation = (x, y) -> x + y;
returnStream.of(Arguments.of(1.0, 0.0, 0.1, 1.0, dummyEquation, IllegalArgumentException.class), Arguments.of(0.0, 1.0, 0.0, 1.0, dummyEquation, IllegalArgumentException.class), Arguments.of(0.0, 1.0, -0.1, 1.0, dummyEquation, IllegalArgumentException.class));
 }
}