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

Class ArrayGenerator

java.lang.Object
com.pholser.junit.quickcheck.generator.Generator<Object>
com.pholser.junit.quickcheck.internal.generator.ArrayGenerator
All Implemented Interfaces:
Gen<Object>, Shrink<Object>
public class ArrayGenerator extends Generator<Object>

  • Field Details

    • componentType

      private final Class<?> componentType

    • component

      private final Generator<?> component

    • lengthRange

      private Size lengthRange

    • distinct

      private boolean distinct

  • Constructor Details

    • ArrayGenerator

      ArrayGenerator(Class<?> componentType, Generator<?> component)

  • Method Details

    • configure

      public void configure(Size size)
      Tells this generator to produce values with a length within a specified minimum and/or maximum, inclusive, chosen with uniform distribution.
      Parameters:
      size - annotation that gives the length constraints

    • configure

      public void configure(Distinct distinct)
      Tells this generator to produce values which are distinct from each other.
      Parameters:
      distinct - Generated values will be distinct if this param is not null.

    • generate

      public Object generate(SourceOfRandomness random, GenerationStatus status)
      Description copied from interface: Gen
      Generates a value, possibly influenced by a source of randomness and metadata about the generation.
      Parameters:
      random - source of randomness to be used when generating the value
      status - an object that can be used to influence the generated value. For example, generating lists can use the size method to generate lists with a given number of elements.
      Returns:
      the generated value

    • canShrink

      public boolean canShrink(Object larger)
      Description copied from class: Generator

      Tells whether this generator is allowed to participate in the Shrink process for the given "larger" value.

      Unless overridden, the only criterion for whether a generator is allowed to participate in shrinking a value is if the value can be safely cast to the type of values the generator produces.

      Overrides:
      canShrink in class Generator<Object>
      Parameters:
      larger - the "larger" value
      Returns:
      whether this generator can participate in "shrinking" the larger value

    • doShrink

      public List<Object> doShrink(SourceOfRandomness random, Object larger)
      Description copied from class: Generator

      Gives some objects that are "smaller" than a given "larger" object.

      Unless overridden, a generator will produce an empty list of "smaller" values.

      Overrides:
      doShrink in class Generator<Object>
      Parameters:
      random - source of randomness to use in shrinking, if desired
      larger - the larger object
      Returns:
      objects that are "smaller" than the larger object. Smaller objects should be provided before bigger objects to make shrinking process faster.

    • provide

      public void provide(Generators provided)
      Description copied from class: Generator

      Supplies the available generators to this one.

      This is intended for use only by junit-quickcheck itself, and not by creators of custom generators.

      Overrides:
      provide in class Generator<Object>
      Parameters:
      provided - repository of available generators

    • magnitude

      public BigDecimal magnitude(Object value)
      Description copied from class: Generator

      Gives a hint to the shrinking process as to the magnitude of the given value. The shrinking process will prefer trying values of greater magnitude before values of lesser magnitude. If not overridden, this implementation returns "one".

      Note to generator writers: Do not worry about normalizing a magnitude to a positive value; the shrinking mechanism will take care of it.

      Overrides:
      magnitude in class Generator<Object>
      Parameters:
      value - the value to assess
      Returns:
      a measure of the given value's magnitude
      See Also:

    • configure

      public void configure(AnnotatedType annotatedType)
      Description copied from class: Generator

      Configures this generator using annotations from a given annotated type.

      This method considers only annotations that are themselves marked with GeneratorConfiguration.

      By default, the generator will configure itself using this procedure:

      • For each of the given annotations:
        • Find a public method on the generator named configure, that accepts a single parameter of the annotation type
        • Invoke the configure method reflectively, passing the annotation as the argument
      Overrides:
      configure in class Generator<Object>
      Parameters:
      annotatedType - a type usage

    • length

      private int length(SourceOfRandomness random, GenerationStatus status)

    • inLengthRange

      private boolean inLengthRange(Object items)

    • removals

      private List<Object> removals(List<?> items)

    • convert

      private Object convert(List<?> items)