From 31466db6ecd115aa74616e14a75721b45c0f59f9 Mon Sep 17 00:00:00 2001
From: Vincent Potucek <vincent.potucek@1und1.de>
Date: Mon, 12 Oct 2015 09:47:40 +0200
Subject: [PATCH] Add sugar to RandomIUtils

---
 .../org/apache/commons/lang3/RandomUtils.java | 45 ++++++++++++++++---
 .../apache/commons/lang3/RandomUtilsTest.java | 43 +++++++++++++++++-
 2 files changed, 81 insertions(+), 7 deletions(-)

diff --git a/src/main/java/org/apache/commons/lang3/RandomUtils.java b/src/main/java/org/apache/commons/lang3/RandomUtils.java
index 6bba2747f..16188c6b2 100644
--- a/src/main/java/org/apache/commons/lang3/RandomUtils.java
+++ b/src/main/java/org/apache/commons/lang3/RandomUtils.java
@@ -90,6 +90,15 @@ public static int nextInt(final int startInclusive, final int endExclusive) {
         
         return startInclusive + RANDOM.nextInt(endExclusive - startInclusive);
     }
+
+    /**
+     * <p> Returns a random int within 0 - Integer.MAX_VALUE </p>
+     *
+     * @see #nextInt()
+     */
+    public static int nextInt() {
+        return nextInt(0, Integer.MAX_VALUE);
+    }
     
     /**
      * <p>
@@ -115,8 +124,16 @@ public static long nextLong(final long startInclusive, final long endExclusive)
         }
 
         return (long) nextDouble(startInclusive, endExclusive);
-    }    
-    
+    }
+
+    /**
+     * <p> Returns a random long within 0 - Long.MAX_VALUE </p>
+     *
+     * @see #nextLong()
+     */
+    public static long nextLong() {
+        return nextLong(0, Long.MAX_VALUE);
+    }
     
     /**
      * <p> 
@@ -136,14 +153,23 @@ public static double nextDouble(final double startInclusive, final double endInc
         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());
     }
-    
+
+    /**
+     * <p> Returns a random double within 0 - Double.MAX_VALUE </p>
+     *
+     * @see #nextDouble()
+     */
+    public static double nextDouble() {
+        return nextDouble(0, Double.MAX_VALUE);
+    }
+
     /**
      * <p>
      * Returns a random float within the specified range.
@@ -168,5 +194,14 @@ public static float nextFloat(final float startInclusive, final float endInclusi
         }
         
         return startInclusive + ((endInclusive - startInclusive) * RANDOM.nextFloat());
-    }    
+    }
+
+    /**
+     * <p> Returns a random float within 0 - Float.MAX_VALUE </p>
+     *
+     * @see #nextFloat()
+     */
+    public static float nextFloat() {
+        return nextFloat(0, Float.MAX_VALUE);
+    }
 }
diff --git a/src/test/java/org/apache/commons/lang3/RandomUtilsTest.java b/src/test/java/org/apache/commons/lang3/RandomUtilsTest.java
index a2aa06395..e1108e50b 100644
--- a/src/test/java/org/apache/commons/lang3/RandomUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/RandomUtilsTest.java
@@ -111,6 +111,16 @@ public void testNextInt() {
         final int result = RandomUtils.nextInt(33, 42);
         assertTrue(result >= 33 && result < 42);
     }
+
+    /**
+     * Tests next double range, random result.
+     */
+    @Test
+    public void testNextIntRandomResult() {
+        int randomResult = RandomUtils.nextInt();
+        assertTrue(randomResult > 0);
+        assertTrue(randomResult < Integer.MAX_VALUE);
+    }
     
     /**
      * Test next double range with minimal range.
@@ -136,6 +146,16 @@ public void testNextDouble() {
         final double result = RandomUtils.nextDouble(33d, 42d);
         assertTrue(result >= 33d && result <= 42d);
     }
+
+    /**
+     * Tests next double range, random result.
+     */
+    @Test
+    public void testNextDoubleRandomResult() {
+        double randomResult = RandomUtils.nextDouble();
+        assertTrue(randomResult > 0);
+        assertTrue(randomResult < Double.MAX_VALUE);
+    }
     
     /**
      * Tests next float range.
@@ -144,7 +164,17 @@ public void testNextDouble() {
     public void testNextFloat() {
         final double result = RandomUtils.nextFloat(33f, 42f);
         assertTrue(result >= 33f && result <= 42f);
-    }    
+    }
+
+    /**
+     * Tests next float range, random result.
+     */
+    @Test
+    public void testNextFloatRandomResult() {
+        float randomResult = RandomUtils.nextFloat();
+        assertTrue(randomResult > 0);
+        assertTrue(randomResult < Float.MAX_VALUE);
+    }
 
     /**
      * Test next long range with minimal range.
@@ -162,7 +192,16 @@ public void testNextLong() {
         final long result = RandomUtils.nextLong(33L, 42L);
         assertTrue(result >= 33L && result < 42L);
     }
-    
+
+    /**
+     * Tests next long range, random result.
+     */
+    @Test
+    public void testNextLongRandomResult() {
+        long randomResult = RandomUtils.nextLong();
+        assertTrue(randomResult > 0);
+        assertTrue(randomResult < Long.MAX_VALUE);
+    }
     
     /**
      * Tests extreme range.