Mercurial > hg > Members > tatsuki > functionaljava-master > core

comparison src/main/java/fj/test/Property.java @ 0:fe80c1edf1be

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
add getLoop
author tatsuki
date Fri, 20 Mar 2015 21:04:03 +0900
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:fe80c1edf1be
1 package fj.test;
2
3 import static fj.Function.curry;
4 import static fj.Function.compose2;
5 import static fj.P.p;
6
7 import fj.*;
8
9 import static fj.P2.__2;
10 import fj.data.List;
11 import fj.data.Option;
12 import static fj.data.Option.none;
13 import fj.data.Stream;
14 import static fj.test.Arg.arg;
15 import static fj.test.CheckResult.exhausted;
16 import static fj.test.CheckResult.falsified;
17 import static fj.test.CheckResult.genException;
18 import static fj.test.CheckResult.passed;
19 import static fj.test.CheckResult.propException;
20 import static fj.test.CheckResult.proven;
21 import static fj.test.Result.noResult;
22 import static java.lang.Math.round;
23
24 /**
25 * Represents an algebraic property about a program that may be {@link #check(Rand, int, int, int,
26 * int) checked} for its truth value. For example, it is true that "for all integers (call it x) and
27 * for all integers (call it y), then x + y is equivalent to y + x". This statement is a (algebraic)
28 * property, proposition or theorem that, when checked, will at least (depending on arguments) fail
29 * to be falsified — since there does not exist a counter-example to this statement.
30 *
31 * @version %build.number%
32 */
33 public final class Property {
34 private final F<Integer, F<Rand, Result>> f;
35
36 private Property(final F<Integer, F<Rand, Result>> f) {
37 this.f = f;
38 }
39
40 /**
41 * Returns the result of applying the given size and random generator.
42 *
43 * @param i The size to use to obtain a result.
44 * @param r The random generator to use to obtain a result.
45 * @return The result of applying the given size and random generator.
46 */
47 public Result prop(final int i, final Rand r) {
48 return f.f(i).f(r);
49 }
50
51 /**
52 * Returns a generator of results from this property.
53 *
54 * @return A generator of results from this property.
55 */
56 public Gen<Result> gen() {
57 return Gen.gen(new F<Integer, F<Rand, Result>>() {
58 public F<Rand, Result> f(final Integer i) {
59 return new F<Rand, Result>() {
60 public Result f(final Rand r) {
61 return f.f(i).f(r);
62 }
63 };
64 }
65 });
66 }
67
68 /**
69 * Performs a conjunction of this property with the given property.
70 *
71 * @param p The property to perform the conjunction with.
72 * @return A conjunction of this property with the given property.
73 */
74 public Property and(final Property p) {
75 return fromGen(gen().bind(p.gen(), new F<Result, F<Result, Result>>() {
76 public F<Result, Result> f(final Result res1) {
77 return new F<Result, Result>() {
78 public Result f(final Result res2) {
79 return res1.isException() || res1.isFalsified() ? res1 : res2.isException() || res2.isFalsified() ? res2 : res1.isProven() || res1.isUnfalsified() ? res2 : res2.isProven() || res2.isUnfalsified() ? res1 : noResult();
80 }
81 };
82 }
83 }));
84 }
85
86 /**
87 * Performs a disjunction of this property with the given property.
88 *
89 * @param p The property to perform the disjunction with.
90 * @return A disjunction of this property with the given property.
91 */
92 public Property or(final Property p) {
93 return fromGen(gen().bind(p.gen(), new F<Result, F<Result, Result>>() {
94 public F<Result, Result> f(final Result res1) {
95 return new F<Result, Result>() {
96 public Result f(final Result res2) {
97 return res1.isException() || res1.isFalsified() ? res1 : res2.isException() || res2.isFalsified() ? res2 : res1.isProven() || res1.isUnfalsified() ? res1 : res2.isProven() || res2.isUnfalsified() ? res2 : noResult();
98 }
99 };
100 }
101 }));
102 }
103
104 /**
105 * Performs a sequence of this property with the given property. The returned property holds if
106 * and only if this property and the given property also hold. If one property does not hold, but
107 * the other does, then the returned property will produce the same result and the property that
108 * holds.
109 *
110 * @param p The property to sequence this property with.
111 * @return A sequence of this property with the given property.
112 */
113 public Property sequence(final Property p) {
114 return fromGen(gen().bind(p.gen(), new F<Result, F<Result, Result>>() {
115 public F<Result, Result> f(final Result res1) {
116 return new F<Result, Result>() {
117 public Result f(final Result res2) {
118 return res1.isException() || res1.isProven() || res1.isUnfalsified() ? res1 : res2.isException() || res2.isProven() || res2.isUnfalsified() ? res2 : res1.isFalsified() ? res2 : res2.isFalsified() ? res1 : noResult();
119 }
120 };
121 }
122 }));
123 }
124
125 /**
126 * Checks this property using the given arguments and produces a result.
127 *
128 * @param r The random generator to use for checking.
129 * @param minSuccessful The minimum number of successful tests before a result is reached.
130 * @param maxDiscarded The maximum number of tests discarded because they did not satisfy
131 * pre-conditions (i.e. {@link #implies(boolean, P1)}).
132 * @param minSize The minimum size to use for checking.
133 * @param maxSize The maximum size to use for checking.
134 * @return A result after checking this property.
135 */
136 @SuppressWarnings({"ThrowableResultOfMethodCallIgnored"})
137 public CheckResult check(final Rand r,
138 final int minSuccessful,
139 final int maxDiscarded,
140 final int minSize,
141 final int maxSize) {
142 int s = 0;
143 int d = 0;
144 float sz = minSize;
145 CheckResult res;
146
147 while (true) {
148 final float size = s == 0 && d == 0 ? minSize : sz + (maxSize - sz) / (minSuccessful - s);
149 try {
150 final Result x = f.f(round(size)).f(r);
151 if (x.isNoResult())
152 if (d + 1 >= maxDiscarded) {
153 res = exhausted(s, d + 1);
154 break;
155 } else {
156 sz = size;
157 d++;
158 }
159 else if (x.isProven()) {
160 res = proven(x.args().some(), s + 1, d);
161 break;
162 } else if (x.isUnfalsified())
163 if (s + 1 >= minSuccessful) {
164 res = passed(s + 1, d);
165 break;
166 } else {
167 sz = size;
168 s++;
169 }
170 else if (x.isFalsified()) {
171 res = falsified(x.args().some(), s, d);
172 break;
173 } else if (x.isException()) {
174 res = propException(x.args().some(), x.exception().some(), s, d);
175 break;
176 }
177 } catch (final Throwable t) {
178 res = genException(t, s, d);
179 break;
180 }
181 }
182
183 return res;
184 }
185
186 /**
187 * Checks this property using a {@link Rand#Rand(F, F) standard random generator} and the given
188 * arguments to produce a result.
189 *
190 * @param minSuccessful The minimum number of successful tests before a result is reached.
191 * @param maxDiscarded The maximum number of tests discarded because they did not satisfy
192 * pre-conditions (i.e. {@link #implies(boolean, P1)}).
193 * @param minSize The minimum size to use for checking.
194 * @param maxSize The maximum size to use for checking.
195 * @return A result after checking this property.
196 */
197 public CheckResult check(final int minSuccessful,
198 final int maxDiscarded,
199 final int minSize,
200 final int maxSize) {
201 return check(Rand.standard, minSuccessful, maxDiscarded, minSize, maxSize);
202 }
203
204 /**
205 * Checks this property using the given random generator, 100 minimum successful checks, 500
206 * maximum discarded tests, minimum size of 0, maximum size of 100.
207 *
208 * @param r The random generator.
209 * @return A result after checking this property.
210 */
211 public CheckResult check(final Rand r) {
212 return check(r, 100, 500, 0, 100);
213 }
214
215 /**
216 * Checks this property using the given random generator, 100 minimum successful checks, 500
217 * maximum discarded tests, the given minimum size and the given maximum size.
218 *
219 * @param r The random generator.
220 * @param minSize The minimum size to use for checking.
221 * @param maxSize The maximum size to use for checking.
222 * @return A result after checking this property.
223 */
224 public CheckResult check(final Rand r, final int minSize, final int maxSize) {
225 return check(r, 100, 500, minSize, maxSize);
226 }
227
228 /**
229 * Checks this property using a {@link Rand#Rand(F, F) standard random generator}, 100 minimum
230 * successful checks, 500 maximum discarded tests and the given arguments to produce a result.
231 *
232 * @param minSize The minimum size to use for checking.
233 * @param maxSize The maximum size to use for checking.
234 * @return A result after checking this property.
235 */
236 public CheckResult check(final int minSize,
237 final int maxSize) {
238 return check(100, 500, minSize, maxSize);
239 }
240
241 /**
242 * Checks this property using a {@link Rand#Rand(F, F) standard random generator}, 100 minimum
243 * successful checks, 500 maximum discarded tests, minimum size of 0, maximum size of 100.
244 *
245 * @return A result after checking this property.
246 */
247 public CheckResult check() {
248 return check(0, 100);
249 }
250
251 /**
252 * Checks this property using a {@link Rand#Rand(F, F) standard random generator}, the given minimum
253 * successful checks, 500 maximum discarded tests, minimum size of 0, maximum size of 100.
254 *
255 * @param minSuccessful The minimum number of successful tests before a result is reached.
256 * @return A result after checking this property.
257 */
258 public CheckResult minSuccessful(final int minSuccessful) {
259 return check(minSuccessful, 500, 0, 100);
260 }
261
262 /**
263 * Checks this property using the given random generator, the given minimum
264 * successful checks, 500 maximum discarded tests, minimum size of 0, maximum size of 100.
265 *
266 * @param r The random generator.
267 * @param minSuccessful The minimum number of successful tests before a result is reached.
268 * @return A result after checking this property.
269 */
270 public CheckResult minSuccessful(final Rand r, final int minSuccessful) {
271 return check(r, minSuccessful, 500, 0, 100);
272 }
273
274 /**
275 * Checks this property using a {@link Rand#Rand(F, F) standard random generator}, 100 minimum
276 * successful checks, the given maximum discarded tests, minimum size of 0, maximum size of 100.
277 *
278 * @param maxDiscarded The maximum number of tests discarded because they did not satisfy
279 * pre-conditions (i.e. {@link #implies(boolean, P1)}).
280 * @return A result after checking this property.
281 */
282 public CheckResult maxDiscarded(final int maxDiscarded) {
283 return check(100, maxDiscarded, 0, 100);
284 }
285
286 /**
287 * Checks this property using a the given random generator}, 100 minimum
288 * successful checks, the given maximum discarded tests, minimum size of 0, maximum size of 100.
289 *
290 * @param r The random generator.
291 * @param maxDiscarded The maximum number of tests discarded because they did not satisfy
292 * pre-conditions (i.e. {@link #implies(boolean, P1)}).
293 * @return A result after checking this property.
294 */
295 public CheckResult maxDiscarded(final Rand r, final int maxDiscarded) {
296 return check(r, 100, maxDiscarded, 0, 100);
297 }
298
299 /**
300 * Checks this property using a {@link Rand#Rand(F, F) standard random generator}, 100 minimum
301 * successful checks, 500 maximum discarded tests, the given minimum size, maximum size of 100.
302 *
303 * @param minSize The minimum size to use for checking.
304 * @return A result after checking this property.
305 */
306 public CheckResult minSize(final int minSize) {
307 return check(100, 500, minSize, 100);
308 }
309
310 /**
311 * Checks this property using the given random generator, 100 minimum
312 * successful checks, 500 maximum discarded tests, the given minimum size, maximum size of 100.
313 *
314 * @param r The random generator.
315 * @param minSize The minimum size to use for checking.
316 * @return A result after checking this property.
317 */
318 public CheckResult minSize(final Rand r, final int minSize) {
319 return check(r, 100, 500, minSize, 100);
320 }
321
322 /**
323 * Checks this property using a {@link Rand#Rand(F, F) standard random generator}, 100 minimum
324 * successful checks, 500 maximum discarded tests, minimum size of 0, the given maximum size.
325 *
326 * @param maxSize The maximum size to use for checking.
327 * @return A result after checking this property.
328 */
329 public CheckResult maxSize(final int maxSize) {
330 return check(100, 500, 0, maxSize);
331 }
332
333 /**
334 * Checks this property using the given random generator, 100 minimum
335 * successful checks, 500 maximum discarded tests, minimum size of 0, the given maximum size.
336 *
337 * @param r The random generator.
338 * @param maxSize The maximum size to use for checking.
339 * @return A result after checking this property.
340 */
341 public CheckResult maxSize(final Rand r, final int maxSize) {
342 return check(r, 100, 500, 0, maxSize);
343 }
344
345 /**
346 * Returns a property that produces a result only if the given condition satisfies. The result
347 * will be taken from the given property.
348 *
349 * @param b The condition that, if satisfied, produces the given property.
350 * @param p The property to return if the condition satisfies.
351 * @return A property that produces a result only if the given condition satisfies.
352 */
353 public static Property implies(final boolean b, final P1<Property> p) {
354 return b ? p._1() : new Property(new F<Integer, F<Rand, Result>>() {
355 public F<Rand, Result> f(final Integer i) {
356 return new F<Rand, Result>() {
357 public Result f(final Rand r) {
358 return noResult();
359 }
360 };
361 }
362 });
363 }
364
365 /**
366 * Returns a property from the given function.
367 *
368 * @param f The function to construct the returned property with.
369 * @return A property from the given function.
370 */
371 public static Property prop(final F<Integer, F<Rand, Result>> f) {
372 return new Property(f);
373 }
374
375 /**
376 * Returns a property that always has the given result.
377 *
378 * @param r The result of the returned property.
379 * @return A property that always has the given result.
380 */
381 public static Property prop(final Result r) {
382 return new Property(new F<Integer, F<Rand, Result>>() {
383 public F<Rand, Result> f(final Integer integer) {
384 return new F<Rand, Result>() {
385 public Result f(final Rand x) {
386 return r;
387 }
388 };
389 }
390 });
391 }
392
393 /**
394 * Returns a property that is either proven (the given condition satsifies) or falsified
395 * otherwise.
396 *
397 * @param b The condition that, if satisfied, returns a property that is proven; otherwise, the
398 * property is falsified.
399 * @return A property that is either proven (the given condition satsifies) or falsified
400 * otherwise.
401 */
402 public static Property prop(final boolean b) {
403 return b ? prop(Result.proven(List.<Arg<?>>nil())) : prop(Result.falsified(List.<Arg<?>>nil()));
404 }
405
406 /**
407 * Constructs a property from a generator of results.
408 *
409 * @param g The generator of results to constructor a property with.
410 * @return A property from a generator of results.
411 */
412 public static Property fromGen(final Gen<Result> g) {
413 return prop(new F<Integer, F<Rand, Result>>() {
414 public F<Rand, Result> f(final Integer i) {
415 return new F<Rand, Result>() {
416 public Result f(final Rand r) {
417 return g.gen(i, r);
418 }
419 };
420 }
421 });
422 }
423
424 /**
425 * Returns a property where its result is derived from universal quantification across the
426 * application of its arguments.
427 *
428 * @param g The generator to produces values from to produce the property with.
429 * @param shrink The shrink strategy to use upon falsification.
430 * @param f The function to produce properties with results.
431 * @return A property where its result is derived from universal quantification across the
432 * application of its arguments.
433 */
434 public static <A> Property forall(final Gen<A> g, final Shrink<A> shrink, final F<A, P1<Property>> f) {
435 return prop(new F<Integer, F<Rand, Result>>() {
436 public F<Rand, Result> f(final Integer i) {
437 return new F<Rand, Result>() {
438 public Result f(final Rand r) {
439 final class Util {
440 @SuppressWarnings({"IfMayBeConditional"})
441 Option<P2<A, Result>> first(final Stream<A> as, final int shrinks) {
442 final Stream<Option<P2<A, Result>>> results = as.map(new F<A, Option<P2<A, Result>>>() {
443 public Option<P2<A, Result>> f(final A a) {
444 final Result result = exception(f.f(a)).prop(i, r);
445
446 return result.toOption().map(new F<Result, P2<A, Result>>() {
447 public P2<A, Result> f(final Result result) {
448 return p(a, result.provenAsUnfalsified().addArg(arg(a, shrinks)));
449 }
450 });
451 }
452 });
453
454 if (results.isEmpty())
455 return none();
456 else return results.find(new F<Option<P2<A, Result>>, Boolean>() {
457 public Boolean f(final Option<P2<A, Result>> o) {
458 return failed(o);
459 }
460 }).orSome(new P1<Option<P2<A, Result>>>() {
461 public Option<P2<A, Result>> _1() {
462 return results.head();
463 }
464 });
465 }
466
467 public boolean failed(final Option<P2<A, Result>> o) {
468 return o.isSome() && o.some()._2().failed();
469 }
470 }
471
472 final Util u = new Util();
473
474 Option<P2<A, Result>> x = u.first(Stream.single(g.gen(i, r)), 0);
475 final F<P2<A, Result>, Result> __2 = __2();
476 if (u.failed(x)) {
477 Option<Result> or;
478 int shrinks = 0;
479
480 do {
481 shrinks++;
482 or = x.map(__2);
483 x = u.first(shrink.shrink(x.some()._1()), shrinks);
484 }
485 while (u.failed(x));
486
487 return noResult(or);
488 } else
489 return noResult(x.map(__2));
490 }
491 };
492 }
493 });
494 }
495
496 /**
497 * Returns a property where its result is derived from universal quantification across the
498 * application of its arguments.
499 *
500 * @param aa The arbitrrary to produces values from to produce the property with.
501 * @param sa The shrink strategy to use upon falsification.
502 * @param f The function to produce properties with results.
503 * @return A property where its result is derived from universal quantification across the
504 * application of its arguments.
505 */
506 public static <A> Property propertyP(final Arbitrary<A> aa, final Shrink<A> sa, final F<A, P1<Property>> f) {
507 return forall(aa.gen, sa, f);
508 }
509
510 /**
511 * Returns a property where its result is derived from universal quantification across the
512 * application of its arguments.
513 *
514 * @param aa The arbitrrary to produces values from to produce the property with.
515 * @param sa The shrink strategy to use upon falsification.
516 * @param f The function to produce properties with results.
517 * @return A property where its result is derived from universal quantification across the
518 * application of its arguments.
519 */
520 public static <A> Property property(final Arbitrary<A> aa, final Shrink<A> sa, final F<A, Property> f) {
521 return propertyP(aa, sa, P1.curry(f));
522 }
523
524 /**
525 * Returns a property where its result is derived from universal quantification across the
526 * application of its arguments. No shrinking occurs upon falsification.
527 *
528 * @param aa The arbitrrary to produces values from to produce the property with.
529 * @param f The function to produce properties with results.
530 * @return A property where its result is derived from universal quantification across the
531 * application of its arguments.
532 */
533 public static <A> Property propertyP(final Arbitrary<A> aa, final F<A, P1<Property>> f) {
534 return propertyP(aa, Shrink.<A>empty(), f);
535 }
536
537 /**
538 * Returns a property where its result is derived from universal quantification across the
539 * application of its arguments. No shrinking occurs upon falsification.
540 *
541 * @param aa The arbitrrary to produces values from to produce the property with.
542 * @param f The function to produce properties with results.
543 * @return A property where its result is derived from universal quantification across the
544 * application of its arguments.
545 */
546 public static <A> Property property(final Arbitrary<A> aa, final F<A, Property> f) {
547 return propertyP(aa, P1.curry(f));
548 }
549
550
551 /**
552 * Returns a property where its result is derived from universal quantification across the
553 * application of its arguments.
554 *
555 * @param aa The arbitrrary to produces values from to produce the property with.
556 * @param ab The arbitrrary to produces values from to produce the property with.
557 * @param sa The shrink strategy to use upon falsification.
558 * @param sb The shrink strategy to use upon falsification.
559 * @param f The function to produce properties with results.
560 * @return A property where its result is derived from universal quantification across the
561 * application of its arguments.
562 */
563 public static <A, B> Property propertyP(final Arbitrary<A> aa, final Arbitrary<B> ab, final Shrink<A> sa, final Shrink<B> sb, final F<A, F<B, P1<Property>>> f) {
564 return property(aa, sa, new F<A, Property>() {
565 public Property f(final A a) {
566 return propertyP(ab, sb, new F<B, P1<Property>>() {
567 public P1<Property> f(final B b) {
568 return f.f(a).f(b);
569 }
570 });
571 }
572 });
573 }
574
575 /**
576 * Returns a property where its result is derived from universal quantification across the
577 * application of its arguments.
578 *
579 * @param aa The arbitrrary to produces values from to produce the property with.
580 * @param ab The arbitrrary to produces values from to produce the property with.
581 * @param sa The shrink strategy to use upon falsification.
582 * @param sb The shrink strategy to use upon falsification.
583 * @param f The function to produce properties with results.
584 * @return A property where its result is derived from universal quantification across the
585 * application of its arguments.
586 */
587 public static <A, B> Property property(final Arbitrary<A> aa, final Arbitrary<B> ab, final Shrink<A> sa, final Shrink<B> sb, final F<A, F<B, Property>> f) {
588 return propertyP(aa, ab, sa, sb, compose2(P.<Property>p1(), f));
589 }
590
591 /**
592 * Returns a property where its result is derived from universal quantification across the
593 * application of its arguments. No shrinking occurs upon falsification.
594 *
595 * @param aa The arbitrrary to produces values from to produce the property with.
596 * @param ab The arbitrrary to produces values from to produce the property with.
597 * @param f The function to produce properties with results.
598 * @return A property where its result is derived from universal quantification across the
599 * application of its arguments.
600 */
601 public static <A, B> Property propertyP(final Arbitrary<A> aa, final Arbitrary<B> ab, final F<A, F<B, P1<Property>>> f) {
602 return property(aa, new F<A, Property>() {
603 public Property f(final A a) {
604 return propertyP(ab, new F<B, P1<Property>>() {
605 public P1<Property> f(final B b) {
606 return f.f(a).f(b);
607 }
608 });
609 }
610 });
611 }
612
613 /**
614 * Returns a property where its result is derived from universal quantification across the
615 * application of its arguments. No shrinking occurs upon falsification.
616 *
617 * @param aa The arbitrrary to produces values from to produce the property with.
618 * @param ab The arbitrrary to produces values from to produce the property with.
619 * @param f The function to produce properties with results.
620 * @return A property where its result is derived from universal quantification across the
621 * application of its arguments.
622 */
623 public static <A, B> Property property(final Arbitrary<A> aa, final Arbitrary<B> ab, final F<A, F<B, Property>> f) {
624 return propertyP(aa, ab, compose2(P.<Property>p1(), f));
625 }
626
627 /**
628 * Returns a property where its result is derived from universal quantification across the
629 * application of its arguments.
630 *
631 * @param aa The arbitrrary to produces values from to produce the property with.
632 * @param ab The arbitrrary to produces values from to produce the property with.
633 * @param sa The shrink strategy to use upon falsification.
634 * @param sb The shrink strategy to use upon falsification.
635 * @param f The function to produce properties with results.
636 * @return A property where its result is derived from universal quantification across the
637 * application of its arguments.
638 */
639 public static <A, B> Property propertyP(final Arbitrary<A> aa, final Arbitrary<B> ab, final Shrink<A> sa, final Shrink<B> sb, final F2<A, B, P1<Property>> f) {
640 return propertyP(aa, ab, sa, sb, curry(f));
641 }
642
643 /**
644 * Returns a property where its result is derived from universal quantification across the
645 * application of its arguments.
646 *
647 * @param aa The arbitrrary to produces values from to produce the property with.
648 * @param ab The arbitrrary to produces values from to produce the property with.
649 * @param sa The shrink strategy to use upon falsification.
650 * @param sb The shrink strategy to use upon falsification.
651 * @param f The function to produce properties with results.
652 * @return A property where its result is derived from universal quantification across the
653 * application of its arguments.
654 */
655 public static <A, B> Property property(final Arbitrary<A> aa, final Arbitrary<B> ab, final Shrink<A> sa, final Shrink<B> sb, final F2<A, B, Property> f) {
656 return propertyP(aa, ab, sa, sb, compose2(P.<Property>p1(), curry(f)));
657 }
658
659 /**
660 * Returns a property where its result is derived from universal quantification across the
661 * application of its arguments. No shrinking occurs upon falsification.
662 *
663 * @param aa The arbitrrary to produces values from to produce the property with.
664 * @param ab The arbitrrary to produces values from to produce the property with.
665 * @param f The function to produce properties with results.
666 * @return A property where its result is derived from universal quantification across the
667 * application of its arguments.
668 */
669 public static <A, B> Property propertyP(final Arbitrary<A> aa, final Arbitrary<B> ab, final F2<A, B, P1<Property>> f) {
670 return propertyP(aa, ab, curry(f));
671 }
672
673 /**
674 * Returns a property where its result is derived from universal quantification across the
675 * application of its arguments. No shrinking occurs upon falsification.
676 *
677 * @param aa The arbitrrary to produces values from to produce the property with.
678 * @param ab The arbitrrary to produces values from to produce the property with.
679 * @param f The function to produce properties with results.
680 * @return A property where its result is derived from universal quantification across the
681 * application of its arguments.
682 */
683 public static <A, B> Property property(final Arbitrary<A> aa, final Arbitrary<B> ab, final F2<A, B, Property> f) {
684 return propertyP(aa, ab, compose2(P.<Property>p1(), curry(f)));
685 }
686
687 /**
688 * Returns a property where its result is derived from universal quantification across the
689 * application of its arguments.
690 *
691 * @param aa The arbitrrary to produces values from to produce the property with.
692 * @param ab The arbitrrary to produces values from to produce the property with.
693 * @param ac The arbitrrary to produces values from to produce the property with.
694 * @param sa The shrink strategy to use upon falsification.
695 * @param sb The shrink strategy to use upon falsification.
696 * @param sc The shrink strategy to use upon falsification.
697 * @param f The function to produce properties with results.
698 * @return A property where its result is derived from universal quantification across the
699 * application of its arguments.
700 */
701 public static <A, B, C> Property property(final Arbitrary<A> aa,
702 final Arbitrary<B> ab,
703 final Arbitrary<C> ac,
704 final Shrink<A> sa,
705 final Shrink<B> sb,
706 final Shrink<C> sc,
707 final F<A, F<B, F<C, Property>>> f) {
708 return property(aa, ab, sa, sb, new F<A, F<B, Property>>() {
709 public F<B, Property> f(final A a) {
710 return new F<B, Property>() {
711 public Property f(final B b) {
712 return property(ac, sc, new F<C, Property>() {
713 public Property f(final C c) {
714 return f.f(a).f(b).f(c);
715 }
716 });
717 }
718 };
719 }
720 });
721 }
722
723 /**
724 * Returns a property where its result is derived from universal quantification across the
725 * application of its arguments. No shrinking occurs upon falsification.
726 *
727 * @param aa The arbitrrary to produces values from to produce the property with.
728 * @param ab The arbitrrary to produces values from to produce the property with.
729 * @param ac The arbitrrary to produces values from to produce the property with.
730 * @param f The function to produce properties with results.
731 * @return A property where its result is derived from universal quantification across the
732 * application of its arguments.
733 */
734 public static <A, B, C> Property property(final Arbitrary<A> aa,
735 final Arbitrary<B> ab,
736 final Arbitrary<C> ac,
737 final F<A, F<B, F<C, Property>>> f) {
738 return property(aa, ab, new F<A, F<B, Property>>() {
739 public F<B, Property> f(final A a) {
740 return new F<B, Property>() {
741 public Property f(final B b) {
742 return property(ac, new F<C, Property>() {
743 public Property f(final C c) {
744 return f.f(a).f(b).f(c);
745 }
746 });
747 }
748 };
749 }
750 });
751 }
752
753 /**
754 * Returns a property where its result is derived from universal quantification across the
755 * application of its arguments.
756 *
757 * @param aa The arbitrrary to produces values from to produce the property with.
758 * @param ab The arbitrrary to produces values from to produce the property with.
759 * @param ac The arbitrrary to produces values from to produce the property with.
760 * @param sa The shrink strategy to use upon falsification.
761 * @param sb The shrink strategy to use upon falsification.
762 * @param sc The shrink strategy to use upon falsification.
763 * @param f The function to produce properties with results.
764 * @return A property where its result is derived from universal quantification across the
765 * application of its arguments.
766 */
767 public static <A, B, C> Property property(final Arbitrary<A> aa,
768 final Arbitrary<B> ab,
769 final Arbitrary<C> ac,
770 final Shrink<A> sa,
771 final Shrink<B> sb,
772 final Shrink<C> sc,
773 final F3<A, B, C, Property> f) {
774 return property(aa, ab, ac, sa, sb, sc, curry(f));
775 }
776
777 /**
778 * Returns a property where its result is derived from universal quantification across the
779 * application of its arguments. No shrinking occurs upon falsification.
780 *
781 * @param aa The arbitrrary to produces values from to produce the property with.
782 * @param ab The arbitrrary to produces values from to produce the property with.
783 * @param ac The arbitrrary to produces values from to produce the property with.
784 * @param f The function to produce properties with results.
785 * @return A property where its result is derived from universal quantification across the
786 * application of its arguments.
787 */
788 public static <A, B, C> Property property(final Arbitrary<A> aa,
789 final Arbitrary<B> ab,
790 final Arbitrary<C> ac,
791 final F3<A, B, C, Property> f) {
792 return property(aa, ab, ac, curry(f));
793 }
794
795 /**
796 * Returns a property where its result is derived from universal quantification across the
797 * application of its arguments.
798 *
799 * @param aa The arbitrrary to produces values from to produce the property with.
800 * @param ab The arbitrrary to produces values from to produce the property with.
801 * @param ac The arbitrrary to produces values from to produce the property with.
802 * @param ad The arbitrrary to produces values from to produce the property with.
803 * @param sa The shrink strategy to use upon falsification.
804 * @param sb The shrink strategy to use upon falsification.
805 * @param sc The shrink strategy to use upon falsification.
806 * @param sd The shrink strategy to use upon falsification.
807 * @param f The function to produce properties with results.
808 * @return A property where its result is derived from universal quantification across the
809 * application of its arguments.
810 */
811 public static <A, B, C, D> Property property(final Arbitrary<A> aa,
812 final Arbitrary<B> ab,
813 final Arbitrary<C> ac,
814 final Arbitrary<D> ad,
815 final Shrink<A> sa,
816 final Shrink<B> sb,
817 final Shrink<C> sc,
818 final Shrink<D> sd,
819 final F<A, F<B, F<C, F<D, Property>>>> f) {
820 return property(aa, ab, ac, sa, sb, sc, new F<A, F<B, F<C, Property>>>() {
821 public F<B, F<C, Property>> f(final A a) {
822 return new F<B, F<C, Property>>() {
823 public F<C, Property> f(final B b) {
824 return new F<C, Property>() {
825 public Property f(final C c) {
826 return property(ad, sd, new F<D, Property>() {
827 public Property f(final D d) {
828 return f.f(a).f(b).f(c).f(d);
829 }
830 });
831 }
832 };
833 }
834 };
835 }
836 });
837 }
838
839 /**
840 * Returns a property where its result is derived from universal quantification across the
841 * application of its arguments. No shrinking occurs upon falsification.
842 *
843 * @param aa The arbitrrary to produces values from to produce the property with.
844 * @param ab The arbitrrary to produces values from to produce the property with.
845 * @param ac The arbitrrary to produces values from to produce the property with.
846 * @param ad The arbitrrary to produces values from to produce the property with.
847 * @param f The function to produce properties with results.
848 * @return A property where its result is derived from universal quantification across the
849 * application of its arguments.
850 */
851 public static <A, B, C, D> Property property(final Arbitrary<A> aa,
852 final Arbitrary<B> ab,
853 final Arbitrary<C> ac,
854 final Arbitrary<D> ad,
855 final F<A, F<B, F<C, F<D, Property>>>> f) {
856 return property(aa, ab, ac, new F<A, F<B, F<C, Property>>>() {
857 public F<B, F<C, Property>> f(final A a) {
858 return new F<B, F<C, Property>>() {
859 public F<C, Property> f(final B b) {
860 return new F<C, Property>() {
861 public Property f(final C c) {
862 return property(ad, new F<D, Property>() {
863 public Property f(final D d) {
864 return f.f(a).f(b).f(c).f(d);
865 }
866 });
867 }
868 };
869 }
870 };
871 }
872 });
873 }
874
875 /**
876 * Returns a property where its result is derived from universal quantification across the
877 * application of its arguments.
878 *
879 * @param aa The arbitrrary to produces values from to produce the property with.
880 * @param ab The arbitrrary to produces values from to produce the property with.
881 * @param ac The arbitrrary to produces values from to produce the property with.
882 * @param ad The arbitrrary to produces values from to produce the property with.
883 * @param sa The shrink strategy to use upon falsification.
884 * @param sb The shrink strategy to use upon falsification.
885 * @param sc The shrink strategy to use upon falsification.
886 * @param sd The shrink strategy to use upon falsification.
887 * @param f The function to produce properties with results.
888 * @return A property where its result is derived from universal quantification across the
889 * application of its arguments.
890 */
891 public static <A, B, C, D> Property property(final Arbitrary<A> aa,
892 final Arbitrary<B> ab,
893 final Arbitrary<C> ac,
894 final Arbitrary<D> ad,
895 final Shrink<A> sa,
896 final Shrink<B> sb,
897 final Shrink<C> sc,
898 final Shrink<D> sd,
899 final F4<A, B, C, D, Property> f) {
900 return property(aa, ab, ac, ad, sa, sb, sc, sd, curry(f));
901 }
902
903 /**
904 * Returns a property where its result is derived from universal quantification across the
905 * application of its arguments. No shrinking occurs upon falsification.
906 *
907 * @param aa The arbitrrary to produces values from to produce the property with.
908 * @param ab The arbitrrary to produces values from to produce the property with.
909 * @param ac The arbitrrary to produces values from to produce the property with.
910 * @param ad The arbitrrary to produces values from to produce the property with.
911 * @param f The function to produce properties with results.
912 * @return A property where its result is derived from universal quantification across the
913 * application of its arguments.
914 */
915 public static <A, B, C, D> Property property(final Arbitrary<A> aa,
916 final Arbitrary<B> ab,
917 final Arbitrary<C> ac,
918 final Arbitrary<D> ad,
919 final F4<A, B, C, D, Property> f) {
920 return property(aa, ab, ac, ad, curry(f));
921 }
922
923 /**
924 * Returns a property where its result is derived from universal quantification across the
925 * application of its arguments.
926 *
927 * @param aa The arbitrrary to produces values from to produce the property with.
928 * @param ab The arbitrrary to produces values from to produce the property with.
929 * @param ac The arbitrrary to produces values from to produce the property with.
930 * @param ad The arbitrrary to produces values from to produce the property with.
931 * @param ae The arbitrrary to produces values from to produce the property with.
932 * @param sa The shrink strategy to use upon falsification.
933 * @param sb The shrink strategy to use upon falsification.
934 * @param sc The shrink strategy to use upon falsification.
935 * @param sd The shrink strategy to use upon falsification.
936 * @param se The shrink strategy to use upon falsification.
937 * @param f The function to produce properties with results.
938 * @return A property where its result is derived from universal quantification across the
939 * application of its arguments.
940 */
941 public static <A, B, C, D, E> Property property(final Arbitrary<A> aa,
942 final Arbitrary<B> ab,
943 final Arbitrary<C> ac,
944 final Arbitrary<D> ad,
945 final Arbitrary<E> ae,
946 final Shrink<A> sa,
947 final Shrink<B> sb,
948 final Shrink<C> sc,
949 final Shrink<D> sd,
950 final Shrink<E> se,
951 final F<A, F<B, F<C, F<D, F<E, Property>>>>> f) {
952 return property(aa, ab, ac, ad, sa, sb, sc, sd, new F<A, F<B, F<C, F<D, Property>>>>() {
953 public F<B, F<C, F<D, Property>>> f(final A a) {
954 return new F<B, F<C, F<D, Property>>>() {
955 public F<C, F<D, Property>> f(final B b) {
956 return new F<C, F<D, Property>>() {
957 public F<D, Property> f(final C c) {
958 return new F<D, Property>() {
959 public Property f(final D d) {
960 return property(ae, se, new F<E, Property>() {
961 public Property f(final E e) {
962 return f.f(a).f(b).f(c).f(d).f(e);
963 }
964 });
965 }
966 };
967 }
968 };
969 }
970 };
971 }
972 });
973 }
974
975 /**
976 * Returns a property where its result is derived from universal quantification across the
977 * application of its arguments. No shrinking occurs upon falsification.
978 *
979 * @param aa The arbitrrary to produces values from to produce the property with.
980 * @param ab The arbitrrary to produces values from to produce the property with.
981 * @param ac The arbitrrary to produces values from to produce the property with.
982 * @param ad The arbitrrary to produces values from to produce the property with.
983 * @param ae The arbitrrary to produces values from to produce the property with.
984 * @param f The function to produce properties with results.
985 * @return A property where its result is derived from universal quantification across the
986 * application of its arguments.
987 */
988 public static <A, B, C, D, E> Property property(final Arbitrary<A> aa,
989 final Arbitrary<B> ab,
990 final Arbitrary<C> ac,
991 final Arbitrary<D> ad,
992 final Arbitrary<E> ae,
993 final F<A, F<B, F<C, F<D, F<E, Property>>>>> f) {
994 return property(aa, ab, ac, ad, new F<A, F<B, F<C, F<D, Property>>>>() {
995 public F<B, F<C, F<D, Property>>> f(final A a) {
996 return new F<B, F<C, F<D, Property>>>() {
997 public F<C, F<D, Property>> f(final B b) {
998 return new F<C, F<D, Property>>() {
999 public F<D, Property> f(final C c) {
1000 return new F<D, Property>() {
1001 public Property f(final D d) {
1002 return property(ae, new F<E, Property>() {
1003 public Property f(final E e) {
1004 return f.f(a).f(b).f(c).f(d).f(e);
1005 }
1006 });
1007 }
1008 };
1009 }
1010 };
1011 }
1012 };
1013 }
1014 });
1015 }
1016
1017 /**
1018 * Returns a property where its result is derived from universal quantification across the
1019 * application of its arguments.
1020 *
1021 * @param aa The arbitrrary to produces values from to produce the property with.
1022 * @param ab The arbitrrary to produces values from to produce the property with.
1023 * @param ac The arbitrrary to produces values from to produce the property with.
1024 * @param ad The arbitrrary to produces values from to produce the property with.
1025 * @param ae The arbitrrary to produces values from to produce the property with.
1026 * @param sa The shrink strategy to use upon falsification.
1027 * @param sb The shrink strategy to use upon falsification.
1028 * @param sc The shrink strategy to use upon falsification.
1029 * @param sd The shrink strategy to use upon falsification.
1030 * @param se The shrink strategy to use upon falsification.
1031 * @param f The function to produce properties with results.
1032 * @return A property where its result is derived from universal quantification across the
1033 * application of its arguments.
1034 */
1035 public static <A, B, C, D, E> Property property(final Arbitrary<A> aa,
1036 final Arbitrary<B> ab,
1037 final Arbitrary<C> ac,
1038 final Arbitrary<D> ad,
1039 final Arbitrary<E> ae,
1040 final Shrink<A> sa,
1041 final Shrink<B> sb,
1042 final Shrink<C> sc,
1043 final Shrink<D> sd,
1044 final Shrink<E> se,
1045 final F5<A, B, C, D, E, Property> f) {
1046 return property(aa, ab, ac, ad, ae, sa, sb, sc, sd, se, curry(f));
1047 }
1048
1049 /**
1050 * Returns a property where its result is derived from universal quantification across the
1051 * application of its arguments. No shrinking occurs upon falsification.
1052 *
1053 * @param aa The arbitrrary to produces values from to produce the property with.
1054 * @param ab The arbitrrary to produces values from to produce the property with.
1055 * @param ac The arbitrrary to produces values from to produce the property with.
1056 * @param ad The arbitrrary to produces values from to produce the property with.
1057 * @param ae The arbitrrary to produces values from to produce the property with.
1058 * @param f The function to produce properties with results.
1059 * @return A property where its result is derived from universal quantification across the
1060 * application of its arguments.
1061 */
1062 public static <A, B, C, D, E> Property property(final Arbitrary<A> aa,
1063 final Arbitrary<B> ab,
1064 final Arbitrary<C> ac,
1065 final Arbitrary<D> ad,
1066 final Arbitrary<E> ae,
1067 final F5<A, B, C, D, E, Property> f) {
1068 return property(aa, ab, ac, ad, ae, curry(f));
1069 }
1070
1071 /**
1072 * Returns a property where its result is derived from universal quantification across the
1073 * application of its arguments.
1074 *
1075 * @param aa The arbitrrary to produces values from to produce the property with.
1076 * @param ab The arbitrrary to produces values from to produce the property with.
1077 * @param ac The arbitrrary to produces values from to produce the property with.
1078 * @param ad The arbitrrary to produces values from to produce the property with.
1079 * @param ae The arbitrrary to produces values from to produce the property with.
1080 * @param af The arbitrrary to produces values from to produce the property with.
1081 * @param sa The shrink strategy to use upon falsification.
1082 * @param sb The shrink strategy to use upon falsification.
1083 * @param sc The shrink strategy to use upon falsification.
1084 * @param sd The shrink strategy to use upon falsification.
1085 * @param se The shrink strategy to use upon falsification.
1086 * @param sf The shrink strategy to use upon falsification.
1087 * @param f The function to produce properties with results.
1088 * @return A property where its result is derived from universal quantification across the
1089 * application of its arguments.
1090 */
1091 public static <A, B, C, D, E, F$> Property property(final Arbitrary<A> aa,
1092 final Arbitrary<B> ab,
1093 final Arbitrary<C> ac,
1094 final Arbitrary<D> ad,
1095 final Arbitrary<E> ae,
1096 final Arbitrary<F$> af,
1097 final Shrink<A> sa,
1098 final Shrink<B> sb,
1099 final Shrink<C> sc,
1100 final Shrink<D> sd,
1101 final Shrink<E> se,
1102 final Shrink<F$> sf,
1103 final F<A, F<B, F<C, F<D, F<E, F<F$, Property>>>>>> f) {
1104 return property(aa, ab, ac, ad, ae, sa, sb, sc, sd, se, new F<A, F<B, F<C, F<D, F<E, Property>>>>>() {
1105 public F<B, F<C, F<D, F<E, Property>>>> f(final A a) {
1106 return new F<B, F<C, F<D, F<E, Property>>>>() {
1107 public F<C, F<D, F<E, Property>>> f(final B b) {
1108 return new F<C, F<D, F<E, Property>>>() {
1109 public F<D, F<E, Property>> f(final C c) {
1110 return new F<D, F<E, Property>>() {
1111 public F<E, Property> f(final D d) {
1112 return new F<E, Property>() {
1113 public Property f(final E e) {
1114 return property(af, sf, new F<F$, Property>() {
1115 public Property f(final F$ f$) {
1116 return f.f(a).f(b).f(c).f(d).f(e).f(f$);
1117 }
1118 });
1119 }
1120 };
1121 }
1122 };
1123 }
1124 };
1125 }
1126 };
1127 }
1128 });
1129 }
1130
1131 /**
1132 * Returns a property where its result is derived from universal quantification across the
1133 * application of its arguments. No shrinking occurs upon falsification.
1134 *
1135 * @param aa The arbitrrary to produces values from to produce the property with.
1136 * @param ab The arbitrrary to produces values from to produce the property with.
1137 * @param ac The arbitrrary to produces values from to produce the property with.
1138 * @param ad The arbitrrary to produces values from to produce the property with.
1139 * @param ae The arbitrrary to produces values from to produce the property with.
1140 * @param af The arbitrrary to produces values from to produce the property with.
1141 * @param f The function to produce properties with results.
1142 * @return A property where its result is derived from universal quantification across the
1143 * application of its arguments.
1144 */
1145 public static <A, B, C, D, E, F$> Property property(final Arbitrary<A> aa,
1146 final Arbitrary<B> ab,
1147 final Arbitrary<C> ac,
1148 final Arbitrary<D> ad,
1149 final Arbitrary<E> ae,
1150 final Arbitrary<F$> af,
1151 final F<A, F<B, F<C, F<D, F<E, F<F$, Property>>>>>> f) {
1152 return property(aa, ab, ac, ad, ae, new F<A, F<B, F<C, F<D, F<E, Property>>>>>() {
1153 public F<B, F<C, F<D, F<E, Property>>>> f(final A a) {
1154 return new F<B, F<C, F<D, F<E, Property>>>>() {
1155 public F<C, F<D, F<E, Property>>> f(final B b) {
1156 return new F<C, F<D, F<E, Property>>>() {
1157 public F<D, F<E, Property>> f(final C c) {
1158 return new F<D, F<E, Property>>() {
1159 public F<E, Property> f(final D d) {
1160 return new F<E, Property>() {
1161 public Property f(final E e) {
1162 return property(af, new F<F$, Property>() {
1163 public Property f(final F$ f$) {
1164 return f.f(a).f(b).f(c).f(d).f(e).f(f$);
1165 }
1166 });
1167 }
1168 };
1169 }
1170 };
1171 }
1172 };
1173 }
1174 };
1175 }
1176 });
1177 }
1178
1179 /**
1180 * Returns a property where its result is derived from universal quantification across the
1181 * application of its arguments.
1182 *
1183 * @param aa The arbitrrary to produces values from to produce the property with.
1184 * @param ab The arbitrrary to produces values from to produce the property with.
1185 * @param ac The arbitrrary to produces values from to produce the property with.
1186 * @param ad The arbitrrary to produces values from to produce the property with.
1187 * @param ae The arbitrrary to produces values from to produce the property with.
1188 * @param af The arbitrrary to produces values from to produce the property with.
1189 * @param sa The shrink strategy to use upon falsification.
1190 * @param sb The shrink strategy to use upon falsification.
1191 * @param sc The shrink strategy to use upon falsification.
1192 * @param sd The shrink strategy to use upon falsification.
1193 * @param se The shrink strategy to use upon falsification.
1194 * @param sf The shrink strategy to use upon falsification.
1195 * @param f The function to produce properties with results.
1196 * @return A property where its result is derived from universal quantification across the
1197 * application of its arguments.
1198 */
1199 public static <A, B, C, D, E, F$> Property property(final Arbitrary<A> aa,
1200 final Arbitrary<B> ab,
1201 final Arbitrary<C> ac,
1202 final Arbitrary<D> ad,
1203 final Arbitrary<E> ae,
1204 final Arbitrary<F$> af,
1205 final Shrink<A> sa,
1206 final Shrink<B> sb,
1207 final Shrink<C> sc,
1208 final Shrink<D> sd,
1209 final Shrink<E> se,
1210 final Shrink<F$> sf,
1211 final F6<A, B, C, D, E, F$, Property> f) {
1212 return property(aa, ab, ac, ad, ae, af, sa, sb, sc, sd, se, sf, curry(f));
1213 }
1214
1215 /**
1216 * Returns a property where its result is derived from universal quantification across the
1217 * application of its arguments. No shrinking occurs upon falsification.
1218 *
1219 * @param aa The arbitrrary to produces values from to produce the property with.
1220 * @param ab The arbitrrary to produces values from to produce the property with.
1221 * @param ac The arbitrrary to produces values from to produce the property with.
1222 * @param ad The arbitrrary to produces values from to produce the property with.
1223 * @param ae The arbitrrary to produces values from to produce the property with.
1224 * @param af The arbitrrary to produces values from to produce the property with.
1225 * @param f The function to produce properties with results.
1226 * @return A property where its result is derived from universal quantification across the
1227 * application of its arguments.
1228 */
1229 public static <A, B, C, D, E, F$> Property property(final Arbitrary<A> aa,
1230 final Arbitrary<B> ab,
1231 final Arbitrary<C> ac,
1232 final Arbitrary<D> ad,
1233 final Arbitrary<E> ae,
1234 final Arbitrary<F$> af,
1235 final F6<A, B, C, D, E, F$, Property> f) {
1236 return property(aa, ab, ac, ad, ae, af, curry(f));
1237 }
1238
1239 /**
1240 * Returns a property where its result is derived from universal quantification across the
1241 * application of its arguments.
1242 *
1243 * @param aa The arbitrrary to produces values from to produce the property with.
1244 * @param ab The arbitrrary to produces values from to produce the property with.
1245 * @param ac The arbitrrary to produces values from to produce the property with.
1246 * @param ad The arbitrrary to produces values from to produce the property with.
1247 * @param ae The arbitrrary to produces values from to produce the property with.
1248 * @param af The arbitrrary to produces values from to produce the property with.
1249 * @param ag The arbitrrary to produces values from to produce the property with.
1250 * @param sa The shrink strategy to use upon falsification.
1251 * @param sb The shrink strategy to use upon falsification.
1252 * @param sc The shrink strategy to use upon falsification.
1253 * @param sd The shrink strategy to use upon falsification.
1254 * @param se The shrink strategy to use upon falsification.
1255 * @param sf The shrink strategy to use upon falsification.
1256 * @param sg The shrink strategy to use upon falsification.
1257 * @param f The function to produce properties with results.
1258 * @return A property where its result is derived from universal quantification across the
1259 * application of its arguments.
1260 */
1261 public static <A, B, C, D, E, F$, G> Property property(final Arbitrary<A> aa,
1262 final Arbitrary<B> ab,
1263 final Arbitrary<C> ac,
1264 final Arbitrary<D> ad,
1265 final Arbitrary<E> ae,
1266 final Arbitrary<F$> af,
1267 final Arbitrary<G> ag,
1268 final Shrink<A> sa,
1269 final Shrink<B> sb,
1270 final Shrink<C> sc,
1271 final Shrink<D> sd,
1272 final Shrink<E> se,
1273 final Shrink<F$> sf,
1274 final Shrink<G> sg,
1275 final F<A, F<B, F<C, F<D, F<E, F<F$, F<G, Property>>>>>>> f) {
1276 return property(aa, ab, ac, ad, ae, af, sa, sb, sc, sd, se, sf, new F<A, F<B, F<C, F<D, F<E, F<F$, Property>>>>>>() {
1277 public F<B, F<C, F<D, F<E, F<F$, Property>>>>> f(final A a) {
1278 return new F<B, F<C, F<D, F<E, F<F$, Property>>>>>() {
1279 public F<C, F<D, F<E, F<F$, Property>>>> f(final B b) {
1280 return new F<C, F<D, F<E, F<F$, Property>>>>() {
1281 public F<D, F<E, F<F$, Property>>> f(final C c) {
1282 return new F<D, F<E, F<F$, Property>>>() {
1283 public F<E, F<F$, Property>> f(final D d) {
1284 return new F<E, F<F$, Property>>() {
1285 public F<F$, Property> f(final E e) {
1286 return new F<F$, Property>() {
1287 public Property f(final F$ f$) {
1288 return property(ag, sg, new F<G, Property>() {
1289 public Property f(final G g) {
1290 return f.f(a).f(b).f(c).f(d).f(e).f(f$).f(g);
1291 }
1292 });
1293 }
1294 };
1295 }
1296 };
1297 }
1298 };
1299 }
1300 };
1301 }
1302 };
1303 }
1304 });
1305 }
1306
1307 /**
1308 * Returns a property where its result is derived from universal quantification across the
1309 * application of its arguments. No shrinking occurs upon falsification.
1310 *
1311 * @param aa The arbitrrary to produces values from to produce the property with.
1312 * @param ab The arbitrrary to produces values from to produce the property with.
1313 * @param ac The arbitrrary to produces values from to produce the property with.
1314 * @param ad The arbitrrary to produces values from to produce the property with.
1315 * @param ae The arbitrrary to produces values from to produce the property with.
1316 * @param af The arbitrrary to produces values from to produce the property with.
1317 * @param ag The arbitrrary to produces values from to produce the property with.
1318 * @param f The function to produce properties with results.
1319 * @return A property where its result is derived from universal quantification across the
1320 * application of its arguments.
1321 */
1322 public static <A, B, C, D, E, F$, G> Property property(final Arbitrary<A> aa,
1323 final Arbitrary<B> ab,
1324 final Arbitrary<C> ac,
1325 final Arbitrary<D> ad,
1326 final Arbitrary<E> ae,
1327 final Arbitrary<F$> af,
1328 final Arbitrary<G> ag,
1329 final F<A, F<B, F<C, F<D, F<E, F<F$, F<G, Property>>>>>>> f) {
1330 return property(aa, ab, ac, ad, ae, af, new F<A, F<B, F<C, F<D, F<E, F<F$, Property>>>>>>() {
1331 public F<B, F<C, F<D, F<E, F<F$, Property>>>>> f(final A a) {
1332 return new F<B, F<C, F<D, F<E, F<F$, Property>>>>>() {
1333 public F<C, F<D, F<E, F<F$, Property>>>> f(final B b) {
1334 return new F<C, F<D, F<E, F<F$, Property>>>>() {
1335 public F<D, F<E, F<F$, Property>>> f(final C c) {
1336 return new F<D, F<E, F<F$, Property>>>() {
1337 public F<E, F<F$, Property>> f(final D d) {
1338 return new F<E, F<F$, Property>>() {
1339 public F<F$, Property> f(final E e) {
1340 return new F<F$, Property>() {
1341 public Property f(final F$ f$) {
1342 return property(ag, new F<G, Property>() {
1343 public Property f(final G g) {
1344 return f.f(a).f(b).f(c).f(d).f(e).f(f$).f(g);
1345 }
1346 });
1347 }
1348 };
1349 }
1350 };
1351 }
1352 };
1353 }
1354 };
1355 }
1356 };
1357 }
1358 });
1359 }
1360
1361 /**
1362 * Returns a property where its result is derived from universal quantification across the
1363 * application of its arguments.
1364 *
1365 * @param aa The arbitrrary to produces values from to produce the property with.
1366 * @param ab The arbitrrary to produces values from to produce the property with.
1367 * @param ac The arbitrrary to produces values from to produce the property with.
1368 * @param ad The arbitrrary to produces values from to produce the property with.
1369 * @param ae The arbitrrary to produces values from to produce the property with.
1370 * @param af The arbitrrary to produces values from to produce the property with.
1371 * @param ag The arbitrrary to produces values from to produce the property with.
1372 * @param sa The shrink strategy to use upon falsification.
1373 * @param sb The shrink strategy to use upon falsification.
1374 * @param sc The shrink strategy to use upon falsification.
1375 * @param sd The shrink strategy to use upon falsification.
1376 * @param se The shrink strategy to use upon falsification.
1377 * @param sf The shrink strategy to use upon falsification.
1378 * @param sg The shrink strategy to use upon falsification.
1379 * @param f The function to produce properties with results.
1380 * @return A property where its result is derived from universal quantification across the
1381 * application of its arguments.
1382 */
1383 public static <A, B, C, D, E, F$, G> Property property(final Arbitrary<A> aa,
1384 final Arbitrary<B> ab,
1385 final Arbitrary<C> ac,
1386 final Arbitrary<D> ad,
1387 final Arbitrary<E> ae,
1388 final Arbitrary<F$> af,
1389 final Arbitrary<G> ag,
1390 final Shrink<A> sa,
1391 final Shrink<B> sb,
1392 final Shrink<C> sc,
1393 final Shrink<D> sd,
1394 final Shrink<E> se,
1395 final Shrink<F$> sf,
1396 final Shrink<G> sg,
1397 final F7<A, B, C, D, E, F$, G, Property> f) {
1398 return property(aa, ab, ac, ad, ae, af, ag, sa, sb, sc, sd, se, sf, sg, curry(f));
1399 }
1400
1401 /**
1402 * Returns a property where its result is derived from universal quantification across the
1403 * application of its arguments. No shrinking occurs upon falsification.
1404 *
1405 * @param aa The arbitrrary to produces values from to produce the property with.
1406 * @param ab The arbitrrary to produces values from to produce the property with.
1407 * @param ac The arbitrrary to produces values from to produce the property with.
1408 * @param ad The arbitrrary to produces values from to produce the property with.
1409 * @param ae The arbitrrary to produces values from to produce the property with.
1410 * @param af The arbitrrary to produces values from to produce the property with.
1411 * @param ag The arbitrrary to produces values from to produce the property with.
1412 * @param f The function to produce properties with results.
1413 * @return A property where its result is derived from universal quantification across the
1414 * application of its arguments.
1415 */
1416 public static <A, B, C, D, E, F$, G> Property property(final Arbitrary<A> aa,
1417 final Arbitrary<B> ab,
1418 final Arbitrary<C> ac,
1419 final Arbitrary<D> ad,
1420 final Arbitrary<E> ae,
1421 final Arbitrary<F$> af,
1422 final Arbitrary<G> ag,
1423 final F7<A, B, C, D, E, F$, G, Property> f) {
1424 return property(aa, ab, ac, ad, ae, af, ag, curry(f));
1425 }
1426
1427 /**
1428 * Returns a property where its result is derived from universal quantification across the
1429 * application of its arguments.
1430 *
1431 * @param aa The arbitrrary to produces values from to produce the property with.
1432 * @param ab The arbitrrary to produces values from to produce the property with.
1433 * @param ac The arbitrrary to produces values from to produce the property with.
1434 * @param ad The arbitrrary to produces values from to produce the property with.
1435 * @param ae The arbitrrary to produces values from to produce the property with.
1436 * @param af The arbitrrary to produces values from to produce the property with.
1437 * @param ag The arbitrrary to produces values from to produce the property with.
1438 * @param ah The arbitrrary to produces values from to produce the property with.
1439 * @param sa The shrink strategy to use upon falsification.
1440 * @param sb The shrink strategy to use upon falsification.
1441 * @param sc The shrink strategy to use upon falsification.
1442 * @param sd The shrink strategy to use upon falsification.
1443 * @param se The shrink strategy to use upon falsification.
1444 * @param sf The shrink strategy to use upon falsification.
1445 * @param sg The shrink strategy to use upon falsification.
1446 * @param sh The shrink strategy to use upon falsification.
1447 * @param f The function to produce properties with results.
1448 * @return A property where its result is derived from universal quantification across the
1449 * application of its arguments.
1450 */
1451 public static <A, B, C, D, E, F$, G, H> Property property(final Arbitrary<A> aa,
1452 final Arbitrary<B> ab,
1453 final Arbitrary<C> ac,
1454 final Arbitrary<D> ad,
1455 final Arbitrary<E> ae,
1456 final Arbitrary<F$> af,
1457 final Arbitrary<G> ag,
1458 final Arbitrary<H> ah,
1459 final Shrink<A> sa,
1460 final Shrink<B> sb,
1461 final Shrink<C> sc,
1462 final Shrink<D> sd,
1463 final Shrink<E> se,
1464 final Shrink<F$> sf,
1465 final Shrink<G> sg,
1466 final Shrink<H> sh,
1467 final F<A, F<B, F<C, F<D, F<E, F<F$, F<G, F<H, Property>>>>>>>> f) {
1468 return property(aa, ab, ac, ad, ae, af, ag, sa, sb, sc, sd, se, sf, sg, new F<A, F<B, F<C, F<D, F<E, F<F$, F<G, Property>>>>>>>() {
1469 public F<B, F<C, F<D, F<E, F<F$, F<G, Property>>>>>> f(final A a) {
1470 return new F<B, F<C, F<D, F<E, F<F$, F<G, Property>>>>>>() {
1471 public F<C, F<D, F<E, F<F$, F<G, Property>>>>> f(final B b) {
1472 return new F<C, F<D, F<E, F<F$, F<G, Property>>>>>() {
1473 public F<D, F<E, F<F$, F<G, Property>>>> f(final C c) {
1474 return new F<D, F<E, F<F$, F<G, Property>>>>() {
1475 public F<E, F<F$, F<G, Property>>> f(final D d) {
1476 return new F<E, F<F$, F<G, Property>>>() {
1477 public F<F$, F<G, Property>> f(final E e) {
1478 return new F<F$, F<G, Property>>() {
1479 public F<G, Property> f(final F$ f$) {
1480 return new F<G, Property>() {
1481 public Property f(final G g) {
1482 return property(ah, sh, new F<H, Property>() {
1483 public Property f(final H h) {
1484 return f.f(a).f(b).f(c).f(d).f(e).f(f$).f(g).f(h);
1485 }
1486 });
1487 }
1488 };
1489 }
1490 };
1491 }
1492 };
1493 }
1494 };
1495 }
1496 };
1497 }
1498 };
1499 }
1500 });
1501 }
1502
1503 /**
1504 * Returns a property where its result is derived from universal quantification across the
1505 * application of its arguments. No shrinking occurs upon falsification.
1506 *
1507 * @param aa The arbitrrary to produces values from to produce the property with.
1508 * @param ab The arbitrrary to produces values from to produce the property with.
1509 * @param ac The arbitrrary to produces values from to produce the property with.
1510 * @param ad The arbitrrary to produces values from to produce the property with.
1511 * @param ae The arbitrrary to produces values from to produce the property with.
1512 * @param af The arbitrrary to produces values from to produce the property with.
1513 * @param ag The arbitrrary to produces values from to produce the property with.
1514 * @param ah The arbitrrary to produces values from to produce the property with.
1515 * @param f The function to produce properties with results.
1516 * @return A property where its result is derived from universal quantification across the
1517 * application of its arguments.
1518 */
1519 public static <A, B, C, D, E, F$, G, H> Property property(final Arbitrary<A> aa,
1520 final Arbitrary<B> ab,
1521 final Arbitrary<C> ac,
1522 final Arbitrary<D> ad,
1523 final Arbitrary<E> ae,
1524 final Arbitrary<F$> af,
1525 final Arbitrary<G> ag,
1526 final Arbitrary<H> ah,
1527 final F<A, F<B, F<C, F<D, F<E, F<F$, F<G, F<H, Property>>>>>>>> f) {
1528 return property(aa, ab, ac, ad, ae, af, ag, new F<A, F<B, F<C, F<D, F<E, F<F$, F<G, Property>>>>>>>() {
1529 public F<B, F<C, F<D, F<E, F<F$, F<G, Property>>>>>> f(final A a) {
1530 return new F<B, F<C, F<D, F<E, F<F$, F<G, Property>>>>>>() {
1531 public F<C, F<D, F<E, F<F$, F<G, Property>>>>> f(final B b) {
1532 return new F<C, F<D, F<E, F<F$, F<G, Property>>>>>() {
1533 public F<D, F<E, F<F$, F<G, Property>>>> f(final C c) {
1534 return new F<D, F<E, F<F$, F<G, Property>>>>() {
1535 public F<E, F<F$, F<G, Property>>> f(final D d) {
1536 return new F<E, F<F$, F<G, Property>>>() {
1537 public F<F$, F<G, Property>> f(final E e) {
1538 return new F<F$, F<G, Property>>() {
1539 public F<G, Property> f(final F$ f$) {
1540 return new F<G, Property>() {
1541 public Property f(final G g) {
1542 return property(ah, new F<H, Property>() {
1543 public Property f(final H h) {
1544 return f.f(a).f(b).f(c).f(d).f(e).f(f$).f(g).f(h);
1545 }
1546 });
1547 }
1548 };
1549 }
1550 };
1551 }
1552 };
1553 }
1554 };
1555 }
1556 };
1557 }
1558 };
1559 }
1560 });
1561 }
1562
1563 /**
1564 * Returns a property where its result is derived from universal quantification across the
1565 * application of its arguments.
1566 *
1567 * @param aa The arbitrrary to produces values from to produce the property with.
1568 * @param ab The arbitrrary to produces values from to produce the property with.
1569 * @param ac The arbitrrary to produces values from to produce the property with.
1570 * @param ad The arbitrrary to produces values from to produce the property with.
1571 * @param ae The arbitrrary to produces values from to produce the property with.
1572 * @param af The arbitrrary to produces values from to produce the property with.
1573 * @param ag The arbitrrary to produces values from to produce the property with.
1574 * @param ah The arbitrrary to produces values from to produce the property with.
1575 * @param sa The shrink strategy to use upon falsification.
1576 * @param sb The shrink strategy to use upon falsification.
1577 * @param sc The shrink strategy to use upon falsification.
1578 * @param sd The shrink strategy to use upon falsification.
1579 * @param se The shrink strategy to use upon falsification.
1580 * @param sf The shrink strategy to use upon falsification.
1581 * @param sg The shrink strategy to use upon falsification.
1582 * @param sh The shrink strategy to use upon falsification.
1583 * @param f The function to produce properties with results.
1584 * @return A property where its result is derived from universal quantification across the
1585 * application of its arguments.
1586 */
1587 public static <A, B, C, D, E, F$, G, H> Property property(final Arbitrary<A> aa,
1588 final Arbitrary<B> ab,
1589 final Arbitrary<C> ac,
1590 final Arbitrary<D> ad,
1591 final Arbitrary<E> ae,
1592 final Arbitrary<F$> af,
1593 final Arbitrary<G> ag,
1594 final Arbitrary<H> ah,
1595 final Shrink<A> sa,
1596 final Shrink<B> sb,
1597 final Shrink<C> sc,
1598 final Shrink<D> sd,
1599 final Shrink<E> se,
1600 final Shrink<F$> sf,
1601 final Shrink<G> sg,
1602 final Shrink<H> sh,
1603 final F8<A, B, C, D, E, F$, G, H, Property> f) {
1604 return property(aa, ab, ac, ad, ae, af, ag, ah, sa, sb, sc, sd, se, sf, sg, sh, curry(f));
1605 }
1606
1607 /**
1608 * Returns a property where its result is derived from universal quantification across the
1609 * application of its arguments. No shrinking occurs upon falsification.
1610 *
1611 * @param aa The arbitrrary to produces values from to produce the property with.
1612 * @param ab The arbitrrary to produces values from to produce the property with.
1613 * @param ac The arbitrrary to produces values from to produce the property with.
1614 * @param ad The arbitrrary to produces values from to produce the property with.
1615 * @param ae The arbitrrary to produces values from to produce the property with.
1616 * @param af The arbitrrary to produces values from to produce the property with.
1617 * @param ag The arbitrrary to produces values from to produce the property with.
1618 * @param ah The arbitrrary to produces values from to produce the property with.
1619 * @param f The function to produce properties with results.
1620 * @return A property where its result is derived from universal quantification across the
1621 * application of its arguments.
1622 */
1623 public static <A, B, C, D, E, F$, G, H> Property property(final Arbitrary<A> aa,
1624 final Arbitrary<B> ab,
1625 final Arbitrary<C> ac,
1626 final Arbitrary<D> ad,
1627 final Arbitrary<E> ae,
1628 final Arbitrary<F$> af,
1629 final Arbitrary<G> ag,
1630 final Arbitrary<H> ah,
1631 final F8<A, B, C, D, E, F$, G, H, Property> f) {
1632 return property(aa, ab, ac, ad, ae, af, ag, ah, curry(f));
1633 }
1634
1635 /**
1636 * Returns a property that has a result of exception, if the evaluation of the given property
1637 * throws an exception; otherwise, the given property is returned.
1638 *
1639 * @param p A property to evaluate to check for an exception.
1640 * @return A property that has a result of exception, if the evaluation of the given property
1641 * throws an exception; otherwise, the given property is returned.
1642 */
1643 public static Property exception(final P1<Property> p) {
1644 try {
1645 return p._1();
1646 } catch (final Throwable t) {
1647 return new Property(new F<Integer, F<Rand, Result>>() {
1648 public F<Rand, Result> f(final Integer i) {
1649 return new F<Rand, Result>() {
1650 public Result f(final Rand r) {
1651 return Result.exception(List.<Arg<?>>nil(), t);
1652 }
1653 };
1654 }
1655 });
1656 }
1657 }
1658
1659
1660
1661 }