Apache
/
commons-lang
mirror of https://github.com/apache/commons-lang.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

LANG-900: New RandumUtils class. Thanks to Duncan Jones 

git-svn-id: https://svn.apache.org/repos/asf/commons/proper/lang/trunk@1557434 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Benedikt Ritter 2014-01-11 19:10:13 +00:00
parent 8ea0c02848
commit b05a81debb
3 changed files with 370 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/changes/changes.xml
View File

@ -22,6 +22,7 @@
<body>
<release version="3.2.2" date="TBA" description="Bug fix for 3.2.1">
<action issue="LANG-900" type="add" dev="britter" due-to="Duncan Jones">New RandomUtils class</action>
<action issue="LANG-915" type="fix" dev="britter" due-to="Sergio Fernández">Wrong locale handling in LocaleUtils.toLocale()</action>
</release>

159
src/main/java/org/apache/commons/lang3/RandomUtils.java Normal file
View File

@ -0,0 +1,159 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.lang3;
import java.util.Random;
/**
* Utility library that supplements the standard {@link Random} class.
*
* @since 3.3
*
* @version $Id$
*/
public class RandomUtils {
/**
* Random object used by random method. This has to be not local to the
* random method so as to not return the same value in the same millisecond.
*/
private static final Random RANDOM = new Random();
/**
* <p>
* {@code RandomUtils} instances should NOT be constructed in standard
* programming. Instead, the class should be used as
* {@code RandomUtils.nextBytes(5);}.
* </p>
*
* <p>
* This constructor is public to permit tools that require a JavaBean
* instance to operate.
* </p>
*/
public RandomUtils() {
super();
}
/**
* Creates a array of the specified length filled with random bytes.
*
* @param count
* the size of the returned array
* @return the random byte array
*/
public static byte[] nextBytes(int count) {
Validate.isTrue(count >= 0, "Count cannot be negative.");
byte[] result = new byte[count];
RANDOM.nextBytes(result);
return result;
}
/**
* Returns a random integer within the specified range.
*
* @param startInclusive
* the smallest value that can be returned, must be non-negative
* @param endExclusive
* the upper bound (not included), must be non-negative
* @throws IllegalArgumentException
* if {@code startInclusive > endInclusive}
* @return the random integer
*/
public static int nextInt(int startInclusive, int endExclusive) {
Validate.isTrue(endExclusive >= startInclusive,
"Start value must be smaller or equal to end value.");
Validate.isTrue(startInclusive >= 0, "Both range values must be non-negative.");
if (startInclusive == endExclusive) {
return startInclusive;
}
return startInclusive + RANDOM.nextInt(endExclusive - startInclusive);
}
/**
* Returns a random long within the specified range.
*
* @param startInclusive
* the smallest value that can be returned, must be non-negative
* @param endExclusive
* the upper bound (not included), must be non-negative
* @throws IllegalArgumentException
* if {@code startInclusive > endInclusive}
* @return the random long
*/
public static long nextLong(long startInclusive, long endExclusive) {
Validate.isTrue(endExclusive >= startInclusive,
"Start value must be smaller or equal to end value.");
Validate.isTrue(startInclusive >= 0, "Both range values must be non-negative.");
if (startInclusive == endExclusive) {
return startInclusive;
}
return (long) nextDouble(startInclusive, endExclusive);
}
/**
* Returns a random double within the specified range.
*
* @param startInclusive
* the smallest value that can be returned, must be non-negative
* @param endInclusive
* the upper bound (included), must be non-negative
* @throws IllegalArgumentException
* if {@code startInclusive > endInclusive}
* @return the random double
*/
public static double nextDouble(double startInclusive, double endInclusive) {
Validate.isTrue(endInclusive >= startInclusive,
"Start value must be smaller or equal to end value.");
Validate.isTrue(startInclusive >= 0, "Both range values must be non-negative.");
if (startInclusive == endInclusive) {
return startInclusive;
}
return startInclusive + ((endInclusive - startInclusive) * RANDOM.nextDouble());
}
/**
* Returns a random float within the specified range.
*
* @param startInclusive
* the smallest value that can be returned, must be non-negative
* @param endInclusive
* the upper bound (included), must be non-negative
* @throws IllegalArgumentException
* if {@code startInclusive > endInclusive}
* @return the random float
*/
public static float nextFloat(float startInclusive, float endInclusive) {
Validate.isTrue(endInclusive >= startInclusive,
"Start value must be smaller or equal to end value.");
Validate.isTrue(startInclusive >= 0, "Both range values must be non-negative.");
if (startInclusive == endInclusive) {
return startInclusive;
}
return startInclusive + ((endInclusive - startInclusive) * RANDOM.nextFloat());
}
}

210
src/test/java/org/apache/commons/lang3/RandomUtilsTest.java Normal file
View File

@ -0,0 +1,210 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.lang3;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import org.junit.Test;
/**
* Tests for {@link RandomUtils}
*
* @version $Id$
*/
public class RandomUtilsTest {
/**
* For comparing doubles and floats
*/
private static final double DELTA = 1e-5;
/**
* Tests exceptions
*/
@Test
public void testExceptions() throws Exception {
try {
RandomUtils.nextBytes(-1);
fail();
} catch (IllegalArgumentException e) {}
try {
RandomUtils.nextInt(2, 1);
fail();
} catch (IllegalArgumentException e) {}
try {
RandomUtils.nextDouble(2, 1);
fail();
} catch (IllegalArgumentException e) {}
try {
RandomUtils.nextLong(2, 1);
fail();
} catch (IllegalArgumentException e) {}
try {
RandomUtils.nextFloat(2, 1);
fail();
} catch (IllegalArgumentException e) {}
try {
RandomUtils.nextInt(-1, 1);
fail();
} catch (IllegalArgumentException e) {}
try {
RandomUtils.nextDouble(-1, 1);
fail();
} catch (IllegalArgumentException e) {}
try {
RandomUtils.nextLong(-1, 1);
fail();
} catch (IllegalArgumentException e) {}
try {
RandomUtils.nextFloat(-1, 1);
fail();
} catch (IllegalArgumentException e) {}
}
/**
* Tests a zero byte array length.
*/
@Test
public void testZeroLengthNextBytes() throws Exception {
assertArrayEquals(new byte[0], RandomUtils.nextBytes(0));
}
/**
* Tests random byte array.
*/
@Test
public void testNextBytes() throws Exception {
byte[] result = RandomUtils.nextBytes(20);
assertEquals(20, result.length);
}
/**
* Test next int range with minimal range.
*/
@Test
public void testNextIntMinimalRange() throws Exception {
assertEquals(42, RandomUtils.nextInt(42, 42));
}
/**
* Tests next int range.
*/
@Test
public void testNextInt() throws Exception {
int result = RandomUtils.nextInt(33, 42);
assertTrue(result >= 33 && result < 42);
}
/**
* Test next double range with minimal range.
*/
@Test
public void testNextDoubleMinimalRange() throws Exception {
assertEquals(42.1, RandomUtils.nextDouble(42.1, 42.1), DELTA);
}
/**
* Test next float range with minimal range.
*/
@Test
public void testNextFloatMinimalRange() throws Exception {
assertEquals(42.1f, RandomUtils.nextFloat(42.1f, 42.1f), DELTA);
}
/**
* Tests next double range.
*/
@Test
public void testNextDouble() throws Exception {
double result = RandomUtils.nextDouble(33d, 42d);
assertTrue(result >= 33d && result <= 42d);
}
/**
* Tests next float range.
*/
@Test
public void testNextFloat() throws Exception {
double result = RandomUtils.nextFloat(33f, 42f);
assertTrue(result >= 33f && result <= 42f);
}
/**
* Test next long range with minimal range.
*/
@Test
public void testNextLongMinimalRange() throws Exception {
assertEquals(42L, RandomUtils.nextLong(42L, 42L));
}
/**
* Tests next long range.
*/
@Test
public void testNextLong() throws Exception {
long result = RandomUtils.nextLong(33L, 42L);
assertTrue(result >= 33L && result < 42L);
}
/**
* Tests extreme range.
*/
@Test
public void testExtremeRangeInt() throws Exception {
int result = RandomUtils.nextInt(0, Integer.MAX_VALUE);
assertTrue(result >= 0 && result < Integer.MAX_VALUE);
}
/**
* Tests extreme range.
*/
@Test
public void testExtremeRangeLong() throws Exception {
long result = RandomUtils.nextLong(0, Long.MAX_VALUE);
assertTrue(result >= 0 && result < Long.MAX_VALUE);
}
/**
* Tests extreme range.
*/
@Test
public void testExtremeRangeFloat() throws Exception {
float result = RandomUtils.nextFloat(0, Float.MAX_VALUE);
assertTrue(result >= 0f && result <= Float.MAX_VALUE);
}
/**
* Tests extreme range.
*/
@Test
public void testExtremeRangeDouble() throws Exception {
double result = RandomUtils.nextDouble(0, Double.MAX_VALUE);
assertTrue(result >= 0 && result <= Double.MAX_VALUE);
}
}