net.jqwik.testing.TestingSupport Maven / Gradle / Ivy

Go to download
package net.jqwik.testing;

import java.util.*;
import java.util.function.*;
import java.util.stream.*;

import org.apiguardian.api.*;
import org.assertj.core.api.*;

import net.jqwik.api.*;
import net.jqwik.api.facades.*;

import static org.apiguardian.api.API.Status.*;
import static org.assertj.core.api.Assertions.*;

@API(status = EXPERIMENTAL, since = "1.4.0")
public class TestingSupport {

	private TestingSupport() {
	}

	public static  void checkAllGenerated(Arbitrary arbitrary, Random random, Predicate checker) {
		checkAllGenerated(arbitrary.generator(1000), random, checker);
	}

	public static  void checkAllGenerated(RandomGenerator generator, Random random, Predicate checker) {
		Optional> failure =
			generator
				.stream(random)
				.limit(100)
				.filter(shrinkable -> !checker.test(shrinkable.value()))
				.findAny();

		failure.ifPresent(shrinkable -> {
			Assertions.fail(String.format("Value [%s] failed to fulfill condition.", shrinkable.value()));
		});
	}

	public static  void assertAllGenerated(Arbitrary arbitrary, Random random, Consumer assertions) {
		assertAllGenerated(arbitrary.generator(1000), random, assertions);
	}

	public static  void assertAllGenerated(RandomGenerator generator, Random random, Consumer assertions) {
		Predicate checker = value -> {
			assertions.accept(value);
			return true;
		};
		checkAllGenerated(generator, random, checker);
	}

	public static  void assertAllGeneratedEqualTo(RandomGenerator generator, Random random, T expected) {
		assertAllGenerated(
			generator,
			random,
			value -> assertThat(value).isEqualTo(expected)
		);
	}

	public static  void assertAllGeneratedEqualTo(Arbitrary arbitrary, Random random, T expected) {
		assertAllGeneratedEqualTo(
			arbitrary.generator(1000),
			random,
			expected
		);
	}

	public static  void checkAtLeastOneGenerated(
		RandomGenerator generator,
		Random random,
		Predicate checker,
		String failureMessage
	) {
		Optional> success =
			generator
				.stream(random)
				.limit(5000)
				.filter(shrinkable -> checker.test(shrinkable.value()))
				.findAny();
		if (!success.isPresent()) {
			fail(failureMessage);
		}
	}

	public static  void checkAtLeastOneGenerated(
		RandomGenerator generator,
		Random random,
		Predicate checker
	) {
		checkAtLeastOneGenerated(generator, random, checker, "Failed to generate at least one");
	}

	public static  void checkAtLeastOneGenerated(
		Arbitrary arbitrary,
		Random random,
		Predicate checker
	) {
		checkAtLeastOneGenerated(arbitrary.generator(1000), random, checker);
	}

	@SafeVarargs
	public static  void assertAtLeastOneGeneratedOf(
		RandomGenerator generator,
		Random random,
		T... values
	) {
		for (T value : values) {
			checkAtLeastOneGenerated(generator, random, value::equals, "Failed to generate " + value);
		}
	}

	@SafeVarargs
	public static  void assertGeneratedExactly(RandomGenerator generator, Random random, T... expectedValues) {
		List generated = generator
			.stream(random)
			.limit(expectedValues.length)
			.map(Shrinkable::value)
			.collect(Collectors.toList());

		assertThat(generated).containsExactly(expectedValues);
	}

	public static  Set> collectEdgeCaseShrinkables(EdgeCases edgeCases) {
		Set> shrinkables = new HashSet<>();
		for (Shrinkable edgeCase : edgeCases) {
			shrinkables.add(edgeCase);
		}
		return shrinkables;
	}

	public static  Set collectEdgeCaseValues(EdgeCases edgeCases) {
		Set values = new HashSet<>();
		for (Shrinkable edgeCase : edgeCases) {
			values.add(edgeCase.value());
		}
		return values;
	}

	public static  T generateFirst(Arbitrary arbitrary, Random random) {
		RandomGenerator generator = arbitrary.generator(1, true);
		return generator.next(random).value();
	}

	public static  Map count(RandomGenerator generator, int tries, Random random) {
		return generator
			.stream(random)
			.limit(tries)
			.map(Shrinkable::value)
			.collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
	}

	public static  Shrinkable generateUntil(RandomGenerator generator, Random random, Function condition) {
		return TestingSupportFacade.implementation.generateUntil(generator, random, condition);
	}

	@API(status = EXPERIMENTAL, since = "1.6.0")
	public static String singleLineReport(Object any) {
		return TestingSupportFacade.implementation.singleLineReport(any);
	}

	@API(status = EXPERIMENTAL, since = "1.6.0")
	public static List multiLineReport(Object any) {
		return TestingSupportFacade.implementation.multiLineReport(any);
	}
}