-
Notifications
You must be signed in to change notification settings - Fork 233
Randomization parameters
The EasyRandomParameters
is the main entry point to set all parameters of how to generate values:
EasyRandomParameters parameters = new EasyRandomParameters()
.seed(123L)
.objectPoolSize(100)
.randomizationDepth(3)
.charset(forName("UTF-8"))
.timeRange(nine, five)
.dateRange(today, tomorrow)
.stringLengthRange(5, 50)
.collectionSizeRange(1, 10)
.scanClasspathForConcreteTypes(true)
.overrideDefaultInitialization(false)
.ignoreRandomizationErrors(true)
.bypassSetters(true);
These parameters will be applied to all fields of the object graph.
The collectionSizeRange
parameter lets you bound the generated collections size.
Setting the stringLengthRange
parameter tells Easy Random to generate random strings with a bounded size.
You can use the charset
parameter to generate random values from the specified Charset
in all character-based fields, basically strings and characters. This parameter will be applied to all String
and Character
fields in the object graph.
You can use the dateRange
and timeRange
parameters to generate Date and Time values in a given range.
EasyRandom
can be configured with a seed
in order to generate the same random instances.
Using the same seed, each run will produce the same value. This feature is useful when you want stable random values across JVM restarts (for repeatable tests for instance).
When the target object declares a field of an abstract or interface type, Easy Random will throw an ObjectGenerationException
saying that it was unable to create a random instance of the abstract/interface type.
The scanClasspathForConcreteTypes
parameter tells Easy Random to scan the classpath and look for a concrete type of the abstract/interface field. Let's see a quick example:
abstract class Bar {}
class ConcreteBar extends Bar {}
class Foo {
private Bar bar;
}
Let's try to generate a random instance of type Foo
:
EasyRandomParameters parameters = new EasyRandomParameters().scanClasspathForConcreteTypes(true);
EasyRandom easyRandom = new EasyRandom(parameters);
Foo foo = easyRandom.nextObject(Foo.class);
In the generated Foo
instance, the bar
field will be assigned a random instance of the ConcreteBar
type.
Without setting the scanClasspathForConcreteTypes
parameter, Easy Random will throw an ObjectGenerationException
Heads up: Please note that Easy Random will be in best effort mode when this parameter is activated. If a concrete type is found in the classpath, it is not guaranteed that Easy Random will be able to randomize it, in which case it will still throw an exception. In this case, you need to provide a custom randomizer for the abstract/interface type.
By default, Easy Random does not randomise fields that are already initialized:
public class Bean {
Set<String> strings = new HashSet<>();
List<Integer> integers = Arrays.asList(1, 2, 3);
public BeanWithDefaultValues() {
}
}
If you randomize an instance of this Bean
class, the strings
field will be empty, and the integers
fields will be equal to the list containing 1, 2 and 3.
If you want to override this default initialization and randomize these fields, you need to set the overrideDefaultInitialization
parameter.
When a type declares a field of the same type, Easy Random will not be able to generate a random object graph due to infinite recursion. Here is an example:
class Person {
private String name;
private Person parent;
}
To avoid infinite recursion, Easy Random provides the objectPoolSize
parameter. This parameter limits the number of objects generated and acts a cache (but is not a real cache like ehcache or memcached). By default, the size of the object pool is equal to 10. This means in the previous example, Easy Random will generate at most 10 objects of type Person
. After that, it will reuse the same objects from the pool for any field of type Person
in the object graph. This parameter can also improve the performance of the randomization process for large object graphs.
Heads up: If you want to always generate distinct objects, you need to set the object pool size to a sufficiently large value. Obviously, this is only possible up to a certain limit (which is the objectPoolSize
value), after which objects will be fetched from the pool to avoid the initial infinite recursion problem.
The randomizationDepth
allows you to limit the randomization depth in an object graph. For example, if you have the following classes:
class A {
private B b;
}
class B {
private C c;
}
If you randomize an instance of type A
with randomizationDepth = 2
, the c
field in the generated B
instance will be null, that is, only the first 2 levels of the object graph are randomized.
By default, when Easy Random is not able to randomize a field or type, it will throw a ObjectGenerationException
. If you want to silently ignore randomization errors, you can set the ignoreRandomizationErrors
parameter.
With this parameter set, any exception raised during the randomization process will be silently ignored and the corresponding field will be set to null.
This flag allows you to bypass setters (if any) and use reflection directly instead. False
by default.
Easy Random is created by Mahmoud Ben Hassine with the help of some awesome contributors!