List<Class<? extends TestInterface>> subClasses = new ArrayList<>();

subClasses.add(TestInterfaceClass.class);

ClassGenerator<TestClass> generator = new ClassGenerator.Builder<>(TestClass.class)

  .setProportionOfNull(0.1f)  //Set the proportion to generate null, default 0.1f

  //Set generator of type (generator.getClassToGenerate()).

  //It will use the generator to generate objects of this type afterwards.

  .setTypeGenerator(new TestClass2Generator())

  //Set the max layer of classes referencing tree. 

  .setMaxLayer(4)

  //Set sub classes of interface or abstract class. 

  .setSubClass(TestInterface.class, subClasses)

  .build();

TestClass value = generator.generate();

  CharGenerator charGenerator = new CharGenerator.Builder()

  .setValueSet(valuesSet)  //Values generated will be fetched from this set

  .setMinBound((char) 112)  //Set the up bound of values generated

  .setMaxBound((char)1)
//Set the low bound of values generated

  .build();

ClassGenerator<TestClass> generator = new ClassGenerator.Builder<>(TestClass.class)

  .setTypeGenerator(charGenerator)

  .build();

  // Rog provides generators for primitive types. And you can also replace it with your implementation.

BasicTypeGeneratorFactory.INSTANCE.setGenerator(new TestIntegerGenerator());

//Then the Integer's generator will be TestIntegerGenerator

//Or you can change the properties of the default primitive type generators

IntegerGenerator generator = new IntegerGenerator.Builder()

  .setMinBound(0)

  .build();

BasicTypeGeneratorFactory.INSTANCE.setGenerator(generator);

//Then the values generated will be larger or equal to 0

public class TestIntegerGenerator implements IGenerator<Integer>{

  @Override
  public Integer generate() {

return 1;
  
}

@Override
  public Class<?> getClassToGenerate() {

return Integer.TYPE;
  
}
  
}
 

  ArrayGenerator<TestClass2> generator = new ArrayGenerator.Builder<>( TestClass2[].class)

  .setGenerator(new TestClass2Generator())

  .setMaxLength(10)
 //Set the max length of array generated, default 100

  .setLength(10)  //Set a specific length for the array generated, default randomly

  .setProportionOfNull(0.1f)

 //Set proportion to generate null

  .build();

TestClass2[] object = generator.generate();

  List<TestEnum> valueSet = new ArrayList<>();

valueSet.add(TestEnum.v1);

EnumGenerator<TestEnum> generator = new EnumGenerator.Builder<>(TestEnum.class)

  .setValueSet(valueSet)  //Values generated will fetched from this set

  .setProportionOfNull(0.5f)  //Set the proportion to generate null

  .build();

TestEnum value = generator.generate();

  List<Class<? extends TestInterface>> classes = new ArrayList<>();

classes.add(TestInterfaceClass.class);

List<TestInterface> objects = new ArrayList<>();

objects.add(new TestInterfaceClass());

InterfaceOrAbstractClassGenerator<TestInterface> generator = new InterfaceOrAbstractClassGenerator.Builder<>(TestInterface.class)

  //Set the subClasses of TestInterface.

  .setClassSet(classes)

  .setTypeGenerator(new TestInferfaceClassGenerator())

  .setScaleOfNull(0.1f)
//Set proportion  to generate null, default 0.1f

  .setObjectSet(objects)  //The values gerated will be fetched from this set

  .build();

TestInterface value = generator.generate();

  List<Character> charSet = new ArrayList<>();

charSet.add('A');

List<String> valueSet = new ArrayList<>();

valueSet.add("A");

StringGenerator generator = new StringGenerator.Builder()

  .setCharSet(charSet)  //The characters of strings generated will be fetched from this set

  .setValueSet(valueSet)  //Strings generated will be fetched from this set

  .setMaxLength(11)  //Set the max length of strings generated

  //.setGenerateNotEmpty(false) //Set if the generator generates not empty strings, default true

  .setGenerateNull(false)  //Set if the generator generates null, default true

  .setGenerateEmpty(false)  //Set if the generator generates empty string, default true

  .setChineseProportion(1, 1)  //Set the proportion of chinese to english characters when the mode is MODE_NORMAL

  //MODE_RANDOM = 0;//Generate unicode char randomly

  //MODE_ASCII = 1;  //Generate only ascii char

  //MODE_NORMAL = 2; //Generate only ascii char and chinese

  .setMode(StringGenerator.MODE_NORMAL)  //Set generating mode, default MODE_NORMAL

  .build();

String value = generator.generate();

  BooleanGenerator generator = new BooleanGenerator.Builder()

  //.setGenerateTrue()

  //Set if the generator generates true, default true.

  //.setGenerateFalse(false)
//Set if the generator generates false, default true.

  .setProportion(1, 1)
//Set the proportion to generate true and false

  .build();

boolean value = generator.generate();

  List<Character> valuesSet = new ArrayList<>();

valuesSet.add('A');

valuesSet.add('B');

CharGenerator generator = new CharGenerator.Builder()

  .setValueSet(valuesSet)  //Values generated will be fetched from this set

  .setMinBound((char) 112)  //Set the up bound of values generated

  .setMaxBound((char)1)
//Set the low bound of values generated

  .build();

  List<Byte> valueSet = new ArrayList<>();

valueSet.add((byte) 1);

List<Byte> negativeSet = new ArrayList<>();

negativeSet.add((byte) -1);

ByteGenerator generator = new ByteGenerator.Builder()

  //.setGenerateNegative(false)  //Set if the generator generates negative values, default true

  //.setGeneratePositive(false)  //Set if the generator generates positive values, default true

  .setGenerateZero(false)  //Set if the generator generates zero

  .setGenerateProportion(1, 1, 1)  //Set proportion to generate positive, zero and negative values

  //.setValueSet(valueSet)  //Values generated will fetched from the list

  .setNegativeValueSet(negativeSet)  //Negative values generated will be fetched from the list.

  .setPositiveValueSet(valueSet)
//Positive values generated will be fetched from the list.

  .setMaxBound((byte) 123)
//Set the up bound of values generated

  .setMinBound((byte) -4)  //Set the low bound of values generated

  .build();

byte value = generator.generate();