Make checking's options optional

README.md

@@ -211,7 +211,7 @@ The `checking` macro is intended to be used with
          '[com.gfredericks.test.chuck.clojure-test :refer [checking]])
 
 (deftest my-test
-  (checking "that positive numbers are positive" 100
+  (checking "that positive numbers are positive"
     [x gen/s-pos-int]
     (is (pos? x))
     (is (> x 0))))

src/com/gfredericks/test/chuck/clojure_test.cljc

@@ -88,14 +88,13 @@
 (defmacro qc-and-report-exception
   [final-reports num-tests-or-options bindings & body]
   `(report-exception-or-shrunk
-     (let [num-tests-or-options# ~num-tests-or-options]
-       (apply tc/quick-check
-         (times num-tests-or-options#)
-         (prop/for-all ~bindings
-           (let [reports# (capture-reports ~@body)]
-             (swap! ~final-reports save-to-final-reports reports#)
-             (pass? reports#)))
-         (apply concat (options num-tests-or-options#))))))
+     (apply tc/quick-check
+            (times ~num-tests-or-options)
+            (prop/for-all ~bindings
+                          (let [reports# (capture-reports ~@body)]
+                            (swap! ~final-reports save-to-final-reports reports#)
+                            (pass? reports#)))
+            (apply concat (options ~num-tests-or-options)))))
 
 (defn -testing
   [name func]
@@ -106,27 +105,45 @@
   (ct/report reports))
 
 (defmacro checking
-  "A macro intended to replace the testing macro in clojure.test with a
+  {:doc      "A macro intended to replace the testing macro in clojure.test with a
   generative form. To make (testing \"doubling\" (is (= (* 2 2) (+ 2 2))))
   generative, you simply have to change it to
-  (checking \"doubling\" 100 [x gen/int] (is (= (* 2 x) (+ x x)))).
+  (checking \"doubling\" [x gen/int] (is (= (* 2 x) (+ x x)))).
 
-  You can optionally pass in a map options instead of the number of tests,
+  You can optionally pass the same options as test.check's defspec,
   which will be passed to `clojure.test.check/quick-check`, e.g.:
 
-    (checking \"doubling\" {:num-tests 100 :seed 123 :max-size 10}
+    (checking \"doubling\" 100 ;; number
+      [x gen/int]
+      (is (= (* 2 x) (+ x x))))
+
+    (checking \"doubling\" {:num-tests 100 :seed 123 :max-size 10} ;; options map
       [x gen/int]
       (is (= (* 2 x) (+ x x))))
 
   For background, see
   http://blog.colinwilliams.name/blog/2015/01/26/alternative-clojure-dot-test-integration-with-test-dot-check/"
-  [name num-tests-or-options bindings & body]
-  `(-testing ~name
-    (fn []
-      (let [final-reports# (atom [])]
-        (qc-and-report-exception final-reports# ~num-tests-or-options ~bindings ~@body)
-        (doseq [r# @final-reports#]
-          (-report r#))))))
+   :arglists '([name bindings & body] [name num-tests-or-options bindings & body])}
+  [name & check-decl]
+  (let [[num-tests-or-options bindings body]
+        (cond
+          (and (or (number? (first check-decl))
+                   (map? (first check-decl)))
+               (vector? (second check-decl)))
+          [(first check-decl) (second check-decl) (nnext check-decl)]
+
+          (vector? (first check-decl))
+          [nil (first check-decl) (next check-decl)]
+
+          :else (throw (#?(:clj  IllegalArgumentException.
+                           :cljs js/Error.) "Arguments to `checking` must be either [name bindings & body] or [name num-tests-or-options bindings & body]")))
+        num-tests-or-options (tc.clojure-test/process-options num-tests-or-options)]
+    `(-testing ~name
+               (fn []
+                 (let [final-reports# (atom [])]
+                   (qc-and-report-exception final-reports# ~num-tests-or-options ~bindings ~@body)
+                   (doseq [r# @final-reports#]
+                     (-report r#)))))))
 
 (defmacro for-all
   "An alternative to clojure.test.check.properties/for-all that uses

test/com/gfredericks/test/chuck/clojure_test_test.cljc

@@ -1,6 +1,6 @@
 (ns com.gfredericks.test.chuck.clojure-test-test
   (:require #?(:clj  [clojure.test :refer :all])
-            #?(:cljs [cljs.test :refer-macros [deftest is]])
+            #?(:cljs [cljs.test :refer-macros [deftest is testing]])
             [clojure.test.check :refer [quick-check]]
             [clojure.test.check.generators :as gen]
             [com.gfredericks.test.chuck.clojure-test #?(:clj :refer :cljs :refer-macros) [checking for-all]]))
@@ -12,6 +12,13 @@
     (is (< i 0))))
 
 (deftest options-test
+  ;; no option is OK, defaults to 100 tests
+  (let [nb-runs (atom 0)]
+    (checking "no option works" [i gen/s-pos-int]
+      (swap! nb-runs inc)
+      (is (pos? i)))
+    (testing "no option means 100 runs (test.check's default)"
+      (is (= 100 @nb-runs))))
   ;; empty map is OK, defaults to 100 tests
   (checking "strings are strings" {} [s gen/string-ascii]
     (is (string? s)))
@@ -23,7 +30,12 @@
     (is (contains? #{-1 0 1} i)))
   ;; passes because of max-size
   (checking "short strings" {:num-tests 100 :max-size 9} [s gen/string-ascii]
-    (is (< (count s) 10))))
+    (is (< (count s) 10)))
+  ;; bad options throws
+  (testing "bad option throws"
+    (is (thrown? #?(:clj IllegalArgumentException :cljs js/Object)
+                 (eval `(checking "numbers are numbers" "opts as string" [i gen/int]
+                          (is (int? i))))))))
 
 (deftest counter
   (checking "increasing" 100 [i gen/s-pos-int]