Skip to content

Commit d8b0fd5

Browse files
aitorcuestamaibin
aitorcuesta
authored and
maibin
committed
BAEL-3678 - Generating Random Numbers - Initial commit (#8491)
* BAEL-3678 - Initial commit * BAEL-3678 - Test added * BAEL-3678 - Generated multiple methods and tests * BAEL-3678 - Test improvement
1 parent e5b4048 commit d8b0fd5

3 files changed

Lines changed: 233 additions & 0 deletions

File tree

‎java-numbers-2/pom.xml‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -21,6 +21,11 @@
2121
<artifactId>jmh-generator-annprocess</artifactId>
2222
<version>${jmh-generator.version}</version>
2323
</dependency>
24+
<dependency>
25+
<groupId>it.unimi.dsi</groupId>
26+
<artifactId>dsiutils</artifactId>
27+
<version>2.6.0</version>
28+
</dependency>
2429
</dependencies>
2530

2631
<build>

‎java-numbers-2/src/main/java/com/baeldung/randomnumbers/RandomNumbersGenerator.java‎

Lines changed: 91 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,91 @@
1+
package com.baeldung.randomnumbers;
2+
3+
import java.security.SecureRandom;
4+
import java.util.Random;
5+
import java.util.SplittableRandom;
6+
import java.util.concurrent.ThreadLocalRandom;
7+
import java.util.stream.IntStream;
8+
9+
import org.apache.commons.math3.random.RandomDataGenerator;
10+
11+
import it.unimi.dsi.util.XoRoShiRo128PlusRandom;
12+
13+
public class RandomNumbersGenerator {
14+
15+
public Integer generateRandomWithMathRandom(int max, int min) {
16+
return (int) ((Math.random() * (max - min)) + min);
17+
}
18+
19+
public Integer generateRandomWithNextInt() {
20+
Random random = new Random();
21+
int randomWithNextInt = random.nextInt();
22+
return randomWithNextInt;
23+
}
24+
25+
public Integer generateRandomWithNextIntWithinARange(int min, int max) {
26+
Random random = new Random();
27+
int randomWintNextIntWithinARange = random.nextInt(max - min) + min;
28+
return randomWintNextIntWithinARange;
29+
}
30+
31+
public IntStream generateRandomUnlimitedIntStream() {
32+
Random random = new Random();
33+
IntStream unlimitedIntStream = random.ints();
34+
return unlimitedIntStream;
35+
}
36+
37+
public IntStream generateRandomLimitedIntStream(long streamSize) {
38+
Random random = new Random();
39+
IntStream limitedIntStream = random.ints(streamSize);
40+
return limitedIntStream;
41+
}
42+
43+
public IntStream generateRandomLimitedIntStreamWithinARange(int min, int max, long streamSize) {
44+
Random random = new Random();
45+
IntStream limitedIntStreamWithinARange = random.ints(streamSize, min, max);
46+
return limitedIntStreamWithinARange;
47+
}
48+
49+
public Integer generateRandomWithThreadLocalRandom() {
50+
int randomWithThreadLocalRandom = ThreadLocalRandom.current()
51+
.nextInt();
52+
return randomWithThreadLocalRandom;
53+
}
54+
55+
public Integer generateRandomWithThreadLocalRandomInARange(int min, int max) {
56+
int randomWithThreadLocalRandomInARange = ThreadLocalRandom.current()
57+
.nextInt(min, max);
58+
return randomWithThreadLocalRandomInARange;
59+
}
60+
61+
public Integer generateRandomWithThreadLocalRandomFromZero(int max) {
62+
int randomWithThreadLocalRandomFromZero = ThreadLocalRandom.current()
63+
.nextInt(max);
64+
return randomWithThreadLocalRandomFromZero;
65+
}
66+
67+
public Integer generateRandomWithSplittableRandom(int min, int max) {
68+
SplittableRandom splittableRandom = new SplittableRandom();
69+
int randomWithSplittableRandom = splittableRandom.nextInt(min, max);
70+
return randomWithSplittableRandom;
71+
}
72+
73+
public Integer generateRandomWithSecureRandom() {
74+
SecureRandom secureRandom = new SecureRandom();
75+
int randomWithSecureRandom = secureRandom.nextInt();
76+
return randomWithSecureRandom;
77+
}
78+
79+
public Integer generateRandomWithRandomDataGenerator(int min, int max) {
80+
RandomDataGenerator randomDataGenerator = new RandomDataGenerator();
81+
int randomWithRandomDataGenerator = randomDataGenerator.nextInt(min, max);
82+
return randomWithRandomDataGenerator;
83+
}
84+
85+
public Integer generateRandomWithXoRoShiRo128PlusRandom(int min, int max) {
86+
XoRoShiRo128PlusRandom xoroRandom = new XoRoShiRo128PlusRandom();
87+
int randomWithXoRoShiRo128PlusRandom = xoroRandom.nextInt(max - min) + min;
88+
return randomWithXoRoShiRo128PlusRandom;
89+
}
90+
91+
}

‎java-numbers-2/src/test/java/com/baeldung/randomnumbers/RandomNumbersGeneratorUnitTest.java‎

Lines changed: 137 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,137 @@
1+
package com.baeldung.randomnumbers;
2+
3+
import static org.junit.Assert.assertNotNull;
4+
import static org.junit.Assert.assertTrue;
5+
6+
import java.util.stream.IntStream;
7+
8+
import org.junit.Test;
9+
10+
public class RandomNumbersGeneratorUnitTest {
11+
12+
private static final int MIN_RANGE = 1;
13+
private static final int MAX_RANGE = 10;
14+
private static final int ITERATIONS = 50;
15+
private static final long STREAM_SIZE = 50;
16+
17+
@Test
18+
public void whenGenerateRandomWithMathRandom_returnsSuccessfully() {
19+
RandomNumbersGenerator generator = new RandomNumbersGenerator();
20+
for (int i = 0; i < ITERATIONS; i++) {
21+
int randomNumer = generator.generateRandomWithMathRandom(MIN_RANGE, MAX_RANGE);
22+
assertTrue(isInRange(randomNumer, Integer.MIN_VALUE, Integer.MAX_VALUE));
23+
}
24+
}
25+
26+
@Test
27+
public void whenGenerateRandomWithNextInt_returnsSuccessfully() {
28+
RandomNumbersGenerator generator = new RandomNumbersGenerator();
29+
for (int i = 0; i < ITERATIONS; i++) {
30+
int randomNumber = generator.generateRandomWithNextInt();
31+
assertTrue(isInRange(randomNumber, Integer.MIN_VALUE, Integer.MAX_VALUE));
32+
}
33+
}
34+
35+
@Test
36+
public void whenGenerateRandomWithNextIntWithinARange_returnsSuccessfully() {
37+
RandomNumbersGenerator generator = new RandomNumbersGenerator();
38+
for (int i = 0; i < ITERATIONS; i++) {
39+
int randomNumber = generator.generateRandomWithNextIntWithinARange(MIN_RANGE, MAX_RANGE);
40+
assertTrue(isInRange(randomNumber, MIN_RANGE, MAX_RANGE));
41+
}
42+
}
43+
44+
@Test
45+
public void whenGenerateRandomUnlimitedIntStream_returnsSuccessfully() {
46+
RandomNumbersGenerator generator = new RandomNumbersGenerator();
47+
IntStream stream = generator.generateRandomUnlimitedIntStream();
48+
assertNotNull(stream);
49+
Integer randomNumber = stream.findFirst()
50+
.getAsInt();
51+
assertNotNull(randomNumber);
52+
assertTrue(isInRange(randomNumber, Integer.MIN_VALUE, Integer.MAX_VALUE));
53+
}
54+
55+
@Test
56+
public void whenGenerateRandomLimitedIntStream_returnsSuccessfully() {
57+
RandomNumbersGenerator generator = new RandomNumbersGenerator();
58+
generator.generateRandomLimitedIntStream(STREAM_SIZE)
59+
.forEach(randomNumber -> assertTrue(isInRange(randomNumber, Integer.MIN_VALUE, Integer.MAX_VALUE)));
60+
}
61+
62+
@Test
63+
public void whenGenerateRandomLimitedIntStreamWithinARange_returnsSuccessfully() {
64+
RandomNumbersGenerator generator = new RandomNumbersGenerator();
65+
generator.generateRandomLimitedIntStreamWithinARange(MIN_RANGE, MAX_RANGE, STREAM_SIZE)
66+
.forEach(randomNumber -> assertTrue(isInRange(randomNumber, MIN_RANGE, MAX_RANGE)));
67+
}
68+
69+
@Test
70+
public void whenGenerateRandomWithThreadLocalRandom_returnsSuccessfully() {
71+
RandomNumbersGenerator generator = new RandomNumbersGenerator();
72+
for (int i = 0; i < ITERATIONS; i++) {
73+
int randomNumber = generator.generateRandomWithThreadLocalRandom();
74+
assertTrue(isInRange(randomNumber, Integer.MIN_VALUE, Integer.MAX_VALUE));
75+
}
76+
}
77+
78+
@Test
79+
public void whenGenerateRandomWithThreadLocalRandomInARange_returnsSuccessfully() {
80+
RandomNumbersGenerator generator = new RandomNumbersGenerator();
81+
for (int i = 0; i < ITERATIONS; i++) {
82+
int randomNumber = generator.generateRandomWithThreadLocalRandomInARange(MIN_RANGE, MAX_RANGE);
83+
assertTrue(isInRange(randomNumber, MIN_RANGE, MAX_RANGE));
84+
}
85+
}
86+
87+
@Test
88+
public void whenGenerateRandomWithThreadLocalRandomFromZero_returnsSuccessfully() {
89+
RandomNumbersGenerator generator = new RandomNumbersGenerator();
90+
for (int i = 0; i < ITERATIONS; i++) {
91+
int randomNumber = generator.generateRandomWithThreadLocalRandomFromZero(MAX_RANGE);
92+
assertTrue(isInRange(randomNumber, 0, MAX_RANGE));
93+
}
94+
}
95+
96+
@Test
97+
public void whenGenerateRandomWithSplittableRandom_returnsSuccessfully() {
98+
RandomNumbersGenerator generator = new RandomNumbersGenerator();
99+
for (int i = 0; i < ITERATIONS; i++) {
100+
int randomNumber = generator.generateRandomWithSplittableRandom(MIN_RANGE, MAX_RANGE);
101+
assertTrue(isInRange(randomNumber, MIN_RANGE, MAX_RANGE));
102+
}
103+
}
104+
105+
@Test
106+
public void whenGenerateRandomWithSecureRandom_returnsSuccessfully() {
107+
RandomNumbersGenerator generator = new RandomNumbersGenerator();
108+
for (int i = 0; i < ITERATIONS; i++) {
109+
int randomNumber = generator.generateRandomWithSecureRandom();
110+
assertTrue(isInRange(randomNumber, Integer.MIN_VALUE, Integer.MAX_VALUE));
111+
}
112+
}
113+
114+
@Test
115+
public void whenGenerateRandomWithRandomDataGenerator_returnsSuccessfully() {
116+
RandomNumbersGenerator generator = new RandomNumbersGenerator();
117+
for (int i = 0; i < ITERATIONS; i++) {
118+
int randomNumber = generator.generateRandomWithRandomDataGenerator(MIN_RANGE, MAX_RANGE);
119+
// RandomDataGenerator top is inclusive
120+
assertTrue(isInRange(randomNumber, MIN_RANGE, MAX_RANGE + 1));
121+
}
122+
}
123+
124+
@Test
125+
public void whenGenerateRandomWithXoRoShiRo128PlusRandom_returnsSuccessfully() {
126+
RandomNumbersGenerator generator = new RandomNumbersGenerator();
127+
for (int i = 0; i < ITERATIONS; i++) {
128+
int randomNumber = generator.generateRandomWithXoRoShiRo128PlusRandom(MIN_RANGE, MAX_RANGE);
129+
assertTrue(isInRange(randomNumber, MIN_RANGE, MAX_RANGE));
130+
}
131+
}
132+
133+
private boolean isInRange(int number, int min, int max) {
134+
return min <= number && number < max;
135+
}
136+
137+
}

0 commit comments

Comments
 (0)