(ns active-quickcheck-example.core-test
  (:use [active.quickcheck])
  (:require [clojure.test :refer :all]))

;; This will pass and NOT produce an exception
(deftest trivial-test
  (is (quickcheck
       (property [x integer]
                 (= x x)))))
;; => OK, passed 100 tests.

(ns active-quickcheck-example.core2-test
  (:require [clojure.test :refer :all]
            [active.quickcheck :as qc]))

;; This will report success but produce an exception
(deftest trivial-test
  (is (qs/quickcheck
       (qs/property [x integer]
                    (= x x)))))
;; => OK, passed 100 tests.
Fail in trivial-test

expected: (qs/quickcheck (qs/property [x integer] (= x x)))

  actual: (not          
           (qs/quickcheck
            #active.quickcheck.Property-type{:func
                                             #function[active-quickcheck-example.core2-test/fn--17615/fn--17616],
                                             :arg-names (x),
                                             :args
                                             (#active.quickcheck.Arbitrary-type{:generator
                                                                                #active.clojure.monad.Bind{:monad
                                                                                                           #active.quickcheck.Get-size-type{},
                                                                                                           :cont
                                                                                                           #function[active.quickcheck/sized/fn--14763]}})}))

(ns example.check
  (:use [active.quickcheck])
  (:require [clojure.spec.alpha :as s]
            [clojure.test :as t]
            [clojure.test.check.generators :as gen]))

(s/def ::nat pos-int?)

(def sure-its-always-4-elems
  "A spec that always generates a list of exactly four distinct positive
  integers."
  (s/spec (s/coll-of ::nat :into [])
          :gen (fn []
                 (gen/list-distinct (s/gen ::nat) {:num-elements 4}))))

;; This works
(s/exercise sure-its-always-4-elems)

;; This doesn't work but instead generates examples with `nil` cases.
(quickcheck
 (property [ks (spec sure-its-always-4-elems)]
           (let [[a b c d] ks]
             (t/is (distinct? a b c d)))))