fj.test.Coarbitrary Maven / Gradle / Ivy
package fj.test;
import fj.*;
import static fj.Function.curry;
import static fj.P.p;
import fj.data.*;
import static fj.data.Array.array;
import static fj.data.List.fromString;
import static fj.data.List.nil;
import static fj.test.Variant.variant;
import static java.lang.Double.doubleToRawLongBits;
import static java.lang.Float.floatToRawIntBits;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.Calendar;
import java.util.Date;
import java.util.EnumMap;
import java.util.EnumSet;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.IdentityHashMap;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Properties;
import java.util.Stack;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.Vector;
import java.util.WeakHashMap;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.SynchronousQueue;
/**
* Transforms a type and a generator to produce a new generator. This function is used to generate
* {@link Arbitrary arbitrary} functions.
*
* @version %build.number%
*/
public abstract class Coarbitrary {
/**
* Transforms the given value and generator to a new generator with a high probability of being
* independent.
*
* @param a The value to produce the generator from.
* @param g The generator to produce the new generator from.
* @return A new generator with a high probability of being independent.
*/
public abstract Gen coarbitrary(A a, Gen g);
/**
* A curried version of {@link #coarbitrary(Object, Gen)}.
*
* @param a The value to produce the generator from.
* @return A curried version of {@link #coarbitrary(Object, Gen)}.
*/
public final F, Gen> coarbitrary(final A a) {
return new F, Gen>() {
public Gen f(final Gen g) {
return coarbitrary(a, g);
}
};
}
/**
* Composes the given function with this coarbitrary to produce a new coarbitrary.
*
* @param f The function to compose.
* @return A new coarbitrary composed with the given function.
*/
public final Coarbitrary compose(final F f) {
return new Coarbitrary() {
public Gen coarbitrary(final B b, final Gen g) {
return Coarbitrary.this.coarbitrary(f.f(b), g);
}
};
}
/**
* Contra-maps this coarbitrary using the given function.
*
* @param f The function to co-map with.
* @return A contra-mapped coarbitrary.
*/
public final Coarbitrary contramap(final F f) {
return new Coarbitrary() {
public Gen coarbitrary(final B b, final Gen g) {
return Coarbitrary.this.coarbitrary(f.f(b), g);
}
};
}
/**
* A coarbitrary for a function.
*
* @param a An arbitrary for the domain of the function.
* @param c A coarbitrary for the codomain of the function.
* @return A coarbitrary for a function.
*/
public static Coarbitrary> coarbF(final Arbitrary a, final Coarbitrary c) {
return new Coarbitrary>() {
public Gen coarbitrary(final F f, final Gen g) {
return a.gen.bind(new F>() {
public Gen f(final A a) {
return c.coarbitrary(f.f(a), g);
}
});
}
};
}
/**
* A coarbitrary for a function-2.
*
* @param aa An arbitrary for part of the domain of the function.
* @param ab An arbitrary for part of the domain of the function.
* @param c A coarbitrary for the codomain of the function.
* @return A coarbitrary for a function-2.
*/
public static Coarbitrary> coarbF2(final Arbitrary aa, final Arbitrary ab,
final Coarbitrary c) {
return new Coarbitrary>() {
public Gen coarbitrary(final F2 f, final Gen g) {
return coarbF(aa, coarbF(ab, c)).coarbitrary(curry(f), g);
}
};
}
/**
* A coarbitrary for a function-3.
*
* @param aa An arbitrary for part of the domain of the function.
* @param ab An arbitrary for part of the domain of the function.
* @param ac An arbitrary for part of the domain of the function.
* @param c A coarbitrary for the codomain of the function.
* @return A coarbitrary for a function-3.
*/
public static Coarbitrary> coarbF3(final Arbitrary aa, final Arbitrary ab,
final Arbitrary ac, final Coarbitrary c) {
return new Coarbitrary>() {
public Gen coarbitrary(final F3 f, final Gen g) {
return coarbF(aa, coarbF(ab, coarbF(ac, c))).coarbitrary(curry(f), g);
}
};
}
/**
* A coarbitrary for a function-4.
*
* @param aa An arbitrary for part of the domain of the function.
* @param ab An arbitrary for part of the domain of the function.
* @param ac An arbitrary for part of the domain of the function.
* @param ad An arbitrary for part of the domain of the function.
* @param c A coarbitrary for the codomain of the function.
* @return A coarbitrary for a function-4.
*/
public static Coarbitrary> coarbF4(final Arbitrary aa, final Arbitrary ab,
final Arbitrary ac, final Arbitrary ad,
final Coarbitrary c) {
return new Coarbitrary>() {
public Gen coarbitrary(final F4 f, final Gen g) {
return coarbF(aa, coarbF(ab, coarbF(ac, coarbF(ad, c)))).coarbitrary(curry(f), g);
}
};
}
/**
* A coarbitrary for a function-5.
*
* @param aa An arbitrary for part of the domain of the function.
* @param ab An arbitrary for part of the domain of the function.
* @param ac An arbitrary for part of the domain of the function.
* @param ad An arbitrary for part of the domain of the function.
* @param ae An arbitrary for part of the domain of the function.
* @param c A coarbitrary for the codomain of the function.
* @return A coarbitrary for a function-5.
*/
public static Coarbitrary> coarbF5(final Arbitrary aa,
final Arbitrary ab,
final Arbitrary ac,
final Arbitrary ad,
final Arbitrary ae,
final Coarbitrary c) {
return new Coarbitrary>() {
public Gen coarbitrary(final F5 f, final Gen g) {
return coarbF(aa, coarbF(ab, coarbF(ac, coarbF(ad, coarbF(ae, c))))).coarbitrary(curry(f), g);
}
};
}
/**
* A coarbitrary for a function-6.
*
* @param aa An arbitrary for part of the domain of the function.
* @param ab An arbitrary for part of the domain of the function.
* @param ac An arbitrary for part of the domain of the function.
* @param ad An arbitrary for part of the domain of the function.
* @param ae An arbitrary for part of the domain of the function.
* @param af An arbitrary for part of the domain of the function.
* @param c A coarbitrary for the codomain of the function.
* @return A coarbitrary for a function-6.
*/
public static Coarbitrary> coarbF6(final Arbitrary aa,
final Arbitrary ab,
final Arbitrary ac,
final Arbitrary ad,
final Arbitrary ae,
final Arbitrary af,
final Coarbitrary c) {
return new Coarbitrary>() {
public Gen coarbitrary(final F6 f, final Gen g) {
return coarbF(aa, coarbF(ab, coarbF(ac, coarbF(ad, coarbF(ae, coarbF(af, c)))))).coarbitrary(curry(f), g);
}
};
}
/**
* A coarbitrary for a function-7.
*
* @param aa An arbitrary for part of the domain of the function.
* @param ab An arbitrary for part of the domain of the function.
* @param ac An arbitrary for part of the domain of the function.
* @param ad An arbitrary for part of the domain of the function.
* @param ae An arbitrary for part of the domain of the function.
* @param af An arbitrary for part of the domain of the function.
* @param ag An arbitrary for part of the domain of the function.
* @param c A coarbitrary for the codomain of the function.
* @return A coarbitrary for a function-7.
*/
public static Coarbitrary> coarbF7(final Arbitrary aa,
final Arbitrary ab,
final Arbitrary ac,
final Arbitrary ad,
final Arbitrary ae,
final Arbitrary af,
final Arbitrary ag,
final Coarbitrary c) {
return new Coarbitrary>() {
public Gen coarbitrary(final F7 f, final Gen g) {
return coarbF(aa, coarbF(ab, coarbF(ac, coarbF(ad, coarbF(ae, coarbF(af, coarbF(ag, c)))))))
.coarbitrary(curry(f), g);
}
};
}
/**
* A coarbitrary for a function-8.
*
* @param aa An arbitrary for part of the domain of the function.
* @param ab An arbitrary for part of the domain of the function.
* @param ac An arbitrary for part of the domain of the function.
* @param ad An arbitrary for part of the domain of the function.
* @param ae An arbitrary for part of the domain of the function.
* @param af An arbitrary for part of the domain of the function.
* @param ag An arbitrary for part of the domain of the function.
* @param ah An arbitrary for part of the domain of the function.
* @param c A coarbitrary for the codomain of the function.
* @return A coarbitrary for a function-8.
*/
public static Coarbitrary> coarbF8(final Arbitrary aa,
final Arbitrary ab,
final Arbitrary ac,
final Arbitrary ad,
final Arbitrary ae,
final Arbitrary af,
final Arbitrary ag,
final Arbitrary ah,
final Coarbitrary c) {
return new Coarbitrary>() {
public Gen coarbitrary(final F8 f, final Gen g) {
return coarbF(aa, coarbF(ab, coarbF(ac, coarbF(ad, coarbF(ae, coarbF(af, coarbF(ag, coarbF(ah, c))))))))
.coarbitrary(curry(f), g);
}
};
}
/**
* A coarbitrary for booleans.
*/
public static final Coarbitrary coarbBoolean = new Coarbitrary() {
public Gen coarbitrary(final Boolean b, final Gen g) {
return variant(b ? 0 : 1, g);
}
};
/**
* A coarbitrary for integers.
*/
public static final Coarbitrary coarbInteger = new Coarbitrary() {
public Gen coarbitrary(final Integer i, final Gen g) {
return variant(i >= 0 ? 2 * i : -2 * i + 1, g);
}
};
/**
* A coarbitrary for bytes.
*/
public static final Coarbitrary coarbByte = new Coarbitrary() {
public Gen coarbitrary(final Byte b, final Gen g) {
return variant(b >= 0 ? 2 * b : -2 * b + 1, g);
}
};
/**
* A coarbitrary for shorts.
*/
public static final Coarbitrary coarbShort = new Coarbitrary() {
public Gen coarbitrary(final Short s, final Gen g) {
return variant(s >= 0 ? 2 * s : -2 * s + 1, g);
}
};
/**
* A coarbitrary for longs.
*/
public static final Coarbitrary coarbLong = new Coarbitrary() {
public Gen coarbitrary(final Long l, final Gen g) {
return variant(l >= 0L ? 2L * l : -2L * l + 1L, g);
}
};
/**
* A coarbitrary for characters.
*/
public static final Coarbitrary coarbCharacter = new Coarbitrary() {
public Gen coarbitrary(final Character c, final Gen g) {
return variant(c << 1, g);
}
};
/**
* A coarbitrary for floats.
*/
public static final Coarbitrary coarbFloat = new Coarbitrary() {
public Gen coarbitrary(final Float f, final Gen g) {
return coarbInteger.coarbitrary(floatToRawIntBits(f), g);
}
};
/**
* A coarbitrary for doubles.
*/
public static final Coarbitrary coarbDouble = new Coarbitrary() {
public Gen coarbitrary(final Double d, final Gen g) {
return coarbLong.coarbitrary(doubleToRawLongBits(d), g);
}
};
/**
* A coarbitrary for the optional value.
*
* @param ca A coarbitrary for the type of the optional value.
* @return A coarbitrary for the optional value.
*/
public static Coarbitrary> coarbOption(final Coarbitrary ca) {
return new Coarbitrary>() {
public Gen coarbitrary(final Option o, final Gen g) {
return o.isNone() ? variant(0, g) : variant(1, ca.coarbitrary(o.some(), g));
}
};
}
/**
* A coarbitrary for the disjoint union.
*
* @param ca A coarbitrary for one side of the disjoint union.
* @param cb A coarbitrary for one side of the disjoint union.
* @return A coarbitrary for the disjoint union.
*/
public static Coarbitrary> coarbEither(final Coarbitrary ca, final Coarbitrary cb) {
return new Coarbitrary>() {
public Gen coarbitrary(final Either e, final Gen g) {
return e.isLeft() ?
variant(0, ca.coarbitrary(e.left().value(), g)) :
variant(1, cb.coarbitrary(e.right().value(), g));
}
};
}
/**
* A coarbitrary for lists.
*
* @param ca A coarbitrary for the elements of the list.
* @return A coarbitrary for lists.
*/
public static Coarbitrary> coarbList(final Coarbitrary ca) {
return new Coarbitrary>() {
public Gen coarbitrary(final List as, final Gen g) {
return as.isEmpty() ?
variant(0, g) :
variant(1, ca.coarbitrary(as.head(), coarbitrary(as.tail(), g)));
}
};
}
/**
* A coarbitrary for strings.
*/
public static final Coarbitrary coarbString = new Coarbitrary() {
public Gen coarbitrary(final String s, final Gen g) {
return coarbList(coarbCharacter).coarbitrary(fromString(s), g);
}
};
/**
* A coarbitrary for string buffers.
*/
public static final Coarbitrary coarbStringBuffer = new Coarbitrary() {
public Gen coarbitrary(final StringBuffer s, final Gen g) {
return coarbString.coarbitrary(s.toString(), g);
}
};
/**
* A coarbitrary for string builders.
*/
public static final Coarbitrary coarbStringBuilder = new Coarbitrary() {
public Gen coarbitrary(final StringBuilder s, final Gen g) {
return coarbString.coarbitrary(s.toString(), g);
}
};
/**
* A coarbitrary for streams.
*
* @param ca A coarbitrary for the elements of the stream.
* @return A coarbitrary for streams.
*/
public static Coarbitrary> coarbStream(final Coarbitrary ca) {
return new Coarbitrary>() {
public Gen coarbitrary(final Stream as, final Gen g) {
return as.isEmpty() ?
variant(0, g) :
variant(1, ca.coarbitrary(as.head(), coarbitrary(as.tail()._1(), g)));
}
};
}
/**
* A coarbitrary for the provided LcgRng
* @return A coarbitrary for the provided LcgRng.
*/
public static Coarbitrary coarbLcgRng() {
return new Coarbitrary() {
@Override
public Gen coarbitrary(LcgRng rng, Gen g) {
long i = rng.getSeed();
return variant(i >= 0 ? 2 * i : -2 * i + 1, g);
}
};
}
/**
* A coarbitrary for state.
*/
public static Coarbitrary> coarbState(Arbitrary as, F2 f) {
return new Coarbitrary>() {
@Override
public Gen coarbitrary(State s1, Gen g) {
return as.gen.bind(r -> {
P2 p = s1.run(r);
return variant(f.f(p._1(), p._2()), g);
});
}
};
}
/**
* A coarbitrary for arrays.
*
* @param ca A coarbitrary for the elements of the array.
* @return A coarbitrary for arrays.
*/
public static Coarbitrary> coarbArray(final Coarbitrary ca) {
return new Coarbitrary>() {
public Gen coarbitrary(final Array as, final Gen g) {
return coarbList(ca).coarbitrary(as.toList(), g);
}
};
}
/**
* A coarbitrary for throwables.
*
* @param cs A coarbitrary for the throwable message.
* @return A coarbitrary for throwables.
*/
public static Coarbitrary coarbThrowable(final Coarbitrary cs) {
return cs.contramap(new F() {
public String f(final Throwable t) {
return t.getMessage();
}
});
}
/**
* A coarbitrary for throwables.
*/
public static final Coarbitrary coarbThrowable =
coarbThrowable(coarbString);
// BEGIN java.util
/**
* A coarbitrary for array lists.
*
* @param ca A coarbitrary for the elements of the array list.
* @return A coarbitrary for array lists.
*/
public static Coarbitrary> coarbArrayList(final Coarbitrary ca) {
return new Coarbitrary>() {
@SuppressWarnings({"unchecked"})
public Gen coarbitrary(final ArrayList as, final Gen g) {
return coarbArray(ca).coarbitrary(array(as.toArray((A[]) new Object[as.size()])), g);
}
};
}
/**
* A coarbitrary for bit sets.
*/
public static final Coarbitrary