private Object[] arguments(SourceOfRandomness random, GenerationStatus status) { Object[] args = new Object[parameters.length]; for (int i = 0; i < args.length; ++i) args[i] = parameterGenerators.get(i).generate(random, status); return args; } }
/** * {@inheritDoc} * * <p>Generators first ensure that they {@linkplain #canShrink(Object) can * participate} in shrinking the given value, and if so, they * {@linkplain #doShrink(SourceOfRandomness, Object) produce shrinks}.</p> */ @Override public final List<T> shrink(SourceOfRandomness random, Object larger) { if (!canShrink(larger)) { throw new IllegalStateException( getClass() + " not capable of shrinking " + larger); } return doShrink(random, narrow(larger)); }
@Override public final <T extends Generator<?>> T make( Class<T> genType, Generator<?>... components) { T generator = instantiate(genType); generator.provide(this); generator.configure(genType); generator.addComponentGenerators(asList(components)); return generator; }
@Override public List<Optional> doShrink( SourceOfRandomness random, Optional larger) { if (!larger.isPresent()) return new ArrayList<>(); List<Optional> shrinks = new ArrayList<>(); shrinks.add(Optional.absent()); shrinks.addAll( componentGenerators().get(0) .shrink(random, larger.get()) .stream() .map(Optional::fromNullable) .collect(toList())); return shrinks; }
@Override public BigDecimal magnitude(Object value) { return delegate.magnitude(value); } }
@Test public void shrinkingChoosesAComponentCapableOfShrinkingTheValue() { stub(first.canShrink(7)).toReturn(true); stub(second.canShrink(7)).toReturn(false); stub(third.canShrink(7)).toReturn(true); when(first.types()).thenReturn(singletonList(Integer.class)); when(first.doShrink(random, 7)).thenReturn(asList(3, 6)); when(random.nextInt(9)).thenReturn(1); assertEquals(asList(3, 6), composite.shrink(random, 7)); verify(first, atLeastOnce()).doShrink(random, 7); } }
@Override public boolean canShrink(Object larger) { return delegate.canShrink(larger); }
private void applyComponentGenerators(Generator<?> generator, List<Generator<?>> componentGenerators) { if (generator.hasComponents()) { if (componentGenerators.isEmpty()) { List<Generator<?>> substitutes = new ArrayList<>(); Generator<?> zilch = generatorFor( new ParameterTypeContext( "Zilch", null, getClass().getName(), token(Zilch.class), emptyMap()) .allowMixedTypes(true)); for (int i = 0; i < generator.numberOfNeededComponents(); ++i) substitutes.add(zilch); generator.addComponentGenerators(substitutes); } else generator.addComponentGenerators(componentGenerators); } }
private void configureLenient( Class<? extends Annotation> annotationType, Annotation configuration) { configure(annotationType, configuration, ex -> {}); }
public Generator<?> produceGenerator(ParameterTypeContext parameter) { Generator<?> generator = generatorFor(parameter); if (!isPrimitiveType(parameter.annotatedType().getType()) && hasNullableAnnotation(parameter.annotatedElement())) generator = new NullableGenerator<>(generator); generator.provide(this); generator.configure(parameter.annotatedType()); if (parameter.topLevel()) generator.configure(parameter.annotatedElement()); return generator; }
@Override public void addComponentGenerators(List<Generator<?>> newComponents) { delegate.addComponentGenerators(newComponents); }
@Override public List<Optional> doShrink( SourceOfRandomness random, Optional larger) { if (!larger.isPresent()) return new ArrayList<>(); List<Optional> shrinks = new ArrayList<>(); shrinks.add(Optional.empty()); shrinks.addAll( componentGenerators().get(0) .shrink(random, larger.get()) .stream() .map(Optional::of) .collect(toList())); return shrinks; }
@Override public BigDecimal magnitude(Object value) { int length = Array.getLength(value); if (length == 0) return ZERO; BigDecimal elementsMagnitude = IntStream.range(0, length) .mapToObj(i -> component.magnitude(Array.get(value, i))) .reduce(ZERO, BigDecimal::add); return BigDecimal.valueOf(length).multiply(elementsMagnitude); }
@Override public final <T extends Generator<?>> T make( Class<T> genType, Generator<?>... components) { T generator = instantiate(genType); generator.provide(this); generator.configure(genType); generator.addComponentGenerators(asList(components)); return generator; }
@Override public boolean canShrink(Object larger) { return composed.stream() .map(w -> w.item) .anyMatch(g -> g.canShrink(larger)); }
/** * {@inheritDoc} * * <p>Generators first ensure that they {@linkplain #canShrink(Object) can * participate} in shrinking the given value, and if so, they * {@linkplain #doShrink(SourceOfRandomness, Object) produce shrinks}.</p> */ @Override public final List<T> shrink(SourceOfRandomness random, Object larger) { if (!canShrink(larger)) { throw new IllegalStateException( getClass() + " not capable of shrinking " + larger); } return doShrink(random, narrow(larger)); }
private void applyComponentGenerators(Generator<?> generator, List<Generator<?>> componentGenerators) { if (generator.hasComponents()) { if (componentGenerators.isEmpty()) { List<Generator<?>> substitutes = new ArrayList<>(); Generator<?> zilch = generatorFor( new ParameterTypeContext( "Zilch", null, getClass().getName(), token(Zilch.class), emptyMap()) .allowMixedTypes(true)); for (int i = 0; i < generator.numberOfNeededComponents(); ++i) substitutes.add(zilch); generator.addComponentGenerators(substitutes); } else generator.addComponentGenerators(componentGenerators); } }
@Override public void configure(AnnotatedElement element) { delegate.configure(element); }