Skip to content

FibonacciJavaStreams refactoring, added unit tests #4260

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 5 commits into from
Jul 25, 2023
Merged

FibonacciJavaStreams refactoring, added unit tests #4260

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
b493e0f
FibonacciJavaStreams refactoring, added unit tests
albina-astr Jul 25, 2023
e019d35
Update directory
Jul 25, 2023
2626710
Fixed style
albina-astr Jul 25, 2023
71dbb24
Fixed style
albina-astr Jul 25, 2023
248a665
Fixed style
albina-astr Jul 25, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
3 changes: 3 additions & 0 deletions DIRECTORY.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -608,6 +608,7 @@
* [EggDroppingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/EggDroppingTest.java)
* [KnapsackMemoizationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/KnapsackMemoizationTest.java)
* [LevenshteinDistanceTests](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/LevenshteinDistanceTests.java)
* [MinimumPathSumTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/MinimumPathSumTest.java)
* [OptimalJobSchedulingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/OptimalJobSchedulingTest.java)
* [PartitionProblemTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/PartitionProblemTest.java)
* [SubsetCountTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/SubsetCountTest.java)
Expand Down Expand Up @@ -637,6 +638,7 @@
* [FactorialTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FactorialTest.java)
* [FastInverseSqrtTests](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FastInverseSqrtTests.java)
* [FFTTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FFTTest.java)
* [FibonacciJavaStreamsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FibonacciJavaStreamsTest.java)
* [FibonacciNumberCheckTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FibonacciNumberCheckTest.java)
* [FindMaxTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FindMaxTest.java)
* [FindMinTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FindMinTest.java)
Expand Down Expand Up @@ -673,6 +675,7 @@
* [SquareRootWithNewtonRaphsonTestMethod](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/SquareRootWithNewtonRaphsonTestMethod.java)
* [StandardDeviationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/StandardDeviationTest.java)
* [StandardScoreTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/StandardScoreTest.java)
* [SumOfArithmeticSeriesTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/SumOfArithmeticSeriesTest.java)
* [SumOfDigitsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/SumOfDigitsTest.java)
* [SumWithoutArithmeticOperatorsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/SumWithoutArithmeticOperatorsTest.java)
* [TestArmstrong](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/TestArmstrong.java)
Expand Down
71 changes: 1 addition & 70 deletions src/main/java/com/thealgorithms/maths/FibonacciJavaStreams.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,7 +2,6 @@

import java.math.BigDecimal;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Stream;

Expand All @@ -14,7 +13,7 @@ public class FibonacciJavaStreams {

public static Optional<BigDecimal> calculate(final BigDecimal index) {
if (index == null || index.compareTo(BigDecimal.ZERO) < 0) {
return Optional.empty();
throw new IllegalArgumentException("Input index cannot be null or negative!");
}

if (index.compareTo(BigDecimal.ONE) < 0) {
Expand All @@ -30,72 +29,4 @@ public static Optional<BigDecimal> calculate(final BigDecimal index) {

return results.isEmpty() ? Optional.empty() : Optional.of(results.get(results.size() - 1));
}

public static void assertThat(final Object actual, final Object expected) {
if (!Objects.equals(actual, expected)) {
throw new AssertionError(String.format("expected=%s but was actual=%s", expected, actual));
}
}

public static void main(final String[] args) {
{
final Optional<BigDecimal> result = calculate(new BigDecimal(-1));
assertThat(result.isEmpty(), true);
}
{
final Optional<BigDecimal> result = calculate(BigDecimal.ZERO);
assertThat(result.isPresent(), true);
result.ifPresent(value -> assertThat(value, BigDecimal.ZERO));
}
{
final Optional<BigDecimal> result = calculate(BigDecimal.ONE);
assertThat(result.isPresent(), true);
result.ifPresent(value -> assertThat(value, BigDecimal.ONE));
}
{
final Optional<BigDecimal> result = calculate(new BigDecimal(2));
assertThat(result.isPresent(), true);
result.ifPresent(value -> assertThat(value, BigDecimal.ONE));
}
{
final Optional<BigDecimal> result = calculate(new BigDecimal(3));
assertThat(result.isPresent(), true);
result.ifPresent(value -> assertThat(value, new BigDecimal(2)));
}
{
final Optional<BigDecimal> result = calculate(new BigDecimal(10));
assertThat(result.isPresent(), true);
result.ifPresent(value -> assertThat(value, new BigDecimal(55)));
}
{
final Optional<BigDecimal> result = calculate(new BigDecimal(20));
assertThat(result.isPresent(), true);
result.ifPresent(value -> assertThat(value, new BigDecimal(6765)));
}
{
final Optional<BigDecimal> result = calculate(new BigDecimal(30));
assertThat(result.isPresent(), true);
result.ifPresent(value -> assertThat(value, new BigDecimal(832040)));
}
{
final Optional<BigDecimal> result = calculate(new BigDecimal(40));
assertThat(result.isPresent(), true);
result.ifPresent(value -> assertThat(value, new BigDecimal(102334155)));
}
{
final Optional<BigDecimal> result = calculate(new BigDecimal(50));
assertThat(result.isPresent(), true);
result.ifPresent(value -> assertThat(value, new BigDecimal(12586269025L)));
}
{
final Optional<BigDecimal> result = calculate(new BigDecimal(100));
assertThat(result.isPresent(), true);
result.ifPresent(value -> assertThat(value, new BigDecimal("354224848179261915075")));
}
{
final Optional<BigDecimal> result = calculate(new BigDecimal(200));
assertThat(result.isPresent(), true);
result.ifPresent(value -> assertThat(value, new BigDecimal("280571172992510140037611932413038677189525")));
}
}
}
71 changes: 71 additions & 0 deletions src/test/java/com/thealgorithms/maths/FibonacciJavaStreamsTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,71 @@
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(new BigDecimal(2), BigDecimal.ONE);
checkElement(new BigDecimal(3), new BigDecimal(2));
}

@Test
public void testCheck10thSequenceElement() {
checkElement(new BigDecimal(10), 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);
}
}