Package com.pholser.junit.quickcheck.internal.generator

Class GeneratorRepository

java.lang.Object
com.pholser.junit.quickcheck.internal.generator.GeneratorRepository
All Implemented Interfaces:
Generators
public class GeneratorRepository extends Object implements Generators

  • Field Details

  • Constructor Details

  • Method Details

    • register

      public GeneratorRepository register(Generator<?> source)

    • register

      public GeneratorRepository register(Iterable<Generator<?>> source)

    • registerTypes

      private void registerTypes(Generator<?> generator)

    • registerHierarchy

      private void registerHierarchy(Class<?> type, Generator<?> generator)

    • maybeRegisterGeneratorForType

      private void maybeRegisterGeneratorForType(Class<?> type, Generator<?> generator)

    • registerGeneratorForType

      private void registerGeneratorForType(Class<?> type, Generator<?> generator)

    • field

      public Generator<?> field(Class<?> type, String fieldName)
      Description copied from interface: Generators

      Gives a generator that can produce an instance of the type described by the field with the given name and containing type.

      If the field is marked with an annotation that influences the generation of a given kind of value, that annotation will be applied to the resulting generator's values.

      Specified by:
      field in interface Generators
      Parameters:
      type - containing type for a field
      fieldName - name of a field
      Returns:
      generator that can produce values of the field's type

    • constructor

      public <U> Generator<U> constructor(Class<U> type, Class<?>... argumentTypes)
      Description copied from interface: Generators

      Gives a generator that can produce an instance of the type described by a constructor of a given type that accepts the given types of arguments. It will generate values for the parameters of the given constructor, and then invoke the constructor.

      If the constructor's parameters are marked with annotations that influence the generation of a given kind of value, those annotations will be applied to the generators that will produce values to be used as arguments to the constructor.

      Specified by:
      constructor in interface Generators
      Type Parameters:
      U - type of objects produced by the resulting generator
      Parameters:
      type - containing type for a constructor
      argumentTypes - types of arguments to the constructor
      Returns:
      generator that can produce values using the constructor

    • fieldsOf

      public <U> Generator<U> fieldsOf(Class<U> type)
      Description copied from interface: Generators

      Gives a generator that can produce an instance of the given type by reflecting the class's fields on up its class hierarchy and generating random values for them.

      The given type must have an accessible zero-arg constructor.

      If a field of the given type is marked with an annotation that influences the generation of a given kind of value, that annotation will be applied to the generation of values for that field.

      Specified by:
      fieldsOf in interface Generators
      Type Parameters:
      U - type of objects produced by the resulting generator
      Parameters:
      type - a type
      Returns:
      generator that can produce values of that type

    • type

      public <T> Generator<T> type(Class<T> type, Class<?>... componentTypes)
      Description copied from interface: Generators

      Gives a generator that can produce values of the given type, parameterized by the given "component" types.

      Specified by:
      type in interface Generators
      Type Parameters:
      T - type of objects produced by the resulting generator
      Parameters:
      type - a type
      componentTypes - types for the "components" of the type, if any
      Returns:
      generator that can produce values of that type
      See Also:

    • parameter

      public Generator<?> parameter(Parameter parameter)
      Description copied from interface: Generators

      Gives a generator that can produce instances of the type of the given reflected method parameter.

      If the parameter is marked with an annotation that influences the generation of its value, that annotation will be applied to the generation of values for that parameter's type.

      Specified by:
      parameter in interface Generators
      Parameters:
      parameter - a reflected method parameter
      Returns:
      generator that can produce values of the parameter's type

    • field

      public Generator<?> field(Field field)
      Description copied from interface: Generators

      Gives a generator that can produce instances of the type of the given reflected field.

      If the field is marked with an annotation that influences the generation of its value, that annotation will be applied to the generation of values for that field's type.

      Specified by:
      field in interface Generators
      Parameters:
      field - a reflected field
      Returns:
      generator that can produce values of the field's type

    • oneOf

      @SafeVarargs public final <T> Generator<T> oneOf(Class<? extends T> first, Class<? extends T>... rest)
      Description copied from interface: Generators

      Gives a generator that can produce instances of one of a given set of related types on every generation.

      On each generation, one of the available generators that can produce one of the named types will be chosen with (approximately) equal probability.

      Specified by:
      oneOf in interface Generators
      Type Parameters:
      T - type of objects produced by the resulting generator
      Parameters:
      first - first type of generated value
      rest - other (related) types of generated values
      Returns:
      generator that can produce values of the given types

    • oneOf

      @SafeVarargs public final <T> Generator<T> oneOf(Generator<? extends T> first, Generator<? extends T>... rest)
      Description copied from interface: Generators

      Gives a generator that can produce instances of one of a given set of related types on every generation.

      On each generation, one of the given generators will be called upon with (approximately) equal probability.

      Specified by:
      oneOf in interface Generators
      Type Parameters:
      T - type of objects produced by the resulting generator
      Parameters:
      first - first generator
      rest - other generators
      Returns:
      generator that can produce values using the given generators

    • make

      public final <T extends Generator<?>> T make(Class<T> genType, Generator<?>... components)
      Description copied from interface: Generators

      Makes a new generator of the given type, provides it with access to other available generators, configures it with any configuration annotations present on the generator type, and supplies it any component generators it needs.

      Specified by:
      make in interface Generators
      Type Parameters:
      T - type of objects produced by the resulting generator
      Parameters:
      genType - type of generator to create
      components - any generators for components of the type
      Returns:
      a generator for producing values
      See Also:

    • withRandom

      public final Generators withRandom(SourceOfRandomness other)
      Description copied from interface: Generators

      Makes a generator access point just like the receiver, but which uses the given source of randomness for making random choices.

      Intended for use by junit-quickcheck.

      Specified by:
      withRandom in interface Generators
      Parameters:
      other - a source of randomness
      Returns:
      a generator access point that has the source of randomness available to it

    • produceGenerator

      public Generator<?> produceGenerator(ParameterTypeContext parameter)

    • generatorFor

      public Generator<?> generatorFor(ParameterTypeContext parameter)

    • generatorForArrayType

      private Generator<?> generatorForArrayType(ParameterTypeContext parameter)

    • matchingGenerators

      private List<Generator<?>> matchingGenerators(ParameterTypeContext parameter)

    • maybeAddGeneratorByNamingConvention

      private void maybeAddGeneratorByNamingConvention(ParameterTypeContext parameter, List<Generator<?>> matches)

    • maybeAddLambdaGenerator

      private void maybeAddLambdaGenerator(ParameterTypeContext parameter, List<Generator<?>> matches)

    • maybeAddMarkerInterfaceGenerator

      private void maybeAddMarkerInterfaceGenerator(ParameterTypeContext parameter, List<Generator<?>> matches)

    • maybeAddGeneratorsFor

      private void maybeAddGeneratorsFor(ParameterTypeContext parameter, List<Generator<?>> matches)

    • compose

      private Generator<?> compose(ParameterTypeContext parameter, List<Generator<?>> matches)

    • composeWeighted

      private Generator<?> composeWeighted(ParameterTypeContext parameter, List<Weighted<Generator<?>>> matches)

    • applyComponentGenerators

      private void applyComponentGenerators(Generator<?> generator, List<Generator<?>> componentGenerators)

    • generatorsFor

      private List<Generator<?>> generatorsFor(ParameterTypeContext parameter)

    • hasGeneratorsFor

      private boolean hasGeneratorsFor(ParameterTypeContext parameter)

    • isPrimitiveType

      private static boolean isPrimitiveType(Type type)

    • hasNullableAnnotation

      private static boolean hasNullableAnnotation(AnnotatedElement element)