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

Class NullableGenerator<T>

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

  • Field Details

    • delegate

      private final Generator<T> delegate

    • probabilityOfNull

      private double probabilityOfNull

  • Constructor Details

    • NullableGenerator

      NullableGenerator(Generator<T> delegate)

  • Method Details

    • generate

      public T 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

    • canRegisterAsType

      public boolean canRegisterAsType(Class<?> type)
      Description copied from class: Generator
      Tells whether this generator is allowed to be used for property parameters of the given type.
      Overrides:
      canRegisterAsType in class Generator<T>
      Parameters:
      type - type against which to test this generator
      Returns:
      true if the generator is allowed to participate in generating values for property parameters of type

    • hasComponents

      public boolean hasComponents()
      Description copied from class: Generator

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

      Overrides:
      hasComponents in class Generator<T>
      Returns:
      whether this generator has component generators, such as for those generators that produce lists or maps
      See Also:

    • numberOfNeededComponents

      public int numberOfNeededComponents()
      Description copied from class: Generator

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

      Overrides:
      numberOfNeededComponents in class Generator<T>
      Returns:
      how many component generators this generator needs
      See Also:

    • addComponentGenerators

      public void addComponentGenerators(List<Generator<?>> newComponents)
      Description copied from class: Generator

      Adds component generators to this generator.

      Some generators need component generators to create proper values. For example, list generators require a single component generator in order to generate elements that have the type of the list parameter's type argument.

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

      Overrides:
      addComponentGenerators in class Generator<T>
      Parameters:
      newComponents - component generators to add

    • canGenerateForParametersOfTypes

      public boolean canGenerateForParametersOfTypes(List<io.arxila.javaruntype.type.TypeParameter<?>> typeParameters)
      Overrides:
      canGenerateForParametersOfTypes in class Generator<T>
      Parameters:
      typeParameters - a list of generic type parameters
      Returns:
      whether this generator can be considered for generating values for property parameters that have the given type parameters in their signatures

    • 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<T>
      Parameters:
      annotatedType - a type usage

    • configure

      public void configure(AnnotatedElement element)
      Overrides:
      configure in class Generator<T>
      Parameters:
      element - an annotated program element

    • 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<T>
      Parameters:
      provided - repository of available generators

    • 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<T>
      Parameters:
      larger - the "larger" value
      Returns:
      whether this generator can participate in "shrinking" the larger value

    • doShrink

      public List<T> doShrink(SourceOfRandomness random, T 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<T>
      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.

    • 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<T>
      Parameters:
      value - the value to assess
      Returns:
      a measure of the given value's magnitude
      See Also:

    • configure

      private void configure(NullAllowed allowed)