// Path: fuzzy-core/src/main/java/com/redfin/fuzzy/Case.java
// public interface Case<T>
// {
// 
// 	/**
// 	 * Returns the specific set of subcases that describe all equivalency classes for this case.
// 	 *
// 	 * <p>Cases are expected to return <em>at least one</em> subcase. When the fuzzy engine is determining how many test
// 	 * cases to execute, it does so in terms of subcases, not cases. Thus, when using the pairwise permutation
// 	 * algorithm, the fuzzy library works to ensure that each possible combination of two subcases are executed.</p>
// 	 *
// 	 * <p><strong>Note to implementors:</strong> cases should generally <em>not</em> include {@code null} values as
// 	 * possible outputs. Instead, consumers are expected to use the {@link #orNull()} method (or, equivalently,
// 	 * {@link Any#nullableOf}) to declare that their cases should also generate null values.</p>
// 	 */
// 	Set<Subcase<T>> getSubcases();
// 
// 	/**
// 	 * Returns a new case that combines the subcases of this case and the provided {@code other} case. This method can
// 	 * be used to combine different cases for a value into a single {@linkplain Generator generator}.
// 	 */
// 	default Case<T> or(Case<T> other) { return Any.of(this, other); }
// 
// 	/**
// 	 * Returns a new case that combines the subcases of this case and a subcase specifically generating the value
// 	 * {@code null}.
// 	 */
// 	default Case<T> orNull() { return Any.nullableOf(this); }
// 
// 	/**
// 	 * Constrains the
// 	 */
// 	default Case<T> excluding(T value) { return excluding(Collections.singleton(value)); }
// 	default Case<T> excluding(T... values) { return excluding(values == null ? null : Arrays.asList(values)); }
// 	default Case<T> excluding(Iterable<T> values) { return new ExcludingCase<>(this, values); }
// 
// 	/**
// 	 * Arbitrarily selects and returns the value of one of this case's subcases.
// 	 */
// 	default T generateAnyOnce() { return generateAnyOnce(new Random()); }
// 
// 	/**
// 	 * Arbitrarily selects and returns the value of one of this case's subcases.
// 	 *
// 	 * @param random the random number generator that will be used to create the returned value.
// 	 */
// 	default T generateAnyOnce(Random random) {
// 		FuzzyPreconditions.checkNotNull(random);
// 
// 		Set<Subcase<T>> subcases = getSubcases();
// 
// 		if(subcases == null || subcases.isEmpty())
// 			throw new IllegalStateException(String.format("Case of type %s generated zero suppliers.", getClass()));
// 
// 		return subcases.stream().findAny().orElse(null).generate(random);
// 	}
// 
// 	/**
// 	 * Requests each of this case's subcases to generate and return a value.
// 	 */
// 	default Set<T> generateAllOnce() { return generateAllOnce(new Random()); }
// 
// 	/**
// 	 * Requests each of this case's subcases to generate and return a value.
// 	 *
// 	 * @param random the random number generator that will be used to create the returned values.
// 	 */
// 	default Set<T> generateAllOnce(Random random) {
// 		FuzzyPreconditions.checkNotNull(random);
// 
// 		Set<Subcase<T>> subcases = getSubcases();
// 
// 		if(subcases == null || subcases.isEmpty())
// 			throw new IllegalStateException(String.format("Case of type %s generated zero suppliers.", getClass()));
// 
// 		return subcases.stream().map(s -> s.generate(random)).collect(Collectors.toSet());
// 	}
// 
// }
// 
// Path: fuzzy-core/src/main/java/com/redfin/fuzzy/Subcase.java
// public interface Subcase<T> {
// 
// 	/**
// 	 * Instructs the subcase to generate and return a new value.
// 	 *
// 	 * <p>Subcases are not required to return exactly the same value for subsequent calls to {@code generate}; they may
// 	 * randomly adjust their output on a per-call basis. However, subcases should adhere to the expectation that they
// 	 * represent an <em>equivalency class</em> of output: although individual return values may differ, each value they
// 	 * produce is effectively the same from a testing perspective.
// 	 * </p>
// 	 * <p>If the subcase does chose to produce randomized values, it should do so deterministically: two calls provided
// 	 * with a random number generator with the same seed should produce exactly the same output. In general, this
// 	 * condition should be satisfied if the test uses the provided {@linkplain Random random number generator} as its
// 	 * only source of randomness.</p>
// 	 */
// 	T generate(Random random);
// 
// 	/**
// 	 * Describes a given output produced by this subcase, for use in test failure reports.
// 	 *
// 	 * <p>The default implementation of this method attempts to provide helpful descriptions of {@code null}, common
// 	 * primitives, strings, arrays, and collections. It defers to {@link Object#toString()} for all other descriptions.
// 	 * </p>
// 	 *
// 	 * @param sink the string builder to which the description of the value should be appended.
// 	 * @param value the value (as returned by this subcase's {@link #generate(Random) generate} method) that should be
// 	 *        described.
// 	 */
// 	default void describeTo(StringBuilder sink, T value) {
// 		FuzzyPreconditions.checkNotNull(sink);
// 		FuzzyUtil.inspectTo(sink, value);
// 	}
// 
// }


import com.redfin.fuzzy.Case;
import com.redfin.fuzzy.Subcase;
import java.util.Collections;
import java.util.Random;
import java.util.Set;
package com.redfin.fuzzy.cases;


public class LiteralCase<T> implements Case<T> {

	private final T literal;

	@SuppressWarnings("unchecked")
	public LiteralCase(T literal) {
// Path: fuzzy-core/src/main/java/com/redfin/fuzzy/Case.java
// public interface Case<T>
// {
// 
// 	/**
// 	 * Returns the specific set of subcases that describe all equivalency classes for this case.
// 	 *
// 	 * <p>Cases are expected to return <em>at least one</em> subcase. When the fuzzy engine is determining how many test
// 	 * cases to execute, it does so in terms of subcases, not cases. Thus, when using the pairwise permutation
// 	 * algorithm, the fuzzy library works to ensure that each possible combination of two subcases are executed.</p>
// 	 *
// 	 * <p><strong>Note to implementors:</strong> cases should generally <em>not</em> include {@code null} values as
// 	 * possible outputs. Instead, consumers are expected to use the {@link #orNull()} method (or, equivalently,
// 	 * {@link Any#nullableOf}) to declare that their cases should also generate null values.</p>
// 	 */
// 	Set<Subcase<T>> getSubcases();
// 
// 	/**
// 	 * Returns a new case that combines the subcases of this case and the provided {@code other} case. This method can
// 	 * be used to combine different cases for a value into a single {@linkplain Generator generator}.
// 	 */
// 	default Case<T> or(Case<T> other) { return Any.of(this, other); }
// 
// 	/**
// 	 * Returns a new case that combines the subcases of this case and a subcase specifically generating the value
// 	 * {@code null}.
// 	 */
// 	default Case<T> orNull() { return Any.nullableOf(this); }
// 
// 	/**
// 	 * Constrains the
// 	 */
// 	default Case<T> excluding(T value) { return excluding(Collections.singleton(value)); }
// 	default Case<T> excluding(T... values) { return excluding(values == null ? null : Arrays.asList(values)); }
// 	default Case<T> excluding(Iterable<T> values) { return new ExcludingCase<>(this, values); }
// 
// 	/**
// 	 * Arbitrarily selects and returns the value of one of this case's subcases.
// 	 */
// 	default T generateAnyOnce() { return generateAnyOnce(new Random()); }
// 
// 	/**
// 	 * Arbitrarily selects and returns the value of one of this case's subcases.
// 	 *
// 	 * @param random the random number generator that will be used to create the returned value.
// 	 */
// 	default T generateAnyOnce(Random random) {
// 		FuzzyPreconditions.checkNotNull(random);
// 
// 		Set<Subcase<T>> subcases = getSubcases();
// 
// 		if(subcases == null || subcases.isEmpty())
// 			throw new IllegalStateException(String.format("Case of type %s generated zero suppliers.", getClass()));
// 
// 		return subcases.stream().findAny().orElse(null).generate(random);
// 	}
// 
// 	/**
// 	 * Requests each of this case's subcases to generate and return a value.
// 	 */
// 	default Set<T> generateAllOnce() { return generateAllOnce(new Random()); }
// 
// 	/**
// 	 * Requests each of this case's subcases to generate and return a value.
// 	 *
// 	 * @param random the random number generator that will be used to create the returned values.
// 	 */
// 	default Set<T> generateAllOnce(Random random) {
// 		FuzzyPreconditions.checkNotNull(random);
// 
// 		Set<Subcase<T>> subcases = getSubcases();
// 
// 		if(subcases == null || subcases.isEmpty())
// 			throw new IllegalStateException(String.format("Case of type %s generated zero suppliers.", getClass()));
// 
// 		return subcases.stream().map(s -> s.generate(random)).collect(Collectors.toSet());
// 	}
// 
// }
// 
// Path: fuzzy-core/src/main/java/com/redfin/fuzzy/Subcase.java
// public interface Subcase<T> {
// 
// 	/**
// 	 * Instructs the subcase to generate and return a new value.
// 	 *
// 	 * <p>Subcases are not required to return exactly the same value for subsequent calls to {@code generate}; they may
// 	 * randomly adjust their output on a per-call basis. However, subcases should adhere to the expectation that they
// 	 * represent an <em>equivalency class</em> of output: although individual return values may differ, each value they
// 	 * produce is effectively the same from a testing perspective.
// 	 * </p>
// 	 * <p>If the subcase does chose to produce randomized values, it should do so deterministically: two calls provided
// 	 * with a random number generator with the same seed should produce exactly the same output. In general, this
// 	 * condition should be satisfied if the test uses the provided {@linkplain Random random number generator} as its
// 	 * only source of randomness.</p>
// 	 */
// 	T generate(Random random);
// 
// 	/**
// 	 * Describes a given output produced by this subcase, for use in test failure reports.
// 	 *
// 	 * <p>The default implementation of this method attempts to provide helpful descriptions of {@code null}, common
// 	 * primitives, strings, arrays, and collections. It defers to {@link Object#toString()} for all other descriptions.
// 	 * </p>
// 	 *
// 	 * @param sink the string builder to which the description of the value should be appended.
// 	 * @param value the value (as returned by this subcase's {@link #generate(Random) generate} method) that should be
// 	 *        described.
// 	 */
// 	default void describeTo(StringBuilder sink, T value) {
// 		FuzzyPreconditions.checkNotNull(sink);
// 		FuzzyUtil.inspectTo(sink, value);
// 	}
// 
// }


// Path: fuzzy-core/src/main/java/com/redfin/fuzzy/cases/LiteralCase.java
import com.redfin.fuzzy.Case;
import com.redfin.fuzzy.Subcase;
import java.util.Collections;
import java.util.Random;
import java.util.Set;

package com.redfin.fuzzy.cases;


public class LiteralCase<T> implements Case<T> {

	private final T literal;

	@SuppressWarnings("unchecked")
	public LiteralCase(T literal) {
		this.literal = literal;