Skip to content

Commit

Permalink
Merge pull request #112 from CodaFi/exceptionally-gifted
Browse files Browse the repository at this point in the history 
Catch Exceptions in Tests
  • Loading branch information
@CodaFi
CodaFi committed Oct 15, 2015
2 parents 6a513d8 + a484637 commit ba589d0
Show file tree
Hide file tree
Showing 3 changed files with 66 additions and 52 deletions.
106 changes: 55 additions & 51 deletions SwiftCheck/Test.swift
View file
Original file line number Diff line number Diff line change
Expand Up @@ -86,113 +86,113 @@
/// Converts a function into a universally quantified property using the default shrinker and
/// generator for that type.
@warn_unused_result
public func forAll<A : Arbitrary>(pf : (A -> Testable)) -> Property {
public func forAll<A : Arbitrary>(pf : (A throws -> Testable)) -> Property {
return forAllShrink(A.arbitrary, shrinker: A.shrink, f: pf)
}

/// Converts a function into a universally quantified property using the default shrinker and
/// generator for 2 types.
@warn_unused_result
public func forAll<A : Arbitrary, B : Arbitrary>(pf : (A, B) -> Testable) -> Property {
return forAll({ t in forAll({ b in pf(t, b) }) })
public func forAll<A : Arbitrary, B : Arbitrary>(pf : (A, B) throws -> Testable) -> Property {
return forAll({ t in forAll({ b in try pf(t, b) }) })
}

/// Converts a function into a universally quantified property using the default shrinker and
/// generator for 3 types.
@warn_unused_result
public func forAll<A : Arbitrary, B : Arbitrary, C : Arbitrary>(pf : (A, B, C) -> Testable) -> Property {
return forAll({ t in forAll({ b, c in pf(t, b, c) }) })
public func forAll<A : Arbitrary, B : Arbitrary, C : Arbitrary>(pf : (A, B, C) throws -> Testable) -> Property {
return forAll({ t in forAll({ b, c in try pf(t, b, c) }) })
}

/// Converts a function into a universally quantified property using the default shrinker and
/// generator for 4 types.
@warn_unused_result
public func forAll<A : Arbitrary, B : Arbitrary, C : Arbitrary, D : Arbitrary>(pf : (A, B, C, D) -> Testable) -> Property {
return forAll({ t in forAll({ b, c, d in pf(t, b, c, d) }) })
public func forAll<A : Arbitrary, B : Arbitrary, C : Arbitrary, D : Arbitrary>(pf : (A, B, C, D) throws -> Testable) -> Property {
return forAll({ t in forAll({ b, c, d in try pf(t, b, c, d) }) })
}

/// Converts a function into a universally quantified property using the default shrinker and
/// generator for 5 types.
@warn_unused_result
public func forAll<A : Arbitrary, B : Arbitrary, C : Arbitrary, D : Arbitrary, E : Arbitrary>(pf : (A, B, C, D, E) -> Testable) -> Property {
return forAll({ t in forAll({ b, c, d, e in pf(t, b, c, d, e) }) })
public func forAll<A : Arbitrary, B : Arbitrary, C : Arbitrary, D : Arbitrary, E : Arbitrary>(pf : (A, B, C, D, E) throws -> Testable) -> Property {
return forAll({ t in forAll({ b, c, d, e in try pf(t, b, c, d, e) }) })
}

/// Converts a function into a universally quantified property using the default shrinker and
/// generator for 6 types.
@warn_unused_result
public func forAll<A : Arbitrary, B : Arbitrary, C : Arbitrary, D : Arbitrary, E : Arbitrary, F : Arbitrary>(pf : (A, B, C, D, E, F) -> Testable) -> Property {
return forAll({ t in forAll({ b, c, d, e, f in pf(t, b, c, d, e, f) }) })
public func forAll<A : Arbitrary, B : Arbitrary, C : Arbitrary, D : Arbitrary, E : Arbitrary, F : Arbitrary>(pf : (A, B, C, D, E, F) throws -> Testable) -> Property {
return forAll({ t in forAll({ b, c, d, e, f in try pf(t, b, c, d, e, f) }) })
}

/// Converts a function into a universally quantified property using the default shrinker and
/// generator for 7 types.
@warn_unused_result
public func forAll<A : Arbitrary, B : Arbitrary, C : Arbitrary, D : Arbitrary, E : Arbitrary, F : Arbitrary, G : Arbitrary>(pf : (A, B, C, D, E, F, G) -> Testable) -> Property {
return forAll({ t in forAll({ b, c, d, e, f, g in pf(t, b, c, d, e, f, g) }) })
public func forAll<A : Arbitrary, B : Arbitrary, C : Arbitrary, D : Arbitrary, E : Arbitrary, F : Arbitrary, G : Arbitrary>(pf : (A, B, C, D, E, F, G) throws -> Testable) -> Property {
return forAll({ t in forAll({ b, c, d, e, f, g in try pf(t, b, c, d, e, f, g) }) })
}

/// Converts a function into a universally quantified property using the default shrinker and
/// generator for 8 types.
@warn_unused_result
public func forAll<A : Arbitrary, B : Arbitrary, C : Arbitrary, D : Arbitrary, E : Arbitrary, F : Arbitrary, G : Arbitrary, H : Arbitrary>(pf : (A, B, C, D, E, F, G, H) -> Testable) -> Property {
return forAll({ t in forAll({ b, c, d, e, f, g, h in pf(t, b, c, d, e, f, g, h) }) })
public func forAll<A : Arbitrary, B : Arbitrary, C : Arbitrary, D : Arbitrary, E : Arbitrary, F : Arbitrary, G : Arbitrary, H : Arbitrary>(pf : (A, B, C, D, E, F, G, H) throws -> Testable) -> Property {
return forAll({ t in forAll({ b, c, d, e, f, g, h in try pf(t, b, c, d, e, f, g, h) }) })
}

/// Given an explicit generator, converts a function to a universally quantified property using the
/// default shrinker for that type.
@warn_unused_result
public func forAll<A : Arbitrary>(gen : Gen<A>, pf : (A -> Testable)) -> Property {
public func forAll<A : Arbitrary>(gen : Gen<A>, pf : (A throws -> Testable)) -> Property {
return forAllShrink(gen, shrinker: A.shrink, f: pf)
}

/// Given 2 explicit generators, converts a function to a universally quantified property using the
/// default shrinkers for those 2 types.
@warn_unused_result
public func forAll<A : Arbitrary, B : Arbitrary>(genA : Gen<A>, _ genB : Gen<B>, pf : (A, B) -> Testable) -> Property {
return forAll(genA, pf: { t in forAll(genB, pf: { b in pf(t, b) }) })
public func forAll<A : Arbitrary, B : Arbitrary>(genA : Gen<A>, _ genB : Gen<B>, pf : (A, B) throws -> Testable) -> Property {
return forAll(genA, pf: { t in forAll(genB, pf: { b in try pf(t, b) }) })
}

/// Given 3 explicit generators, converts a function to a universally quantified property using the
/// default shrinkers for those 3 types.
@warn_unused_result
public func forAll<A : Arbitrary, B : Arbitrary, C : Arbitrary>(genA : Gen<A>, _ genB : Gen<B>, _ genC : Gen<C>, pf : (A, B, C) -> Testable) -> Property {
return forAll(genA, pf: { t in forAll(genB, genC, pf: { b, c in pf(t, b, c) }) })
public func forAll<A : Arbitrary, B : Arbitrary, C : Arbitrary>(genA : Gen<A>, _ genB : Gen<B>, _ genC : Gen<C>, pf : (A, B, C) throws -> Testable) -> Property {
return forAll(genA, pf: { t in forAll(genB, genC, pf: { b, c in try pf(t, b, c) }) })
}

/// Given 4 explicit generators, converts a function to a universally quantified property using the
/// default shrinkers for those 4 types.
@warn_unused_result
public func forAll<A : Arbitrary, B : Arbitrary, C : Arbitrary, D : Arbitrary>(genA : Gen<A>, _ genB : Gen<B>, _ genC : Gen<C>, _ genD : Gen<D>, pf : (A, B, C, D) -> Testable) -> Property {
return forAll(genA, pf: { t in forAll(genB, genC, genD, pf: { b, c, d in pf(t, b, c, d) }) })
public func forAll<A : Arbitrary, B : Arbitrary, C : Arbitrary, D : Arbitrary>(genA : Gen<A>, _ genB : Gen<B>, _ genC : Gen<C>, _ genD : Gen<D>, pf : (A, B, C, D) throws -> Testable) -> Property {
return forAll(genA, pf: { t in forAll(genB, genC, genD, pf: { b, c, d in try pf(t, b, c, d) }) })
}

/// Given 5 explicit generators, converts a function to a universally quantified property using the
/// default shrinkers for those 5 types.
@warn_unused_result
public func forAll<A : Arbitrary, B : Arbitrary, C : Arbitrary, D : Arbitrary, E : Arbitrary>(genA : Gen<A>, _ genB : Gen<B>, _ genC : Gen<C>, _ genD : Gen<D>, _ genE : Gen<E>, pf : (A, B, C, D, E) -> Testable) -> Property {
return forAll(genA, pf: { t in forAll(genB, genC, genD, genE, pf: { b, c, d, e in pf(t, b, c, d, e) }) })
public func forAll<A : Arbitrary, B : Arbitrary, C : Arbitrary, D : Arbitrary, E : Arbitrary>(genA : Gen<A>, _ genB : Gen<B>, _ genC : Gen<C>, _ genD : Gen<D>, _ genE : Gen<E>, pf : (A, B, C, D, E) throws -> Testable) -> Property {
return forAll(genA, pf: { t in forAll(genB, genC, genD, genE, pf: { b, c, d, e in try pf(t, b, c, d, e) }) })
}

/// Given 6 explicit generators, converts a function to a universally quantified property using the
/// default shrinkers for those 6 types.
@warn_unused_result
public func forAll<A : Arbitrary, B : Arbitrary, C : Arbitrary, D : Arbitrary, E : Arbitrary, F : Arbitrary>(genA : Gen<A>, _ genB : Gen<B>, _ genC : Gen<C>, _ genD : Gen<D>, _ genE : Gen<E>, _ genF : Gen<F>, pf : (A, B, C, D, E, F) -> Testable) -> Property {
return forAll(genA, pf: { t in forAll(genB, genC, genD, genE, genF, pf: { b, c, d, e, f in pf(t, b, c, d, e, f) }) })
public func forAll<A : Arbitrary, B : Arbitrary, C : Arbitrary, D : Arbitrary, E : Arbitrary, F : Arbitrary>(genA : Gen<A>, _ genB : Gen<B>, _ genC : Gen<C>, _ genD : Gen<D>, _ genE : Gen<E>, _ genF : Gen<F>, pf : (A, B, C, D, E, F) throws -> Testable) -> Property {
return forAll(genA, pf: { t in forAll(genB, genC, genD, genE, genF, pf: { b, c, d, e, f in try pf(t, b, c, d, e, f) }) })
}

/// Given 7 explicit generators, converts a function to a universally quantified property using the
/// default shrinkers for those 7 types.
@warn_unused_result
public func forAll<A : Arbitrary, B : Arbitrary, C : Arbitrary, D : Arbitrary, E : Arbitrary, F : Arbitrary, G : Arbitrary>(genA : Gen<A>, _ genB : Gen<B>, _ genC : Gen<C>, _ genD : Gen<D>, _ genE : Gen<E>, _ genF : Gen<F>, _ genG : Gen<G>, pf : (A, B, C, D, E, F, G) -> Testable) -> Property {
return forAll(genA, pf: { t in forAll(genB, genC, genD, genE, genF, genG, pf: { b, c, d, e, f, g in pf(t, b, c, d, e, f, g) }) })
public func forAll<A : Arbitrary, B : Arbitrary, C : Arbitrary, D : Arbitrary, E : Arbitrary, F : Arbitrary, G : Arbitrary>(genA : Gen<A>, _ genB : Gen<B>, _ genC : Gen<C>, _ genD : Gen<D>, _ genE : Gen<E>, _ genF : Gen<F>, _ genG : Gen<G>, pf : (A, B, C, D, E, F, G) throws -> Testable) -> Property {
return forAll(genA, pf: { t in forAll(genB, genC, genD, genE, genF, genG, pf: { b, c, d, e, f, g in try pf(t, b, c, d, e, f, g) }) })
}

/// Given 8 explicit generators, converts a function to a universally quantified property using the
/// default shrinkers for those 8 types.
@warn_unused_result
public func forAll<A : Arbitrary, B : Arbitrary, C : Arbitrary, D : Arbitrary, E : Arbitrary, F : Arbitrary, G : Arbitrary, H : Arbitrary>(genA : Gen<A>, _ genB : Gen<B>, _ genC : Gen<C>, _ genD : Gen<D>, _ genE : Gen<E>, _ genF : Gen<F>, _ genG : Gen<G>, _ genH : Gen<H>, pf : (A, B, C, D, E, F, G, H) -> Testable) -> Property {
return forAll(genA, pf: { t in forAll(genB, genC, genD, genE, genF, genG, genH, pf: { b, c, d, e, f, g, h in pf(t, b, c, d, e, f, g, h) }) })
public func forAll<A : Arbitrary, B : Arbitrary, C : Arbitrary, D : Arbitrary, E : Arbitrary, F : Arbitrary, G : Arbitrary, H : Arbitrary>(genA : Gen<A>, _ genB : Gen<B>, _ genC : Gen<C>, _ genD : Gen<D>, _ genE : Gen<E>, _ genF : Gen<F>, _ genG : Gen<G>, _ genH : Gen<H>, pf : (A, B, C, D, E, F, G, H) throws -> Testable) -> Property {
return forAll(genA, pf: { t in forAll(genB, genC, genD, genE, genF, genG, genH, pf: { b, c, d, e, f, g, h in try pf(t, b, c, d, e, f, g, h) }) })
}

/// Given an explicit generator, converts a function to a universally quantified property for that
Expand All @@ -201,7 +201,7 @@ public func forAll<A : Arbitrary, B : Arbitrary, C : Arbitrary, D : Arbitrary, E
/// This variant of `forAll` does not shrink its argument but allows generators of any type, not
/// just those that conform to `Arbitrary`.
@warn_unused_result
public func forAllNoShrink<A>(gen : Gen<A>, pf : (A -> Testable)) -> Property {
public func forAllNoShrink<A>(gen : Gen<A>, pf : (A throws -> Testable)) -> Property {
return forAllShrink(gen, shrinker: { _ in [A]() }, f: pf)
}

Expand All @@ -211,8 +211,8 @@ public func forAllNoShrink<A>(gen : Gen<A>, pf : (A -> Testable)) -> Property {
/// This variant of `forAll` does not shrink its argument but allows generators of any type, not
/// just those that conform to `Arbitrary`.
@warn_unused_result
public func forAllNoShrink<A, B>(genA : Gen<A>, _ genB : Gen<B>, pf : (A, B) -> Testable) -> Property {
return forAllNoShrink(genA, pf: { t in forAllNoShrink(genB, pf: { b in pf(t, b) }) })
public func forAllNoShrink<A, B>(genA : Gen<A>, _ genB : Gen<B>, pf : (A, B) throws -> Testable) -> Property {
return forAllNoShrink(genA, pf: { t in forAllNoShrink(genB, pf: { b in try pf(t, b) }) })
}

/// Given 3 explicit generators, converts a function to a universally quantified property for those
Expand All @@ -221,8 +221,8 @@ public func forAllNoShrink<A, B>(genA : Gen<A>, _ genB : Gen<B>, pf : (A, B) ->
/// This variant of `forAll` does not shrink its argument but allows generators of any type, not
/// just those that conform to `Arbitrary`.
@warn_unused_result
public func forAllNoShrink<A, B, C>(genA : Gen<A>, _ genB : Gen<B>, _ genC : Gen<C>, pf : (A, B, C) -> Testable) -> Property {
return forAllNoShrink(genA, pf: { t in forAllNoShrink(genB, genC, pf: { b, c in pf(t, b, c) }) })
public func forAllNoShrink<A, B, C>(genA : Gen<A>, _ genB : Gen<B>, _ genC : Gen<C>, pf : (A, B, C) throws -> Testable) -> Property {
return forAllNoShrink(genA, pf: { t in forAllNoShrink(genB, genC, pf: { b, c in try pf(t, b, c) }) })
}

/// Given 4 explicit generators, converts a function to a universally quantified property
Expand All @@ -231,8 +231,8 @@ public func forAllNoShrink<A, B, C>(genA : Gen<A>, _ genB : Gen<B>, _ genC : Gen
/// This variant of `forAll` does not shrink its argument but allows generators of any type, not
/// just those that conform to `Arbitrary`.
@warn_unused_result
public func forAllNoShrink<A, B, C, D>(genA : Gen<A>, _ genB : Gen<B>, _ genC : Gen<C>, _ genD : Gen<D>, pf : (A, B, C, D) -> Testable) -> Property {
return forAllNoShrink(genA, pf: { t in forAllNoShrink(genB, genC, genD, pf: { b, c, d in pf(t, b, c, d) }) })
public func forAllNoShrink<A, B, C, D>(genA : Gen<A>, _ genB : Gen<B>, _ genC : Gen<C>, _ genD : Gen<D>, pf : (A, B, C, D) throws -> Testable) -> Property {
return forAllNoShrink(genA, pf: { t in forAllNoShrink(genB, genC, genD, pf: { b, c, d in try pf(t, b, c, d) }) })
}

/// Given 5 explicit generators, converts a function to a universally quantified property for those
Expand All @@ -241,8 +241,8 @@ public func forAllNoShrink<A, B, C, D>(genA : Gen<A>, _ genB : Gen<B>, _ genC :
/// This variant of `forAll` does not shrink its argument but allows generators of any type, not
/// just those that conform to `Arbitrary`.
@warn_unused_result
public func forAllNoShrink<A, B, C, D, E>(genA : Gen<A>, _ genB : Gen<B>, _ genC : Gen<C>, _ genD : Gen<D>, _ genE : Gen<E>, pf : (A, B, C, D, E) -> Testable) -> Property {
return forAllNoShrink(genA, pf: { t in forAllNoShrink(genB, genC, genD, genE, pf: { b, c, d, e in pf(t, b, c, d, e) }) })
public func forAllNoShrink<A, B, C, D, E>(genA : Gen<A>, _ genB : Gen<B>, _ genC : Gen<C>, _ genD : Gen<D>, _ genE : Gen<E>, pf : (A, B, C, D, E) throws -> Testable) -> Property {
return forAllNoShrink(genA, pf: { t in forAllNoShrink(genB, genC, genD, genE, pf: { b, c, d, e in try pf(t, b, c, d, e) }) })
}

/// Given 6 explicit generators, converts a function to a universally quantified property for those
Expand All @@ -251,8 +251,8 @@ public func forAllNoShrink<A, B, C, D, E>(genA : Gen<A>, _ genB : Gen<B>, _ genC
/// This variant of `forAll` does not shrink its argument but allows generators of any type, not
/// just those that conform to `Arbitrary`.
@warn_unused_result
public func forAllNoShrink<A, B, C, D, E, F>(genA : Gen<A>, _ genB : Gen<B>, _ genC : Gen<C>, _ genD : Gen<D>, _ genE : Gen<E>, _ genF : Gen<F>, pf : (A, B, C, D, E, F) -> Testable) -> Property {
return forAllNoShrink(genA, pf: { t in forAllNoShrink(genB, genC, genD, genE, genF, pf: { b, c, d, e, f in pf(t, b, c, d, e, f) }) })
public func forAllNoShrink<A, B, C, D, E, F>(genA : Gen<A>, _ genB : Gen<B>, _ genC : Gen<C>, _ genD : Gen<D>, _ genE : Gen<E>, _ genF : Gen<F>, pf : (A, B, C, D, E, F) throws -> Testable) -> Property {
return forAllNoShrink(genA, pf: { t in forAllNoShrink(genB, genC, genD, genE, genF, pf: { b, c, d, e, f in try pf(t, b, c, d, e, f) }) })
}

/// Given 7 explicit generators, converts a function to a universally quantified property for those
Expand All @@ -261,8 +261,8 @@ public func forAllNoShrink<A, B, C, D, E, F>(genA : Gen<A>, _ genB : Gen<B>, _ g
/// This variant of `forAll` does not shrink its argument but allows generators of any type, not
/// just those that conform to `Arbitrary`.
@warn_unused_result
public func forAllNoShrink<A, B, C, D, E, F, G>(genA : Gen<A>, _ genB : Gen<B>, _ genC : Gen<C>, _ genD : Gen<D>, _ genE : Gen<E>, _ genF : Gen<F>, _ genG : Gen<G>, pf : (A, B, C, D, E, F, G) -> Testable) -> Property {
return forAllNoShrink(genA, pf: { t in forAllNoShrink(genB, genC, genD, genE, genF, genG, pf: { b, c, d, e, f, g in pf(t, b, c, d, e, f, g) }) })
public func forAllNoShrink<A, B, C, D, E, F, G>(genA : Gen<A>, _ genB : Gen<B>, _ genC : Gen<C>, _ genD : Gen<D>, _ genE : Gen<E>, _ genF : Gen<F>, _ genG : Gen<G>, pf : (A, B, C, D, E, F, G) throws -> Testable) -> Property {
return forAllNoShrink(genA, pf: { t in forAllNoShrink(genB, genC, genD, genE, genF, genG, pf: { b, c, d, e, f, g in try pf(t, b, c, d, e, f, g) }) })
}

/// Given 8 explicit generators, converts a function to a universally quantified property for those
Expand All @@ -271,17 +271,21 @@ public func forAllNoShrink<A, B, C, D, E, F, G>(genA : Gen<A>, _ genB : Gen<B>,
/// This variant of `forAll` does not shrink its argument but allows generators of any type, not
/// just those that conform to `Arbitrary`.
@warn_unused_result
public func forAllNoShrink<A, B, C, D, E, F, G, H>(genA : Gen<A>, _ genB : Gen<B>, _ genC : Gen<C>, _ genD : Gen<D>, _ genE : Gen<E>, _ genF : Gen<F>, _ genG : Gen<G>, _ genH : Gen<H>, pf : (A, B, C, D, E, F, G, H) -> Testable) -> Property {
return forAllNoShrink(genA, pf: { t in forAllNoShrink(genB, genC, genD, genE, genF, genG, genH, pf: { b, c, d, e, f, g, h in pf(t, b, c, d, e, f, g, h) }) })
public func forAllNoShrink<A, B, C, D, E, F, G, H>(genA : Gen<A>, _ genB : Gen<B>, _ genC : Gen<C>, _ genD : Gen<D>, _ genE : Gen<E>, _ genF : Gen<F>, _ genG : Gen<G>, _ genH : Gen<H>, pf : (A, B, C, D, E, F, G, H) throws -> Testable) -> Property {
return forAllNoShrink(genA, pf: { t in forAllNoShrink(genB, genC, genD, genE, genF, genG, genH, pf: { b, c, d, e, f, g, h in try pf(t, b, c, d, e, f, g, h) }) })
}

/// Given an explicit generator and shrinker, converts a function to a universally quantified
/// property.
@warn_unused_result
public func forAllShrink<A>(gen : Gen<A>, shrinker : A -> [A], f : A -> Testable) -> Property {
public func forAllShrink<A>(gen : Gen<A>, shrinker : A -> [A], f : A throws -> Testable) -> Property {
return Property(gen.bind { x in
return shrinking(shrinker, initial: x, prop: { xs in
return f(xs).counterexample(String(xs))
do {
return (try f(xs)).counterexample(String(xs))
} catch let e {
return TestResult.failed("Test case threw an exception: \"" + String(e) + "\"")
}
}).unProperty
})
}
Expand All @@ -302,14 +306,14 @@ public func forAllShrink<A>(gen : Gen<A>, shrinker : A -> [A], f : A -> Testable
/// [Skolem Normal Form](https://en.wikipedia.org/wiki/Skolem_normal_form). `SNF` involves turning
/// every `exists` into a function returning the existential value, taking any other parameters
/// being quantified over as needed.
public func exists<A : Arbitrary>(pf : A -> Testable) -> Property {
public func exists<A : Arbitrary>(pf : A throws -> Testable) -> Property {
return exists(A.arbitrary, pf: pf)
}

/// Given an explicit generator, converts a function to an existentially quantified property using
/// the default shrinker for that type.
public func exists<A : Arbitrary>(gen : Gen<A>, pf : A -> Testable) -> Property {
return forAllNoShrink(A.arbitrary, pf: { pf($0).invert }).invert.mapResult { res in
public func exists<A : Arbitrary>(gen : Gen<A>, pf : A throws -> Testable) -> Property {
return forAllNoShrink(A.arbitrary, pf: { try pf($0).invert }).invert.mapResult { res in
return TestResult(ok: res.ok
, expect: res.expect
, reason: res.reason
Expand All @@ -322,7 +326,7 @@ public func exists<A : Arbitrary>(gen : Gen<A>, pf : A -> Testable) -> Property
}
}


/// Tests a property and prints the results to stdout.
public func quickCheck(prop : Testable, name : String = "") {
quickCheckWithResult(stdArgs(name), p: prop)
}
Expand Down
Loading

0 comments on commit ba589d0

Please sign in to comment.