Repeatable random object on the same seed

easy-random-core/src/main/java/org/jeasy/random/FieldPopulator.java

@@ -32,7 +32,6 @@
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Type;
 
-import static org.jeasy.random.util.CollectionUtils.randomElementOf;
 import static org.jeasy.random.util.ReflectionUtils.*;
 
 /**
@@ -128,7 +127,7 @@ private Object generateRandomValue(final Field field, final RandomizationContext
             value = mapPopulator.getRandomMap(field, context);
         } else {
             if (context.getParameters().isScanClasspathForConcreteTypes() && isAbstract(fieldType) && !isEnumType(fieldType) /*enums can be abstract, but can not inherit*/) {
-                Class<?> randomConcreteSubType = randomElementOf(filterSameParameterizedTypes(getPublicConcreteSubTypesOf(fieldType), fieldGenericType));
+                Class<?> randomConcreteSubType = context.randomElementOf(filterSameParameterizedTypes(getPublicConcreteSubTypesOf(fieldType), fieldGenericType));
                 if (randomConcreteSubType == null) {
                     throw new ObjectCreationException("Unable to find a matching concrete subtype of type: " + fieldType);
                 } else {

easy-random-core/src/main/java/org/jeasy/random/ObjenesisObjectFactory.java

@@ -30,7 +30,6 @@
 
 import java.lang.reflect.Constructor;
 
-import static org.jeasy.random.util.CollectionUtils.randomElementOf;
 import static org.jeasy.random.util.ReflectionUtils.getPublicConcreteSubTypesOf;
 import static org.jeasy.random.util.ReflectionUtils.isAbstract;
 
@@ -47,7 +46,7 @@ class ObjenesisObjectFactory implements ObjectFactory {
     @Override
     public <T> T createInstance(Class<T> type, RandomizerContext context) {
         if (context.getParameters().isScanClasspathForConcreteTypes() && isAbstract(type)) {
-            Class<?> randomConcreteSubType = randomElementOf(getPublicConcreteSubTypesOf((type)));
+            Class<?> randomConcreteSubType = context.randomElementOf(getPublicConcreteSubTypesOf((type)));
             if (randomConcreteSubType == null) {
                 throw new InstantiationError("Unable to find a matching concrete subtype of type: " + type + " in the classpath");
             } else {

easy-random-core/src/main/java/org/jeasy/random/RandomizationContext.java

@@ -46,13 +46,16 @@ class RandomizationContext implements RandomizerContext {
 
     private final Class<?> type;
 
+    private final Random random;
+
     private Object rootObject;
 
     RandomizationContext(final Class<?> type, final EasyRandomParameters parameters) {
         this.type = type;
         populatedBeans = new IdentityHashMap<>();
         stack = new Stack<>();
         this.parameters = parameters;
+        this.random = new Random(parameters.getSeed());
     }
 
     void addPopulatedBean(final Class<?> type, Object object) {
@@ -105,7 +108,7 @@ private List<String> toLowerCase(final List<String> strings) {
     }
 
     private int nextInt(int startInclusive, int endExclusive) {
-        return startInclusive + new Random().nextInt(endExclusive - startInclusive);
+        return startInclusive + random.nextInt(endExclusive - startInclusive);
     }
 
     void setRandomizedObject(Object randomizedObject) {
@@ -148,4 +151,12 @@ public Object getRootObject() {
     public EasyRandomParameters getParameters() {
         return parameters;
     }
+
+    @Override
+    public <T> T randomElementOf(List<T> list) {
+        if (list.isEmpty()) {
+            return null;
+        }
+        return list.get(nextInt(0, list.size()));
+    }
 }

easy-random-core/src/main/java/org/jeasy/random/api/RandomizerContext.java

@@ -23,6 +23,7 @@
  */
 package org.jeasy.random.api;
 
+import java.util.List;
 import org.jeasy.random.EasyRandom;
 import org.jeasy.random.EasyRandomParameters;
 
@@ -70,4 +71,12 @@ public interface RandomizerContext {
      */
     EasyRandomParameters getParameters();
 
+    /**
+     * Get a random element from the list.
+     *
+     * @param list the input list
+     * @param <T>  the type of elements in the list
+     * @return a random element from the list or null if the list is empty
+     */
+    <T> T randomElementOf(List<T> list);
 }

easy-random-core/src/test/java/org/jeasy/random/RandomizationContextTest.java

@@ -25,6 +25,7 @@
 
 import static java.lang.annotation.ElementType.FIELD;
 import static java.lang.annotation.RetentionPolicy.RUNTIME;
+import static java.util.Arrays.asList;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.jeasy.random.FieldPredicates.named;
 import static org.mockito.Mockito.when;
@@ -187,6 +188,19 @@ void testRandomizerContext() {
         assertThat(a.b.e.name).isEqualTo("bar");
     }
 
+    @Test
+    void testRandomElementOf() {
+        // Given
+        String[] elements = {"foo", "bar"};
+
+        // When
+        RandomizationContext context = new RandomizationContext(Object.class, parameters);
+        String element = context.randomElementOf(asList(elements));
+
+        // Then
+        assertThat(element).isIn(elements);
+    }
+
     static class MyRandomizer implements ContextAwareRandomizer<D> {
 
         private RandomizerContext context;

easy-random-core/src/test/java/org/jeasy/random/RepeatableRandomTest.java

@@ -0,0 +1,170 @@
+/*
+ * The MIT License
+ *
+ *   Copyright (c) 2020, Mahmoud Ben Hassine (mahmoud.benhassine@icloud.com)
+ *
+ *   Permission is hereby granted, free of charge, to any person obtaining a copy
+ *   of this software and associated documentation files (the "Software"), to deal
+ *   in the Software without restriction, including without limitation the rights
+ *   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *   copies of the Software, and to permit persons to whom the Software is
+ *   furnished to do so, subject to the following conditions:
+ *
+ *   The above copyright notice and this permission notice shall be included in
+ *   all copies or substantial portions of the Software.
+ *
+ *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ *   THE SOFTWARE.
+ */
+package org.jeasy.random;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.ThreadLocalRandom;
+import org.junit.jupiter.api.Test;
+
+public class RepeatableRandomTest {
+
+    @Test
+    public void validateEqualsAndHashCodeSameRandomInstancePoolSize1() {
+        for (int i = 0; i < 3; i++) {
+            validateEqualsAndHashCodeSameRandomInstanceImpl(1);
+        }
+    }
+
+    @Test
+    public void validateEqualsAndHashCodeSameRandomInstancePoolSize3() {
+        for (int i = 0; i < 3; i++) {
+            validateEqualsAndHashCodeSameRandomInstanceImpl(3);
+        }
+    }
+
+    private void validateEqualsAndHashCodeSameRandomInstanceImpl(int poolSize) {
+        long seed = ThreadLocalRandom.current().nextLong();
+
+        Object instance1 = randomInstance(Pojo.class, seed, poolSize);
+        // same seed - hence same object expected
+        Object instance2 = randomInstance(Pojo.class, seed, poolSize);
+
+        assertThat(instance1)
+                .isEqualTo(instance2);
+        assertThat(instance1.hashCode())
+                .isEqualTo(instance2.hashCode());
+    }
+
+    private Object randomInstance(Class<?> type, long seed, int poolSize) {
+        EasyRandom easyRandom = new EasyRandom(new EasyRandomParameters()
+                .objectPoolSize(poolSize)
+                .seed(seed)
+                .stringLengthRange(3, 5)
+                .collectionSizeRange(3, 4));
+        return easyRandom.nextObject(type);
+    }
+
+    public static class Pojo {
+
+        private String id;
+
+        private List<PojoA> a;
+
+        private List<PojoB> b;
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) {
+                return true;
+            }
+            if (o == null || getClass() != o.getClass()) {
+                return false;
+            }
+            Pojo that = (Pojo) o;
+            return id.equals(that.id)
+                    && a.equals(that.a)
+                    && b.equals(that.b);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(id, a, b);
+        }
+
+        @Override
+        public String toString() {
+            return "Pojo{" +
+                    "id='" + id + '\'' +
+                    ", a=" + a +
+                    ", b=" + b +
+                    '}';
+        }
+    }
+
+    public static class PojoA {
+
+        private String s;
+
+        // equals/hashCode/toString by id to avoid possible stack overflow
+        private Pojo root;
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) {
+                return true;
+            }
+            if (o == null || getClass() != o.getClass()) {
+                return false;
+            }
+            PojoA that = (PojoA) o;
+            return s.equals(that.s)
+                    && root.id.equals(that.root.id);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(s, root.id);
+        }
+
+        @Override
+        public String toString() {
+            return "PojoA{" +
+                    "s='" + s + '\'' +
+                    ", root.id=" + root.id +
+                    '}';
+        }
+    }
+
+    public static class PojoB {
+
+        private String s;
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) {
+                return true;
+            }
+            if (o == null || getClass() != o.getClass()) {
+                return false;
+            }
+            PojoB that = (PojoB) o;
+            return s.equals(that.s);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(s);
+        }
+
+        @Override
+        public String toString() {
+            return "PojoB{" +
+                    "s='" + s + '\'' +
+                    '}';
+        }
+    }
+}