Copyright 2008 - 2010 Tony Morris, Runar Bjarnason, Tom Adams, Brad Clow, Ricky Clarkson, Nick Partridge, Jason Zaugg

This software is released under an open source BSD licence.

fj.test
Class Property

java.lang.Object
  extended by fj.test.Property

public final class Property
extends Object

Represents an algebraic property about a program that may be checked for its truth value. For example, it is true that "for all integers (call it x) and for all integers (call it y), then x + y is equivalent to y + x". This statement is a (algebraic) property, proposition or theorem that, when checked, will at least (depending on arguments) fail to be falsified — since there does not exist a counter-example to this statement.


Method Summary
 Property and(Property p)
          Performs a conjunction of this property with the given property.
 CheckResult check()
          Checks this property using a standard random generator, 100 minimum successful checks, 500 maximum discarded tests, minimum size of 0, maximum size of 100.
 CheckResult check(int minSize, int maxSize)
          Checks this property using a standard random generator, 100 minimum successful checks, 500 maximum discarded tests and the given arguments to produce a result.
 CheckResult check(int minSuccessful, int maxDiscarded, int minSize, int maxSize)
          Checks this property using a standard random generator and the given arguments to produce a result.
 CheckResult check(Rand r)
          Checks this property using the given random generator, 100 minimum successful checks, 500 maximum discarded tests, minimum size of 0, maximum size of 100.
 CheckResult check(Rand r, int minSize, int maxSize)
          Checks this property using the given random generator, 100 minimum successful checks, 500 maximum discarded tests, the given minimum size and the given maximum size.
 CheckResult check(Rand r, int minSuccessful, int maxDiscarded, int minSize, int maxSize)
          Checks this property using the given arguments and produces a result.
static Property exception(P1<Property> p)
          Returns a property that has a result of exception, if the evaluation of the given property throws an exception; otherwise, the given property is returned.
static
<A> Property
forall(Gen<A> g, Shrink<A> shrink, F<A,P1<Property>> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static Property fromGen(Gen<Result> g)
          Constructs a property from a generator of results.
 Gen<Result> gen()
          Returns a generator of results from this property.
static Property implies(boolean b, P1<Property> p)
          Returns a property that produces a result only if the given condition satisfies.
 CheckResult maxDiscarded(int maxDiscarded)
          Checks this property using a standard random generator, 100 minimum successful checks, the given maximum discarded tests, minimum size of 0, maximum size of 100.
 CheckResult maxDiscarded(Rand r, int maxDiscarded)
          Checks this property using a the given random generator}, 100 minimum successful checks, the given maximum discarded tests, minimum size of 0, maximum size of 100.
 CheckResult maxSize(int maxSize)
          Checks this property using a standard random generator, 100 minimum successful checks, 500 maximum discarded tests, minimum size of 0, the given maximum size.
 CheckResult maxSize(Rand r, int maxSize)
          Checks this property using the given random generator, 100 minimum successful checks, 500 maximum discarded tests, minimum size of 0, the given maximum size.
 CheckResult minSize(int minSize)
          Checks this property using a standard random generator, 100 minimum successful checks, 500 maximum discarded tests, the given minimum size, maximum size of 100.
 CheckResult minSize(Rand r, int minSize)
          Checks this property using the given random generator, 100 minimum successful checks, 500 maximum discarded tests, the given minimum size, maximum size of 100.
 CheckResult minSuccessful(int minSuccessful)
          Checks this property using a standard random generator, the given minimum successful checks, 500 maximum discarded tests, minimum size of 0, maximum size of 100.
 CheckResult minSuccessful(Rand r, int minSuccessful)
          Checks this property using the given random generator, the given minimum successful checks, 500 maximum discarded tests, minimum size of 0, maximum size of 100.
 Property or(Property p)
          Performs a disjunction of this property with the given property.
static Property prop(boolean b)
          Returns a property that is either proven (the given condition satsifies) or falsified otherwise.
static Property prop(F<Integer,F<Rand,Result>> f)
          Returns a property from the given function.
 Result prop(int i, Rand r)
          Returns the result of applying the given size and random generator.
static Property prop(Result r)
          Returns a property that always has the given result.
static
<A,B,C,D,E,F$,G,H>
Property
property(Arbitrary<A> aa, Arbitrary<B> ab, Arbitrary<C> ac, Arbitrary<D> ad, Arbitrary<E> ae, Arbitrary<F$> af, Arbitrary<G> ag, Arbitrary<H> ah, F<A,F<B,F<C,F<D,F<E,F<F$,F<G,F<H,Property>>>>>>>> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B,C,D,E,F$,G,H>
Property
property(Arbitrary<A> aa, Arbitrary<B> ab, Arbitrary<C> ac, Arbitrary<D> ad, Arbitrary<E> ae, Arbitrary<F$> af, Arbitrary<G> ag, Arbitrary<H> ah, F8<A,B,C,D,E,F$,G,H,Property> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B,C,D,E,F$,G,H>
Property
property(Arbitrary<A> aa, Arbitrary<B> ab, Arbitrary<C> ac, Arbitrary<D> ad, Arbitrary<E> ae, Arbitrary<F$> af, Arbitrary<G> ag, Arbitrary<H> ah, Shrink<A> sa, Shrink<B> sb, Shrink<C> sc, Shrink<D> sd, Shrink<E> se, Shrink<F$> sf, Shrink<G> sg, Shrink<H> sh, F<A,F<B,F<C,F<D,F<E,F<F$,F<G,F<H,Property>>>>>>>> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B,C,D,E,F$,G,H>
Property
property(Arbitrary<A> aa, Arbitrary<B> ab, Arbitrary<C> ac, Arbitrary<D> ad, Arbitrary<E> ae, Arbitrary<F$> af, Arbitrary<G> ag, Arbitrary<H> ah, Shrink<A> sa, Shrink<B> sb, Shrink<C> sc, Shrink<D> sd, Shrink<E> se, Shrink<F$> sf, Shrink<G> sg, Shrink<H> sh, F8<A,B,C,D,E,F$,G,H,Property> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B,C,D,E,F$,G>
Property
property(Arbitrary<A> aa, Arbitrary<B> ab, Arbitrary<C> ac, Arbitrary<D> ad, Arbitrary<E> ae, Arbitrary<F$> af, Arbitrary<G> ag, F<A,F<B,F<C,F<D,F<E,F<F$,F<G,Property>>>>>>> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B,C,D,E,F$,G>
Property
property(Arbitrary<A> aa, Arbitrary<B> ab, Arbitrary<C> ac, Arbitrary<D> ad, Arbitrary<E> ae, Arbitrary<F$> af, Arbitrary<G> ag, F7<A,B,C,D,E,F$,G,Property> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B,C,D,E,F$,G>
Property
property(Arbitrary<A> aa, Arbitrary<B> ab, Arbitrary<C> ac, Arbitrary<D> ad, Arbitrary<E> ae, Arbitrary<F$> af, Arbitrary<G> ag, Shrink<A> sa, Shrink<B> sb, Shrink<C> sc, Shrink<D> sd, Shrink<E> se, Shrink<F$> sf, Shrink<G> sg, F<A,F<B,F<C,F<D,F<E,F<F$,F<G,Property>>>>>>> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B,C,D,E,F$,G>
Property
property(Arbitrary<A> aa, Arbitrary<B> ab, Arbitrary<C> ac, Arbitrary<D> ad, Arbitrary<E> ae, Arbitrary<F$> af, Arbitrary<G> ag, Shrink<A> sa, Shrink<B> sb, Shrink<C> sc, Shrink<D> sd, Shrink<E> se, Shrink<F$> sf, Shrink<G> sg, F7<A,B,C,D,E,F$,G,Property> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B,C,D,E,F$>
Property
property(Arbitrary<A> aa, Arbitrary<B> ab, Arbitrary<C> ac, Arbitrary<D> ad, Arbitrary<E> ae, Arbitrary<F$> af, F<A,F<B,F<C,F<D,F<E,F<F$,Property>>>>>> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B,C,D,E,F$>
Property
property(Arbitrary<A> aa, Arbitrary<B> ab, Arbitrary<C> ac, Arbitrary<D> ad, Arbitrary<E> ae, Arbitrary<F$> af, F6<A,B,C,D,E,F$,Property> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B,C,D,E,F$>
Property
property(Arbitrary<A> aa, Arbitrary<B> ab, Arbitrary<C> ac, Arbitrary<D> ad, Arbitrary<E> ae, Arbitrary<F$> af, Shrink<A> sa, Shrink<B> sb, Shrink<C> sc, Shrink<D> sd, Shrink<E> se, Shrink<F$> sf, F<A,F<B,F<C,F<D,F<E,F<F$,Property>>>>>> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B,C,D,E,F$>
Property
property(Arbitrary<A> aa, Arbitrary<B> ab, Arbitrary<C> ac, Arbitrary<D> ad, Arbitrary<E> ae, Arbitrary<F$> af, Shrink<A> sa, Shrink<B> sb, Shrink<C> sc, Shrink<D> sd, Shrink<E> se, Shrink<F$> sf, F6<A,B,C,D,E,F$,Property> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B,C,D,E>
Property
property(Arbitrary<A> aa, Arbitrary<B> ab, Arbitrary<C> ac, Arbitrary<D> ad, Arbitrary<E> ae, F<A,F<B,F<C,F<D,F<E,Property>>>>> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B,C,D,E>
Property
property(Arbitrary<A> aa, Arbitrary<B> ab, Arbitrary<C> ac, Arbitrary<D> ad, Arbitrary<E> ae, F5<A,B,C,D,E,Property> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B,C,D,E>
Property
property(Arbitrary<A> aa, Arbitrary<B> ab, Arbitrary<C> ac, Arbitrary<D> ad, Arbitrary<E> ae, Shrink<A> sa, Shrink<B> sb, Shrink<C> sc, Shrink<D> sd, Shrink<E> se, F<A,F<B,F<C,F<D,F<E,Property>>>>> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B,C,D,E>
Property
property(Arbitrary<A> aa, Arbitrary<B> ab, Arbitrary<C> ac, Arbitrary<D> ad, Arbitrary<E> ae, Shrink<A> sa, Shrink<B> sb, Shrink<C> sc, Shrink<D> sd, Shrink<E> se, F5<A,B,C,D,E,Property> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B,C,D> Property
property(Arbitrary<A> aa, Arbitrary<B> ab, Arbitrary<C> ac, Arbitrary<D> ad, F<A,F<B,F<C,F<D,Property>>>> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B,C,D> Property
property(Arbitrary<A> aa, Arbitrary<B> ab, Arbitrary<C> ac, Arbitrary<D> ad, F4<A,B,C,D,Property> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B,C,D> Property
property(Arbitrary<A> aa, Arbitrary<B> ab, Arbitrary<C> ac, Arbitrary<D> ad, Shrink<A> sa, Shrink<B> sb, Shrink<C> sc, Shrink<D> sd, F<A,F<B,F<C,F<D,Property>>>> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B,C,D> Property
property(Arbitrary<A> aa, Arbitrary<B> ab, Arbitrary<C> ac, Arbitrary<D> ad, Shrink<A> sa, Shrink<B> sb, Shrink<C> sc, Shrink<D> sd, F4<A,B,C,D,Property> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B,C> Property
property(Arbitrary<A> aa, Arbitrary<B> ab, Arbitrary<C> ac, F<A,F<B,F<C,Property>>> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B,C> Property
property(Arbitrary<A> aa, Arbitrary<B> ab, Arbitrary<C> ac, F3<A,B,C,Property> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B,C> Property
property(Arbitrary<A> aa, Arbitrary<B> ab, Arbitrary<C> ac, Shrink<A> sa, Shrink<B> sb, Shrink<C> sc, F<A,F<B,F<C,Property>>> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B,C> Property
property(Arbitrary<A> aa, Arbitrary<B> ab, Arbitrary<C> ac, Shrink<A> sa, Shrink<B> sb, Shrink<C> sc, F3<A,B,C,Property> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B> Property
property(Arbitrary<A> aa, Arbitrary<B> ab, F<A,F<B,Property>> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B> Property
property(Arbitrary<A> aa, Arbitrary<B> ab, F2<A,B,Property> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B> Property
property(Arbitrary<A> aa, Arbitrary<B> ab, Shrink<A> sa, Shrink<B> sb, F<A,F<B,Property>> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B> Property
property(Arbitrary<A> aa, Arbitrary<B> ab, Shrink<A> sa, Shrink<B> sb, F2<A,B,Property> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A> Property
property(Arbitrary<A> aa, F<A,Property> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A> Property
property(Arbitrary<A> aa, Shrink<A> sa, F<A,Property> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B> Property
propertyP(Arbitrary<A> aa, Arbitrary<B> ab, F<A,F<B,P1<Property>>> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B> Property
propertyP(Arbitrary<A> aa, Arbitrary<B> ab, F2<A,B,P1<Property>> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B> Property
propertyP(Arbitrary<A> aa, Arbitrary<B> ab, Shrink<A> sa, Shrink<B> sb, F<A,F<B,P1<Property>>> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A,B> Property
propertyP(Arbitrary<A> aa, Arbitrary<B> ab, Shrink<A> sa, Shrink<B> sb, F2<A,B,P1<Property>> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A> Property
propertyP(Arbitrary<A> aa, F<A,P1<Property>> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
static
<A> Property
propertyP(Arbitrary<A> aa, Shrink<A> sa, F<A,P1<Property>> f)
          Returns a property where its result is derived from universal quantification across the application of its arguments.
 Property sequence(Property p)
          Performs a sequence of this property with the given property.
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Method Detail

prop

public Result prop(int i,
                   Rand r)
Returns the result of applying the given size and random generator.

Parameters:
i - The size to use to obtain a result.
r - The random generator to use to obtain a result.
Returns:
The result of applying the given size and random generator.

gen

public Gen<Result> gen()
Returns a generator of results from this property.

Returns:
A generator of results from this property.

and

public Property and(Property p)
Performs a conjunction of this property with the given property.

Parameters:
p - The property to perform the conjunction with.
Returns:
A conjunction of this property with the given property.

or

public Property or(Property p)
Performs a disjunction of this property with the given property.

Parameters:
p - The property to perform the disjunction with.
Returns:
A disjunction of this property with the given property.

sequence

public Property sequence(Property p)
Performs a sequence of this property with the given property. The returned property holds if and only if this property and the given property also hold. If one property does not hold, but the other does, then the returned property will produce the same result and the property that holds.

Parameters:
p - The property to sequence this property with.
Returns:
A sequence of this property with the given property.

check

public CheckResult check(Rand r,
                         int minSuccessful,
                         int maxDiscarded,
                         int minSize,
                         int maxSize)
Checks this property using the given arguments and produces a result.

Parameters:
r - The random generator to use for checking.
minSuccessful - The minimum number of successful tests before a result is reached.
maxDiscarded - The maximum number of tests discarded because they did not satisfy pre-conditions (i.e. implies(boolean, P1)).
minSize - The minimum size to use for checking.
maxSize - The maximum size to use for checking.
Returns:
A result after checking this property.

check

public CheckResult check(int minSuccessful,
                         int maxDiscarded,
                         int minSize,
                         int maxSize)
Checks this property using a standard random generator and the given arguments to produce a result.

Parameters:
minSuccessful - The minimum number of successful tests before a result is reached.
maxDiscarded - The maximum number of tests discarded because they did not satisfy pre-conditions (i.e. implies(boolean, P1)).
minSize - The minimum size to use for checking.
maxSize - The maximum size to use for checking.
Returns:
A result after checking this property.

check

public CheckResult check(Rand r)
Checks this property using the given random generator, 100 minimum successful checks, 500 maximum discarded tests, minimum size of 0, maximum size of 100.

Parameters:
r - The random generator.
Returns:
A result after checking this property.

check

public CheckResult check(Rand r,
                         int minSize,
                         int maxSize)
Checks this property using the given random generator, 100 minimum successful checks, 500 maximum discarded tests, the given minimum size and the given maximum size.

Parameters:
r - The random generator.
minSize - The minimum size to use for checking.
maxSize - The maximum size to use for checking.
Returns:
A result after checking this property.

check

public CheckResult check(int minSize,
                         int maxSize)
Checks this property using a standard random generator, 100 minimum successful checks, 500 maximum discarded tests and the given arguments to produce a result.

Parameters:
minSize - The minimum size to use for checking.
maxSize - The maximum size to use for checking.
Returns:
A result after checking this property.

check

public CheckResult check()
Checks this property using a standard random generator, 100 minimum successful checks, 500 maximum discarded tests, minimum size of 0, maximum size of 100.

Returns:
A result after checking this property.

minSuccessful

public CheckResult minSuccessful(int minSuccessful)
Checks this property using a standard random generator, the given minimum successful checks, 500 maximum discarded tests, minimum size of 0, maximum size of 100.

Parameters:
minSuccessful - The minimum number of successful tests before a result is reached.
Returns:
A result after checking this property.

minSuccessful

public CheckResult minSuccessful(Rand r,
                                 int minSuccessful)
Checks this property using the given random generator, the given minimum successful checks, 500 maximum discarded tests, minimum size of 0, maximum size of 100.

Parameters:
r - The random generator.
minSuccessful - The minimum number of successful tests before a result is reached.
Returns:
A result after checking this property.

maxDiscarded

public CheckResult maxDiscarded(int maxDiscarded)
Checks this property using a standard random generator, 100 minimum successful checks, the given maximum discarded tests, minimum size of 0, maximum size of 100.

Parameters:
maxDiscarded - The maximum number of tests discarded because they did not satisfy pre-conditions (i.e. implies(boolean, P1)).
Returns:
A result after checking this property.

maxDiscarded

public CheckResult maxDiscarded(Rand r,
                                int maxDiscarded)
Checks this property using a the given random generator}, 100 minimum successful checks, the given maximum discarded tests, minimum size of 0, maximum size of 100.

Parameters:
r - The random generator.
maxDiscarded - The maximum number of tests discarded because they did not satisfy pre-conditions (i.e. implies(boolean, P1)).
Returns:
A result after checking this property.

minSize

public CheckResult minSize(int minSize)
Checks this property using a standard random generator, 100 minimum successful checks, 500 maximum discarded tests, the given minimum size, maximum size of 100.

Parameters:
minSize - The minimum size to use for checking.
Returns:
A result after checking this property.

minSize

public CheckResult minSize(Rand r,
                           int minSize)
Checks this property using the given random generator, 100 minimum successful checks, 500 maximum discarded tests, the given minimum size, maximum size of 100.

Parameters:
r - The random generator.
minSize - The minimum size to use for checking.
Returns:
A result after checking this property.

maxSize

public CheckResult maxSize(int maxSize)
Checks this property using a standard random generator, 100 minimum successful checks, 500 maximum discarded tests, minimum size of 0, the given maximum size.

Parameters:
maxSize - The maximum size to use for checking.
Returns:
A result after checking this property.

maxSize

public CheckResult maxSize(Rand r,
                           int maxSize)
Checks this property using the given random generator, 100 minimum successful checks, 500 maximum discarded tests, minimum size of 0, the given maximum size.

Parameters:
r - The random generator.
maxSize - The maximum size to use for checking.
Returns:
A result after checking this property.

implies

public static Property implies(boolean b,
                               P1<Property> p)
Returns a property that produces a result only if the given condition satisfies. The result will be taken from the given property.

Parameters:
b - The condition that, if satisfied, produces the given property.
p - The property to return if the condition satisfies.
Returns:
A property that produces a result only if the given condition satisfies.

prop

public static Property prop(F<Integer,F<Rand,Result>> f)
Returns a property from the given function.

Parameters:
f - The function to construct the returned property with.
Returns:
A property from the given function.

prop

public static Property prop(Result r)
Returns a property that always has the given result.

Parameters:
r - The result of the returned property.
Returns:
A property that always has the given result.

prop

public static Property prop(boolean b)
Returns a property that is either proven (the given condition satsifies) or falsified otherwise.

Parameters:
b - The condition that, if satisfied, returns a property that is proven; otherwise, the property is falsified.
Returns:
A property that is either proven (the given condition satsifies) or falsified otherwise.

fromGen

public static Property fromGen(Gen<Result> g)
Constructs a property from a generator of results.

Parameters:
g - The generator of results to constructor a property with.
Returns:
A property from a generator of results.

forall

public static <A> Property forall(Gen<A> g,
                                  Shrink<A> shrink,
                                  F<A,P1<Property>> f)
Returns a property where its result is derived from universal quantification across the application of its arguments.

Parameters:
g - The generator to produces values from to produce the property with.
shrink - The shrink strategy to use upon falsification.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

propertyP

public static <A> Property propertyP(Arbitrary<A> aa,
                                     Shrink<A> sa,
                                     F<A,P1<Property>> f)
Returns a property where its result is derived from universal quantification across the application of its arguments.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
sa - The shrink strategy to use upon falsification.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A> Property property(Arbitrary<A> aa,
                                    Shrink<A> sa,
                                    F<A,Property> f)
Returns a property where its result is derived from universal quantification across the application of its arguments.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
sa - The shrink strategy to use upon falsification.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

propertyP

public static <A> Property propertyP(Arbitrary<A> aa,
                                     F<A,P1<Property>> f)
Returns a property where its result is derived from universal quantification across the application of its arguments. No shrinking occurs upon falsification.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A> Property property(Arbitrary<A> aa,
                                    F<A,Property> f)
Returns a property where its result is derived from universal quantification across the application of its arguments. No shrinking occurs upon falsification.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

propertyP

public static <A,B> Property propertyP(Arbitrary<A> aa,
                                       Arbitrary<B> ab,
                                       Shrink<A> sa,
                                       Shrink<B> sb,
                                       F<A,F<B,P1<Property>>> f)
Returns a property where its result is derived from universal quantification across the application of its arguments.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
sa - The shrink strategy to use upon falsification.
sb - The shrink strategy to use upon falsification.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A,B> Property property(Arbitrary<A> aa,
                                      Arbitrary<B> ab,
                                      Shrink<A> sa,
                                      Shrink<B> sb,
                                      F<A,F<B,Property>> f)
Returns a property where its result is derived from universal quantification across the application of its arguments.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
sa - The shrink strategy to use upon falsification.
sb - The shrink strategy to use upon falsification.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

propertyP

public static <A,B> Property propertyP(Arbitrary<A> aa,
                                       Arbitrary<B> ab,
                                       F<A,F<B,P1<Property>>> f)
Returns a property where its result is derived from universal quantification across the application of its arguments. No shrinking occurs upon falsification.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A,B> Property property(Arbitrary<A> aa,
                                      Arbitrary<B> ab,
                                      F<A,F<B,Property>> f)
Returns a property where its result is derived from universal quantification across the application of its arguments. No shrinking occurs upon falsification.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

propertyP

public static <A,B> Property propertyP(Arbitrary<A> aa,
                                       Arbitrary<B> ab,
                                       Shrink<A> sa,
                                       Shrink<B> sb,
                                       F2<A,B,P1<Property>> f)
Returns a property where its result is derived from universal quantification across the application of its arguments.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
sa - The shrink strategy to use upon falsification.
sb - The shrink strategy to use upon falsification.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A,B> Property property(Arbitrary<A> aa,
                                      Arbitrary<B> ab,
                                      Shrink<A> sa,
                                      Shrink<B> sb,
                                      F2<A,B,Property> f)
Returns a property where its result is derived from universal quantification across the application of its arguments.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
sa - The shrink strategy to use upon falsification.
sb - The shrink strategy to use upon falsification.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

propertyP

public static <A,B> Property propertyP(Arbitrary<A> aa,
                                       Arbitrary<B> ab,
                                       F2<A,B,P1<Property>> f)
Returns a property where its result is derived from universal quantification across the application of its arguments. No shrinking occurs upon falsification.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A,B> Property property(Arbitrary<A> aa,
                                      Arbitrary<B> ab,
                                      F2<A,B,Property> f)
Returns a property where its result is derived from universal quantification across the application of its arguments. No shrinking occurs upon falsification.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A,B,C> Property property(Arbitrary<A> aa,
                                        Arbitrary<B> ab,
                                        Arbitrary<C> ac,
                                        Shrink<A> sa,
                                        Shrink<B> sb,
                                        Shrink<C> sc,
                                        F<A,F<B,F<C,Property>>> f)
Returns a property where its result is derived from universal quantification across the application of its arguments.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
ac - The arbitrrary to produces values from to produce the property with.
sa - The shrink strategy to use upon falsification.
sb - The shrink strategy to use upon falsification.
sc - The shrink strategy to use upon falsification.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A,B,C> Property property(Arbitrary<A> aa,
                                        Arbitrary<B> ab,
                                        Arbitrary<C> ac,
                                        F<A,F<B,F<C,Property>>> f)
Returns a property where its result is derived from universal quantification across the application of its arguments. No shrinking occurs upon falsification.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
ac - The arbitrrary to produces values from to produce the property with.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A,B,C> Property property(Arbitrary<A> aa,
                                        Arbitrary<B> ab,
                                        Arbitrary<C> ac,
                                        Shrink<A> sa,
                                        Shrink<B> sb,
                                        Shrink<C> sc,
                                        F3<A,B,C,Property> f)
Returns a property where its result is derived from universal quantification across the application of its arguments.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
ac - The arbitrrary to produces values from to produce the property with.
sa - The shrink strategy to use upon falsification.
sb - The shrink strategy to use upon falsification.
sc - The shrink strategy to use upon falsification.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A,B,C> Property property(Arbitrary<A> aa,
                                        Arbitrary<B> ab,
                                        Arbitrary<C> ac,
                                        F3<A,B,C,Property> f)
Returns a property where its result is derived from universal quantification across the application of its arguments. No shrinking occurs upon falsification.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
ac - The arbitrrary to produces values from to produce the property with.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A,B,C,D> Property property(Arbitrary<A> aa,
                                          Arbitrary<B> ab,
                                          Arbitrary<C> ac,
                                          Arbitrary<D> ad,
                                          Shrink<A> sa,
                                          Shrink<B> sb,
                                          Shrink<C> sc,
                                          Shrink<D> sd,
                                          F<A,F<B,F<C,F<D,Property>>>> f)
Returns a property where its result is derived from universal quantification across the application of its arguments.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
ac - The arbitrrary to produces values from to produce the property with.
ad - The arbitrrary to produces values from to produce the property with.
sa - The shrink strategy to use upon falsification.
sb - The shrink strategy to use upon falsification.
sc - The shrink strategy to use upon falsification.
sd - The shrink strategy to use upon falsification.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A,B,C,D> Property property(Arbitrary<A> aa,
                                          Arbitrary<B> ab,
                                          Arbitrary<C> ac,
                                          Arbitrary<D> ad,
                                          F<A,F<B,F<C,F<D,Property>>>> f)
Returns a property where its result is derived from universal quantification across the application of its arguments. No shrinking occurs upon falsification.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
ac - The arbitrrary to produces values from to produce the property with.
ad - The arbitrrary to produces values from to produce the property with.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A,B,C,D> Property property(Arbitrary<A> aa,
                                          Arbitrary<B> ab,
                                          Arbitrary<C> ac,
                                          Arbitrary<D> ad,
                                          Shrink<A> sa,
                                          Shrink<B> sb,
                                          Shrink<C> sc,
                                          Shrink<D> sd,
                                          F4<A,B,C,D,Property> f)
Returns a property where its result is derived from universal quantification across the application of its arguments.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
ac - The arbitrrary to produces values from to produce the property with.
ad - The arbitrrary to produces values from to produce the property with.
sa - The shrink strategy to use upon falsification.
sb - The shrink strategy to use upon falsification.
sc - The shrink strategy to use upon falsification.
sd - The shrink strategy to use upon falsification.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A,B,C,D> Property property(Arbitrary<A> aa,
                                          Arbitrary<B> ab,
                                          Arbitrary<C> ac,
                                          Arbitrary<D> ad,
                                          F4<A,B,C,D,Property> f)
Returns a property where its result is derived from universal quantification across the application of its arguments. No shrinking occurs upon falsification.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
ac - The arbitrrary to produces values from to produce the property with.
ad - The arbitrrary to produces values from to produce the property with.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A,B,C,D,E> Property property(Arbitrary<A> aa,
                                            Arbitrary<B> ab,
                                            Arbitrary<C> ac,
                                            Arbitrary<D> ad,
                                            Arbitrary<E> ae,
                                            Shrink<A> sa,
                                            Shrink<B> sb,
                                            Shrink<C> sc,
                                            Shrink<D> sd,
                                            Shrink<E> se,
                                            F<A,F<B,F<C,F<D,F<E,Property>>>>> f)
Returns a property where its result is derived from universal quantification across the application of its arguments.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
ac - The arbitrrary to produces values from to produce the property with.
ad - The arbitrrary to produces values from to produce the property with.
ae - The arbitrrary to produces values from to produce the property with.
sa - The shrink strategy to use upon falsification.
sb - The shrink strategy to use upon falsification.
sc - The shrink strategy to use upon falsification.
sd - The shrink strategy to use upon falsification.
se - The shrink strategy to use upon falsification.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A,B,C,D,E> Property property(Arbitrary<A> aa,
                                            Arbitrary<B> ab,
                                            Arbitrary<C> ac,
                                            Arbitrary<D> ad,
                                            Arbitrary<E> ae,
                                            F<A,F<B,F<C,F<D,F<E,Property>>>>> f)
Returns a property where its result is derived from universal quantification across the application of its arguments. No shrinking occurs upon falsification.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
ac - The arbitrrary to produces values from to produce the property with.
ad - The arbitrrary to produces values from to produce the property with.
ae - The arbitrrary to produces values from to produce the property with.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A,B,C,D,E> Property property(Arbitrary<A> aa,
                                            Arbitrary<B> ab,
                                            Arbitrary<C> ac,
                                            Arbitrary<D> ad,
                                            Arbitrary<E> ae,
                                            Shrink<A> sa,
                                            Shrink<B> sb,
                                            Shrink<C> sc,
                                            Shrink<D> sd,
                                            Shrink<E> se,
                                            F5<A,B,C,D,E,Property> f)
Returns a property where its result is derived from universal quantification across the application of its arguments.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
ac - The arbitrrary to produces values from to produce the property with.
ad - The arbitrrary to produces values from to produce the property with.
ae - The arbitrrary to produces values from to produce the property with.
sa - The shrink strategy to use upon falsification.
sb - The shrink strategy to use upon falsification.
sc - The shrink strategy to use upon falsification.
sd - The shrink strategy to use upon falsification.
se - The shrink strategy to use upon falsification.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A,B,C,D,E> Property property(Arbitrary<A> aa,
                                            Arbitrary<B> ab,
                                            Arbitrary<C> ac,
                                            Arbitrary<D> ad,
                                            Arbitrary<E> ae,
                                            F5<A,B,C,D,E,Property> f)
Returns a property where its result is derived from universal quantification across the application of its arguments. No shrinking occurs upon falsification.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
ac - The arbitrrary to produces values from to produce the property with.
ad - The arbitrrary to produces values from to produce the property with.
ae - The arbitrrary to produces values from to produce the property with.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A,B,C,D,E,F$> Property property(Arbitrary<A> aa,
                                               Arbitrary<B> ab,
                                               Arbitrary<C> ac,
                                               Arbitrary<D> ad,
                                               Arbitrary<E> ae,
                                               Arbitrary<F$> af,
                                               Shrink<A> sa,
                                               Shrink<B> sb,
                                               Shrink<C> sc,
                                               Shrink<D> sd,
                                               Shrink<E> se,
                                               Shrink<F$> sf,
                                               F<A,F<B,F<C,F<D,F<E,F<F$,Property>>>>>> f)
Returns a property where its result is derived from universal quantification across the application of its arguments.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
ac - The arbitrrary to produces values from to produce the property with.
ad - The arbitrrary to produces values from to produce the property with.
ae - The arbitrrary to produces values from to produce the property with.
af - The arbitrrary to produces values from to produce the property with.
sa - The shrink strategy to use upon falsification.
sb - The shrink strategy to use upon falsification.
sc - The shrink strategy to use upon falsification.
sd - The shrink strategy to use upon falsification.
se - The shrink strategy to use upon falsification.
sf - The shrink strategy to use upon falsification.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A,B,C,D,E,F$> Property property(Arbitrary<A> aa,
                                               Arbitrary<B> ab,
                                               Arbitrary<C> ac,
                                               Arbitrary<D> ad,
                                               Arbitrary<E> ae,
                                               Arbitrary<F$> af,
                                               F<A,F<B,F<C,F<D,F<E,F<F$,Property>>>>>> f)
Returns a property where its result is derived from universal quantification across the application of its arguments. No shrinking occurs upon falsification.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
ac - The arbitrrary to produces values from to produce the property with.
ad - The arbitrrary to produces values from to produce the property with.
ae - The arbitrrary to produces values from to produce the property with.
af - The arbitrrary to produces values from to produce the property with.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A,B,C,D,E,F$> Property property(Arbitrary<A> aa,
                                               Arbitrary<B> ab,
                                               Arbitrary<C> ac,
                                               Arbitrary<D> ad,
                                               Arbitrary<E> ae,
                                               Arbitrary<F$> af,
                                               Shrink<A> sa,
                                               Shrink<B> sb,
                                               Shrink<C> sc,
                                               Shrink<D> sd,
                                               Shrink<E> se,
                                               Shrink<F$> sf,
                                               F6<A,B,C,D,E,F$,Property> f)
Returns a property where its result is derived from universal quantification across the application of its arguments.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
ac - The arbitrrary to produces values from to produce the property with.
ad - The arbitrrary to produces values from to produce the property with.
ae - The arbitrrary to produces values from to produce the property with.
af - The arbitrrary to produces values from to produce the property with.
sa - The shrink strategy to use upon falsification.
sb - The shrink strategy to use upon falsification.
sc - The shrink strategy to use upon falsification.
sd - The shrink strategy to use upon falsification.
se - The shrink strategy to use upon falsification.
sf - The shrink strategy to use upon falsification.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A,B,C,D,E,F$> Property property(Arbitrary<A> aa,
                                               Arbitrary<B> ab,
                                               Arbitrary<C> ac,
                                               Arbitrary<D> ad,
                                               Arbitrary<E> ae,
                                               Arbitrary<F$> af,
                                               F6<A,B,C,D,E,F$,Property> f)
Returns a property where its result is derived from universal quantification across the application of its arguments. No shrinking occurs upon falsification.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
ac - The arbitrrary to produces values from to produce the property with.
ad - The arbitrrary to produces values from to produce the property with.
ae - The arbitrrary to produces values from to produce the property with.
af - The arbitrrary to produces values from to produce the property with.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A,B,C,D,E,F$,G> Property property(Arbitrary<A> aa,
                                                 Arbitrary<B> ab,
                                                 Arbitrary<C> ac,
                                                 Arbitrary<D> ad,
                                                 Arbitrary<E> ae,
                                                 Arbitrary<F$> af,
                                                 Arbitrary<G> ag,
                                                 Shrink<A> sa,
                                                 Shrink<B> sb,
                                                 Shrink<C> sc,
                                                 Shrink<D> sd,
                                                 Shrink<E> se,
                                                 Shrink<F$> sf,
                                                 Shrink<G> sg,
                                                 F<A,F<B,F<C,F<D,F<E,F<F$,F<G,Property>>>>>>> f)
Returns a property where its result is derived from universal quantification across the application of its arguments.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
ac - The arbitrrary to produces values from to produce the property with.
ad - The arbitrrary to produces values from to produce the property with.
ae - The arbitrrary to produces values from to produce the property with.
af - The arbitrrary to produces values from to produce the property with.
ag - The arbitrrary to produces values from to produce the property with.
sa - The shrink strategy to use upon falsification.
sb - The shrink strategy to use upon falsification.
sc - The shrink strategy to use upon falsification.
sd - The shrink strategy to use upon falsification.
se - The shrink strategy to use upon falsification.
sf - The shrink strategy to use upon falsification.
sg - The shrink strategy to use upon falsification.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A,B,C,D,E,F$,G> Property property(Arbitrary<A> aa,
                                                 Arbitrary<B> ab,
                                                 Arbitrary<C> ac,
                                                 Arbitrary<D> ad,
                                                 Arbitrary<E> ae,
                                                 Arbitrary<F$> af,
                                                 Arbitrary<G> ag,
                                                 F<A,F<B,F<C,F<D,F<E,F<F$,F<G,Property>>>>>>> f)
Returns a property where its result is derived from universal quantification across the application of its arguments. No shrinking occurs upon falsification.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
ac - The arbitrrary to produces values from to produce the property with.
ad - The arbitrrary to produces values from to produce the property with.
ae - The arbitrrary to produces values from to produce the property with.
af - The arbitrrary to produces values from to produce the property with.
ag - The arbitrrary to produces values from to produce the property with.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A,B,C,D,E,F$,G> Property property(Arbitrary<A> aa,
                                                 Arbitrary<B> ab,
                                                 Arbitrary<C> ac,
                                                 Arbitrary<D> ad,
                                                 Arbitrary<E> ae,
                                                 Arbitrary<F$> af,
                                                 Arbitrary<G> ag,
                                                 Shrink<A> sa,
                                                 Shrink<B> sb,
                                                 Shrink<C> sc,
                                                 Shrink<D> sd,
                                                 Shrink<E> se,
                                                 Shrink<F$> sf,
                                                 Shrink<G> sg,
                                                 F7<A,B,C,D,E,F$,G,Property> f)
Returns a property where its result is derived from universal quantification across the application of its arguments.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
ac - The arbitrrary to produces values from to produce the property with.
ad - The arbitrrary to produces values from to produce the property with.
ae - The arbitrrary to produces values from to produce the property with.
af - The arbitrrary to produces values from to produce the property with.
ag - The arbitrrary to produces values from to produce the property with.
sa - The shrink strategy to use upon falsification.
sb - The shrink strategy to use upon falsification.
sc - The shrink strategy to use upon falsification.
sd - The shrink strategy to use upon falsification.
se - The shrink strategy to use upon falsification.
sf - The shrink strategy to use upon falsification.
sg - The shrink strategy to use upon falsification.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A,B,C,D,E,F$,G> Property property(Arbitrary<A> aa,
                                                 Arbitrary<B> ab,
                                                 Arbitrary<C> ac,
                                                 Arbitrary<D> ad,
                                                 Arbitrary<E> ae,
                                                 Arbitrary<F$> af,
                                                 Arbitrary<G> ag,
                                                 F7<A,B,C,D,E,F$,G,Property> f)
Returns a property where its result is derived from universal quantification across the application of its arguments. No shrinking occurs upon falsification.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
ac - The arbitrrary to produces values from to produce the property with.
ad - The arbitrrary to produces values from to produce the property with.
ae - The arbitrrary to produces values from to produce the property with.
af - The arbitrrary to produces values from to produce the property with.
ag - The arbitrrary to produces values from to produce the property with.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A,B,C,D,E,F$,G,H> Property property(Arbitrary<A> aa,
                                                   Arbitrary<B> ab,
                                                   Arbitrary<C> ac,
                                                   Arbitrary<D> ad,
                                                   Arbitrary<E> ae,
                                                   Arbitrary<F$> af,
                                                   Arbitrary<G> ag,
                                                   Arbitrary<H> ah,
                                                   Shrink<A> sa,
                                                   Shrink<B> sb,
                                                   Shrink<C> sc,
                                                   Shrink<D> sd,
                                                   Shrink<E> se,
                                                   Shrink<F$> sf,
                                                   Shrink<G> sg,
                                                   Shrink<H> sh,
                                                   F<A,F<B,F<C,F<D,F<E,F<F$,F<G,F<H,Property>>>>>>>> f)
Returns a property where its result is derived from universal quantification across the application of its arguments.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
ac - The arbitrrary to produces values from to produce the property with.
ad - The arbitrrary to produces values from to produce the property with.
ae - The arbitrrary to produces values from to produce the property with.
af - The arbitrrary to produces values from to produce the property with.
ag - The arbitrrary to produces values from to produce the property with.
ah - The arbitrrary to produces values from to produce the property with.
sa - The shrink strategy to use upon falsification.
sb - The shrink strategy to use upon falsification.
sc - The shrink strategy to use upon falsification.
sd - The shrink strategy to use upon falsification.
se - The shrink strategy to use upon falsification.
sf - The shrink strategy to use upon falsification.
sg - The shrink strategy to use upon falsification.
sh - The shrink strategy to use upon falsification.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A,B,C,D,E,F$,G,H> Property property(Arbitrary<A> aa,
                                                   Arbitrary<B> ab,
                                                   Arbitrary<C> ac,
                                                   Arbitrary<D> ad,
                                                   Arbitrary<E> ae,
                                                   Arbitrary<F$> af,
                                                   Arbitrary<G> ag,
                                                   Arbitrary<H> ah,
                                                   F<A,F<B,F<C,F<D,F<E,F<F$,F<G,F<H,Property>>>>>>>> f)
Returns a property where its result is derived from universal quantification across the application of its arguments. No shrinking occurs upon falsification.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
ac - The arbitrrary to produces values from to produce the property with.
ad - The arbitrrary to produces values from to produce the property with.
ae - The arbitrrary to produces values from to produce the property with.
af - The arbitrrary to produces values from to produce the property with.
ag - The arbitrrary to produces values from to produce the property with.
ah - The arbitrrary to produces values from to produce the property with.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A,B,C,D,E,F$,G,H> Property property(Arbitrary<A> aa,
                                                   Arbitrary<B> ab,
                                                   Arbitrary<C> ac,
                                                   Arbitrary<D> ad,
                                                   Arbitrary<E> ae,
                                                   Arbitrary<F$> af,
                                                   Arbitrary<G> ag,
                                                   Arbitrary<H> ah,
                                                   Shrink<A> sa,
                                                   Shrink<B> sb,
                                                   Shrink<C> sc,
                                                   Shrink<D> sd,
                                                   Shrink<E> se,
                                                   Shrink<F$> sf,
                                                   Shrink<G> sg,
                                                   Shrink<H> sh,
                                                   F8<A,B,C,D,E,F$,G,H,Property> f)
Returns a property where its result is derived from universal quantification across the application of its arguments.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
ac - The arbitrrary to produces values from to produce the property with.
ad - The arbitrrary to produces values from to produce the property with.
ae - The arbitrrary to produces values from to produce the property with.
af - The arbitrrary to produces values from to produce the property with.
ag - The arbitrrary to produces values from to produce the property with.
ah - The arbitrrary to produces values from to produce the property with.
sa - The shrink strategy to use upon falsification.
sb - The shrink strategy to use upon falsification.
sc - The shrink strategy to use upon falsification.
sd - The shrink strategy to use upon falsification.
se - The shrink strategy to use upon falsification.
sf - The shrink strategy to use upon falsification.
sg - The shrink strategy to use upon falsification.
sh - The shrink strategy to use upon falsification.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

property

public static <A,B,C,D,E,F$,G,H> Property property(Arbitrary<A> aa,
                                                   Arbitrary<B> ab,
                                                   Arbitrary<C> ac,
                                                   Arbitrary<D> ad,
                                                   Arbitrary<E> ae,
                                                   Arbitrary<F$> af,
                                                   Arbitrary<G> ag,
                                                   Arbitrary<H> ah,
                                                   F8<A,B,C,D,E,F$,G,H,Property> f)
Returns a property where its result is derived from universal quantification across the application of its arguments. No shrinking occurs upon falsification.

Parameters:
aa - The arbitrrary to produces values from to produce the property with.
ab - The arbitrrary to produces values from to produce the property with.
ac - The arbitrrary to produces values from to produce the property with.
ad - The arbitrrary to produces values from to produce the property with.
ae - The arbitrrary to produces values from to produce the property with.
af - The arbitrrary to produces values from to produce the property with.
ag - The arbitrrary to produces values from to produce the property with.
ah - The arbitrrary to produces values from to produce the property with.
f - The function to produce properties with results.
Returns:
A property where its result is derived from universal quantification across the application of its arguments.

exception

public static Property exception(P1<Property> p)
Returns a property that has a result of exception, if the evaluation of the given property throws an exception; otherwise, the given property is returned.

Parameters:
p - A property to evaluate to check for an exception.
Returns:
A property that has a result of exception, if the evaluation of the given property throws an exception; otherwise, the given property is returned.

Copyright 2008 - 2010 Tony Morris, Runar Bjarnason, Tom Adams, Brad Clow, Ricky Clarkson, Nick Partridge, Jason Zaugg

This software is released under an open source BSD licence.