BAEL-1889 - Let's move the Java Number articles into a new module (#4619)

* BAEL-1849 - Convert from String to Date in Java * BAEL-1863 - Calling Callbacks with Mockito * BAEL-1889 - Let's move the Java Number articles into a new module * BAEL-1889 - Let's move the Java Number articles into a new module
2018-07-14 15:00:37 +02:00
parent de2afd7da8
commit b44883b364
41 changed files with 380 additions and 188 deletions
--- a/java-numbers/src/test/java/com/baeldung/algorithms/primechecker/PrimeCheckerUnitTest.java
+++ b/java-numbers/src/test/java/com/baeldung/algorithms/primechecker/PrimeCheckerUnitTest.java
@@ -0,0 +1,68 @@
+package com.baeldung.algorithms.primechecker;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class PrimeCheckerUnitTest {
+
+    private final BigIntegerPrimeChecker primeChecker = new BigIntegerPrimeChecker();
+
+    @Test
+    public void whenCheckIsPrime_thenTrue() {
+        assertTrue(primeChecker.isPrime(13l));
+        assertTrue(primeChecker.isPrime(1009L));
+        assertTrue(primeChecker.isPrime(74207281L));
+    }
+
+    @Test
+    public void whenCheckIsPrime_thenFalse() {
+        assertTrue(!primeChecker.isPrime(50L));
+        assertTrue(!primeChecker.isPrime(1001L));
+        assertTrue(!primeChecker.isPrime(74207282L));
+    }
+
+    private final BruteForcePrimeChecker bfPrimeChecker = new BruteForcePrimeChecker();
+
+    @Test
+    public void whenBFCheckIsPrime_thenTrue() {
+        assertTrue(bfPrimeChecker.isPrime(13));
+        assertTrue(bfPrimeChecker.isPrime(1009));
+    }
+
+    @Test
+    public void whenBFCheckIsPrime_thenFalse() {
+        assertFalse(bfPrimeChecker.isPrime(50));
+        assertFalse(bfPrimeChecker.isPrime(1001));
+    }
+
+    private final OptimisedPrimeChecker optimisedPrimeChecker = new OptimisedPrimeChecker();
+
+    @Test
+    public void whenOptCheckIsPrime_thenTrue() {
+        assertTrue(optimisedPrimeChecker.isPrime(13));
+        assertTrue(optimisedPrimeChecker.isPrime(1009));
+    }
+
+    @Test
+    public void whenOptCheckIsPrime_thenFalse() {
+        assertFalse(optimisedPrimeChecker.isPrime(50));
+        assertFalse(optimisedPrimeChecker.isPrime(1001));
+    }
+
+    private final PrimesPrimeChecker primesPrimeChecker = new PrimesPrimeChecker();
+
+    @Test
+    public void whenPrimesCheckIsPrime_thenTrue() {
+        assertTrue(primesPrimeChecker.isPrime(13));
+        assertTrue(primesPrimeChecker.isPrime(1009));
+    }
+
+    @Test
+    public void whenPrimesCheckIsPrime_thenFalse() {
+        assertFalse(primesPrimeChecker.isPrime(50));
+        assertFalse(primesPrimeChecker.isPrime(1001));
+    }
+
+}
--- a/java-numbers/src/test/java/com/baeldung/maths/BigDecimalImplUnitTest.java
+++ b/java-numbers/src/test/java/com/baeldung/maths/BigDecimalImplUnitTest.java
@@ -0,0 +1,25 @@
+package com.baeldung.maths;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+
+public class BigDecimalImplUnitTest {
+
+    @Test
+    public void givenBigDecimalNumbers_whenAddedTogether_thenGetExpectedResult() {
+        BigDecimal serviceTax = new BigDecimal("56.0084578639");
+        serviceTax = serviceTax.setScale(2, RoundingMode.CEILING);
+
+        BigDecimal entertainmentTax = new BigDecimal("23.00689");
+        entertainmentTax = entertainmentTax.setScale(2, RoundingMode.FLOOR);
+
+        BigDecimal totalTax = serviceTax.add(entertainmentTax);
+        BigDecimal result = BigDecimal.valueOf(79.01);
+
+        Assert.assertEquals(result, totalTax);
+
+    }
+}
--- a/java-numbers/src/test/java/com/baeldung/maths/BigIntegerImplUnitTest.java
+++ b/java-numbers/src/test/java/com/baeldung/maths/BigIntegerImplUnitTest.java
@@ -0,0 +1,21 @@
+package com.baeldung.maths;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.math.BigInteger;
+
+public class BigIntegerImplUnitTest {
+
+    @Test
+    public void givenBigIntegerNumbers_whenAddedTogether_thenGetExpectedResult() {
+        BigInteger numStarsMilkyWay = new BigInteger("8731409320171337804361260816606476");
+        BigInteger numStarsAndromeda = new BigInteger("5379309320171337804361260816606476");
+
+        BigInteger totalStars = numStarsMilkyWay.add(numStarsAndromeda);
+        BigInteger result = new BigInteger("14110718640342675608722521633212952");
+
+        Assert.assertEquals(result, totalStars);
+    }
+
+}
--- a/java-numbers/src/test/java/com/baeldung/maths/FloatingPointArithmeticUnitTest.java
+++ b/java-numbers/src/test/java/com/baeldung/maths/FloatingPointArithmeticUnitTest.java
@@ -0,0 +1,45 @@
+package com.baeldung.maths;
+
+import java.math.BigDecimal;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class FloatingPointArithmeticUnitTest {
+
+    @Test
+    public void givenDecimalNumbers_whenAddedTogether_thenGetExpectedResult() {
+        double a = 13.22;
+        double b = 4.88;
+        double c = 21.45;
+        double result = 39.55;
+        
+        double abc = a + b + c;
+        double acb = a + c + b;
+        
+        Assert.assertEquals(result, abc, 0);
+        Assert.assertNotEquals(result, acb, 0);
+        
+        double ab = 18.1;
+        double ac = 34.67;
+        
+        double ab_c = ab + c;
+        double ac_b = ac + b;
+        
+        Assert.assertEquals(result, ab_c, 0);
+        Assert.assertNotEquals(result, ac_b, 0);
+        
+        BigDecimal d = new BigDecimal(String.valueOf(a));
+        BigDecimal e = new BigDecimal(String.valueOf(b));
+        BigDecimal f = new BigDecimal(String.valueOf(c));
+        BigDecimal sum = new BigDecimal("39.55");
+        
+        BigDecimal def = d.add(e).add(f);
+        BigDecimal dfe = d.add(f).add(e);
+        
+        Assert.assertEquals(0, def.compareTo(sum));
+        Assert.assertEquals(0, dfe.compareTo(sum));
+        
+        Assert.assertNotEquals(0, sum.compareTo(new BigDecimal(String.valueOf(acb))));
+    }
+}
--- a/java-numbers/src/test/java/com/baeldung/maths/RoundUnitTest.java
+++ b/java-numbers/src/test/java/com/baeldung/maths/RoundUnitTest.java
@@ -0,0 +1,71 @@
+package com.baeldung.maths;
+
+import org.apache.commons.math3.util.Precision;
+import org.decimal4j.util.DoubleRounder;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class RoundUnitTest {
+    private double value = 2.03456d;
+    private int places = 2;
+    private double delta = 0.0d;
+    private double expected = 2.03d;
+
+    @Test
+    public void givenDecimalNumber_whenRoundToNDecimalPlaces_thenGetExpectedResult() {   
+        Assert.assertEquals(expected, Round.round(value, places), delta);
+        Assert.assertEquals(expected, Round.roundNotPrecise(value, places), delta);
+        Assert.assertEquals(expected, Round.roundAvoid(value, places), delta);
+        Assert.assertEquals(expected, Precision.round(value, places), delta);
+        Assert.assertEquals(expected, DoubleRounder.round(value, places), delta);
+        
+        places = 3;
+        expected = 2.035d;
+        
+        Assert.assertEquals(expected, Round.round(value, places), delta);
+        Assert.assertEquals(expected, Round.roundNotPrecise(value, places), delta);
+        Assert.assertEquals(expected, Round.roundAvoid(value, places), delta);
+        Assert.assertEquals(expected, Precision.round(value, places), delta);
+        Assert.assertEquals(expected, DoubleRounder.round(value, places), delta);
+        
+        value = 1000.0d;
+        places = 17;
+        expected = 1000.0d;
+        
+        Assert.assertEquals(expected, Round.round(value, places), delta);
+        Assert.assertEquals(expected, Round.roundNotPrecise(value, places), delta);
+        Assert.assertNotEquals(expected, Round.roundAvoid(value, places), delta); // Returns: 92.23372036854776 !
+        Assert.assertEquals(expected, Precision.round(value, places), delta);
+        Assert.assertEquals(expected, DoubleRounder.round(value, places), delta);
+        
+        value = 256.025d;
+        places = 2;
+        expected = 256.03d;
+        
+        Assert.assertEquals(expected, Round.round(value, places), delta);
+        Assert.assertNotEquals(expected, Round.roundNotPrecise(value, places), delta); // Returns: 256.02 !
+        Assert.assertNotEquals(expected, Round.roundAvoid(value, places), delta); // Returns: 256.02 !
+        Assert.assertEquals(expected, Precision.round(value, places), delta);
+        Assert.assertNotEquals(expected, DoubleRounder.round(value, places), delta); // Returns: 256.02 !
+        
+        value = 260.775d; 
+        places = 2;
+        expected = 260.78d;
+        
+        Assert.assertEquals(expected, Round.round(value, places), delta);
+        Assert.assertNotEquals(expected, Round.roundNotPrecise(value, places), delta); // Returns: 260.77 !
+        Assert.assertNotEquals(expected, Round.roundAvoid(value, places), delta); // Returns: 260.77 !
+        Assert.assertEquals(expected, Precision.round(value, places), delta);
+        Assert.assertNotEquals(expected, DoubleRounder.round(value, places), delta); // Returns: 260.77 !
+        
+        value = 90080070060.1d;
+        places = 9;
+        expected = 90080070060.1d;
+        
+        Assert.assertEquals(expected, Round.round(value, places), delta);
+        Assert.assertEquals(expected, Round.roundNotPrecise(value, places), delta);
+        Assert.assertNotEquals(expected, Round.roundAvoid(value, places), delta); // Returns: 9.223372036854776E9 !
+        Assert.assertEquals(expected, Precision.round(value, places), delta);
+        Assert.assertEquals(expected, DoubleRounder.round(value, places), delta);
+    }
+}
--- a/java-numbers/src/test/java/com/baeldung/numberofdigits/NumberOfDigitsIntegrationTest.java
+++ b/java-numbers/src/test/java/com/baeldung/numberofdigits/NumberOfDigitsIntegrationTest.java
@@ -0,0 +1,106 @@
+package com.baeldung.numberofdigits;
+
+import org.junit.Assert;
+import org.junit.Assume;
+import org.junit.experimental.theories.DataPoints;
+import org.junit.experimental.theories.Theories;
+import org.junit.experimental.theories.Theory;
+import org.junit.runner.RunWith;
+
+@RunWith(Theories.class)
+public class NumberOfDigitsIntegrationTest {
+    
+    private static NumberOfDigits numberOfDigits;
+    
+    static {
+        numberOfDigits = new NumberOfDigits();
+    }
+    
+    @DataPoints
+    public static int[][] lowestIntegers()
+    {
+      return new int[][]{
+          {1, 1}, 
+          {2, 10}, 
+          {3, 100}, 
+          {4, 1000}, 
+          {5, 10000}, 
+          {6, 100000}, 
+          {7, 1000000}, 
+          {8, 10000000}, 
+          {9, 100000000}, 
+          {10, 1000000000}
+      };
+    }
+    
+    @DataPoints
+    public static int[][] highestIntegers()
+    {
+      return new int[][]{
+          {1, 9}, 
+          {2, 99}, 
+          {3, 999}, 
+          {4, 9999}, 
+          {5, 99999}, 
+          {6, 999999}, 
+          {7, 9999999}, 
+          {8, 99999999}, 
+          {9, 999999999}, 
+          {10, Integer.MAX_VALUE}
+      };
+    }
+    
+    @DataPoints
+    public static int[][] randomIntegers()
+    {
+      return new int[][]{
+          {1, 1}, 
+          {2, 14}, 
+          {3, 549}, 
+          {4, 1136}, 
+          {5, 25340}, 
+          {6, 134321}, 
+          {7, 1435432}, 
+          {8, 54234129}, 
+          {9, 113683912}, 
+          {10, 1534031982}
+      };
+    }
+
+    @Theory
+    public void givenDataPoints_whenStringBasedSolutionInvoked_thenAllPointsMatch(final int[] entry) {
+        Assume.assumeTrue(entry[0] > 0 && entry[1] > 0);
+        Assert.assertEquals(entry[0], numberOfDigits.stringBasedSolution(entry[1]));
+    }
+
+    @Theory
+    public void givenDataPoints_whenLogarithmicApproachInvoked_thenAllPointsMatch(final int[] entry) {
+        Assume.assumeTrue(entry[0] > 0 && entry[1] > 0);
+        Assert.assertEquals(entry[0], numberOfDigits.logarithmicApproach(entry[1]));
+    }
+
+    @Theory
+    public void givenDataPoints_whenRepeatedMultiplicationInvoked_thenAllPointsMatch(final int[] entry) {
+        Assume.assumeTrue(entry[0] > 0 && entry[1] > 0);
+        Assert.assertEquals(entry[0], numberOfDigits.repeatedMultiplication(entry[1]));
+    }
+
+    @Theory
+    public void givenDataPoints_whenShiftOperatorsInvoked_thenAllPointsMatch(final int[] entry) {
+        Assume.assumeTrue(entry[0] > 0 && entry[1] > 0);
+        Assert.assertEquals(entry[0], numberOfDigits.shiftOperators(entry[1]));
+    }
+
+    @Theory
+    public void givenDataPoints_whenDividingWithPowersOf2Invoked_thenAllPointsMatch(final int[] entry) {
+        Assume.assumeTrue(entry[0] > 0 && entry[1] > 0);
+        Assert.assertEquals(entry[0], numberOfDigits.dividingWithPowersOf2(entry[1]));
+    }
+
+    @Theory
+    public void givenDataPoints_whenDivideAndConquerInvoked_thenAllPointsMatch(final int[] entry) {
+        Assume.assumeTrue(entry[0] > 0 && entry[1] > 0);
+        Assert.assertEquals(entry[0], numberOfDigits.divideAndConquer(entry[1]));
+    }
+    
+}
--- a/java-numbers/src/test/java/com/baeldung/pairsaddupnumber/DifferentPairsUnitTest.java
+++ b/java-numbers/src/test/java/com/baeldung/pairsaddupnumber/DifferentPairsUnitTest.java
@@ -0,0 +1,39 @@
+package com.baeldung.pairsaddupnumber;
+
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+public class DifferentPairsUnitTest {
+
+    /* All different pairs */
+
+    @Test
+    public void whenTraditionalLoop_thenReturnAllDifferentPairs() {
+        /* Data */
+        final int[] input = {2, 4, 3, 3, 8};
+        final int sum = 6;
+        /* Call service */
+        final List<Integer> pairs = DifferentPairs.findPairsWithForLoop(input, sum);
+        /* Check results */
+        assertThat(pairs).hasSize(2).contains(4,3).doesNotContain(8);
+    }
+
+    @Test
+    public void whenStreamApi_thenReturnAllDifferentPairs() {
+        /* Data */
+        final int[] input = {2, 4, 3, 3, 8};
+        final int sum = 6;
+        /* Call service */
+        final List<Integer> pairs = DifferentPairs.findPairsWithStreamApi(input, sum);
+        /* Check results */
+        assertNotNull(pairs);
+        assertEquals(pairs.size(),2);
+        assertEquals(pairs.get(0), new Integer(4));
+        assertThat(pairs).hasSize(2).contains(4,3).doesNotContain(8);
+    }
+}
--- a/java-numbers/src/test/java/com/baeldung/pairsaddupnumber/ExistingPairsUnitTest.java
+++ b/java-numbers/src/test/java/com/baeldung/pairsaddupnumber/ExistingPairsUnitTest.java
@@ -0,0 +1,34 @@
+package com.baeldung.pairsaddupnumber;
+
+import org.junit.Test;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+
+public class ExistingPairsUnitTest {
+
+    /* All existing pairs */
+
+    @Test
+    public void whenTraditionalLoop_thenReturnAllExistingPairs() {
+        /* Data */
+        final int[] input = {2, 4, 3, 3, 8};
+        final int sum = 6;
+        /* Call service */
+        final List<Integer> pairs = ExistingPairs.findPairsWithForLoop(input, sum);
+        /* Check results */
+        assertThat(pairs).hasSize(4).contains(2,4,3,3).doesNotContain(8);
+    }
+
+    @Test
+    public void whenStreamApi_thenReturnAllExistingPairs() {
+        /* Data */
+        final int[] input = {2, 4, 3, 3, 8};
+        final int sum = 6;
+        /* Call service */
+        final List<Integer> pairs = ExistingPairs.findPairsWithStreamApi(input, sum);
+        /* Check results */
+        assertThat(pairs).hasSize(4).contains(2,4,3,3).doesNotContain(8);
+    }
+}
--- a/java-numbers/src/test/java/com/baeldung/prime/PrimeGeneratorUnitTest.java
+++ b/java-numbers/src/test/java/com/baeldung/prime/PrimeGeneratorUnitTest.java
@@ -0,0 +1,28 @@
+package com.baeldung.prime;
+
+import java.util.Arrays;
+import java.util.List;
+import org.junit.Test;
+
+import static com.baeldung.prime.PrimeGenerator.*;
+import static org.junit.Assert.*;
+
+public class PrimeGeneratorUnitTest {
+    @Test
+    public void whenBruteForced_returnsSuccessfully() {
+        final List<Integer> primeNumbers = primeNumbersBruteForce(20);
+        assertEquals(Arrays.asList(new Integer[] { 2, 3, 5, 7, 11, 13, 17, 19 }), primeNumbers);
+    }
+
+    @Test
+    public void whenOptimized_returnsSuccessfully() {
+        final List<Integer> primeNumbers = primeNumbersTill(20);
+        assertEquals(Arrays.asList(new Integer[] { 2, 3, 5, 7, 11, 13, 17, 19 }), primeNumbers);
+    }
+
+    @Test
+    public void whenSieveOfEratosthenes_returnsSuccessfully() {
+        final List<Integer> primeNumbers = sieveOfEratosthenes(20);
+        assertEquals(Arrays.asList(new Integer[] { 2, 3, 5, 7, 11, 13, 17, 19 }), primeNumbers);
+    }
+}
--- a/java-numbers/src/test/java/com/baeldung/random/JavaRandomUnitTest.java
+++ b/java-numbers/src/test/java/com/baeldung/random/JavaRandomUnitTest.java
@@ -0,0 +1,217 @@
+package com.baeldung.random;
+
+import org.apache.commons.lang3.RandomStringUtils;
+import org.apache.commons.math3.random.RandomDataGenerator;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.nio.charset.Charset;
+import java.util.Random;
+
+public class JavaRandomUnitTest {
+
+    private static final Logger LOG = LoggerFactory.getLogger(JavaRandomUnitTest.class);
+
+    // tests - random long
+
+    @Test
+    public void givenUsingPlainJava_whenGeneratingRandomLongUnbounded_thenCorrect() {
+        final long generatedLong = new Random().nextLong();
+
+        LOG.debug("{}", generatedLong);
+    }
+
+    @Test
+    public void givenUsingApacheCommons_whenGeneratingRandomLongUnbounded_thenCorrect() {
+        final long generatedLong = new RandomDataGenerator().getRandomGenerator()
+            .nextLong();
+
+        LOG.debug("{}", generatedLong);
+    }
+
+    @Test
+    public void givenUsingPlainJava_whenGeneratingRandomLongBounded_thenCorrect() {
+        final long leftLimit = 1L;
+        final long rightLimit = 10L;
+        final long generatedLong = leftLimit + (long) (Math.random() * (rightLimit - leftLimit));
+
+        LOG.debug("{}", generatedLong);
+    }
+
+    @Test
+    public void givenUsingApacheCommons_whenGeneratingRandomLongBounded_thenCorrect() {
+        final long leftLimit = 10L;
+        final long rightLimit = 100L;
+        final long generatedLong = new RandomDataGenerator().nextLong(leftLimit, rightLimit);
+
+        LOG.debug("{}", generatedLong);
+    }
+
+    // tests - random int
+
+    @Test
+    public void givenUsingPlainJava_whenGeneratingRandomIntegerUnbounded_thenCorrect() {
+        final int generatedInteger = new Random().nextInt();
+
+        LOG.debug("{}", generatedInteger);
+    }
+
+    @Test
+    public void givenUsingPlainJava_whenGeneratingRandomIntegerBounded_thenCorrect() {
+        final int leftLimit = 1;
+        final int rightLimit = 10;
+        final int generatedInteger = leftLimit + (int) (new Random().nextFloat() * (rightLimit - leftLimit));
+
+        LOG.debug("{}", generatedInteger);
+    }
+
+    @Test
+    public void givenUsingApache_whenGeneratingRandomIntegerUnbounded_thenCorrect() {
+        final Integer generatedInteger = new RandomDataGenerator().getRandomGenerator()
+            .nextInt();
+
+        LOG.debug("{}", generatedInteger);
+    }
+
+    @Test
+    public void givenUsingApache_whenGeneratingRandomIntegerBounded_thenCorrect() {
+        final int leftLimit = 1;
+        final int rightLimit = 10;
+        final int generatedInteger = new RandomDataGenerator().nextInt(leftLimit, rightLimit);
+
+        LOG.debug("{}", generatedInteger);
+    }
+
+    // tests - random float
+
+    @Test
+    public void givenUsingPlainJava_whenGeneratingRandomFloatUnbouned_thenCorrect() {
+        final float generatedFloat = new Random().nextFloat();
+
+        LOG.debug("{}", generatedFloat);
+    }
+
+    @Test
+    public void givenUsingApache_whenGeneratingRandomFloatUnbounded_thenCorrect() {
+        final float generatedFloat = new RandomDataGenerator().getRandomGenerator()
+            .nextFloat();
+
+        LOG.debug("{}", generatedFloat);
+    }
+
+    @Test
+    public void givenUsingPlainJava_whenGeneratingRandomFloatBouned_thenCorrect() {
+        final float leftLimit = 1F;
+        final float rightLimit = 10F;
+        final float generatedFloat = leftLimit + new Random().nextFloat() * (rightLimit - leftLimit);
+
+        LOG.debug("{}", generatedFloat);
+    }
+
+    @Test
+    public void givenUsingApache_whenGeneratingRandomFloatBounded_thenCorrect() {
+        final float leftLimit = 1F;
+        final float rightLimit = 10F;
+        final float randomFloat = new RandomDataGenerator().getRandomGenerator()
+            .nextFloat();
+        final float generatedFloat = leftLimit + randomFloat * (rightLimit - leftLimit);
+
+        LOG.debug("{}", generatedFloat);
+    }
+
+    // tests - random double
+
+    @Test
+    public void givenUsingPlainJava_whenGeneratingRandomDoubleUnbounded_thenCorrect() {
+        final double generatedDouble = Math.random();
+
+        LOG.debug("{}", generatedDouble);
+    }
+
+    @Test
+    public void givenUsingApache_whenGeneratingRandomDoubleUnbounded_thenCorrect() {
+        final double generatedDouble = new RandomDataGenerator().getRandomGenerator()
+            .nextDouble();
+
+        LOG.debug("{}", generatedDouble);
+    }
+
+    @Test
+    public void givenUsingPlainJava_whenGeneratingRandomDoubleBounded_thenCorrect() {
+        final double leftLimit = 1D;
+        final double rightLimit = 10D;
+        final double generatedDouble = leftLimit + new Random().nextDouble() * (rightLimit - leftLimit);
+
+        LOG.debug("{}", generatedDouble);
+    }
+
+    @Test
+    public void givenUsingApache_whenGeneratingRandomDoubleBounded_thenCorrect() {
+        final double leftLimit = 1D;
+        final double rightLimit = 100D;
+        final double generatedDouble = new RandomDataGenerator().nextUniform(leftLimit, rightLimit);
+
+        LOG.debug("{}", generatedDouble);
+    }
+
+    // tests - random String
+
+    @Test
+    public void givenUsingPlainJava_whenGeneratingRandomStringUnbounded_thenCorrect() {
+        final byte[] array = new byte[7]; // length is bounded by 7
+        new Random().nextBytes(array);
+        final String generatedString = new String(array, Charset.forName("UTF-8"));
+
+        LOG.debug(generatedString);
+    }
+
+    @Test
+    public void givenUsingPlainJava_whenGeneratingRandomStringBounded_thenCorrect() {
+        final int leftLimit = 97; // letter 'a'
+        final int rightLimit = 122; // letter 'z'
+        final int targetStringLength = 10;
+        final Random random = new Random();
+        final StringBuilder buffer = new StringBuilder(targetStringLength);
+
+        for (int i = 0; i < targetStringLength; i++) {
+            final int randomLimitedInt = leftLimit + (int) (random.nextFloat() * (rightLimit - leftLimit + 1));
+            buffer.append((char) randomLimitedInt);
+        }
+        final String generatedString = buffer.toString();
+
+        LOG.debug(generatedString);
+    }
+
+    @Test
+    public void givenUsingApache_whenGeneratingRandomString_thenCorrect() {
+        final String generatedString = RandomStringUtils.random(10);
+
+        LOG.debug(generatedString);
+    }
+
+    @Test
+    public void givenUsingApache_whenGeneratingRandomAlphabeticString_thenCorrect() {
+        final String generatedString = RandomStringUtils.randomAlphabetic(10);
+
+        LOG.debug(generatedString);
+    }
+
+    @Test
+    public void givenUsingApache_whenGeneratingRandomAlphanumericString_thenCorrect() {
+        final String generatedString = RandomStringUtils.randomAlphanumeric(10);
+
+        LOG.debug(generatedString);
+    }
+
+    @Test
+    public void givenUsingApache_whenGeneratingRandomStringBounded_thenCorrect() {
+        final int length = 10;
+        final boolean useLetters = true;
+        final boolean useNumbers = false;
+        final String generatedString = RandomStringUtils.random(length, useLetters, useNumbers);
+
+        LOG.debug(generatedString);
+    }
+
+}