(defn uuid-gen []
  (g/return (-> g/uuid g/generate str)))

{:table "my-table"
    :key   (uuid-gen)
    :rows  (-> (g/hash-map
                 :id                    (uuid-gen)
                 :external-reference-id g/string-alphanumeric)
             (g/vector 1000) g/not-empty g/generate)}

{
 :amount-debit  (gen/pos-int)
 :amount-credit (gen/pos-int)
}

(def gen-card (gen/let
                [card-type (gen/elements [:amount-credit :amount-debit])
                 value gen/s-pos-int]
                (hash-map card-type value)))

(println "Sample:" (gen/sample gen-card 5))
;; Sample: ({:amount-debit 1} {:amount-debit 1} {:amount-credit 1} {:amount-debit 3} {:amount-credit 2})

(g/let [debit? g/boolean]
  (g/hash-map
    :created-at            (timestamp-gen)
    :amount-debit          (g/fmap #(when debit? %) g/pos-int)
    :amount-credit         (g/fmap #(when-not debit? %) g/pos-int)))

(defn gen-when
  [x gen]
  (gen/let
    [x (gen/return x)]
    (when x gen)))

(def gen-card
  (gen/let
    [debit? gen/boolean
     amount gen/pos-int]
    (gen/hash-map
      :created-at gen/pos-int
      :amount-debit (gen-when debit? amount)
      :amount-credit (gen-when (not debit?) amount))))

({:created-at 0, :amount-debit 0, :amount-credit nil}
 {:created-at 0, :amount-debit nil, :amount-credit 0}
 {:created-at 0, :amount-debit nil, :amount-credit 2}
 {:created-at 2, :amount-debit 3, :amount-credit nil}
 {:created-at 4, :amount-debit nil, :amount-credit 0})

(defspec foo-test 100 
  (prop/for-all [m (s/gen ::bool-kv)] ,,,

ERROR in (foo-test) (

java.lang.AssertionError: Assert failed: No file for namespace my-app.test-runner exists

Error: Cannot find module 'function (f) {if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.React = f()}}’

(defn pixel->tile [position tile-size]
  {:x (Math/floor (/ (:x position) tile-size))
   :y (Math/floor (/ (:y position) tile-size))})

(facts "about numbers"
  (fact "a number is anything"
    4 => anything)
  (defspec inc-test
    100
    (prop/for-all [v gen/int]
                  (= (inc v) (+ 2 v)))))

>>> Output from clojure.test tests:

FAIL in (inc-test) (clojure_test.cljc:21)
expected: result
  actual: false

1 failures, 0 errors.
>>> Midje summary:
All checks (1) succeeded.
Subprocess failed

(first-available-timeslot {:attendees 3 :starts 2017-02-03 :ends 2017-02-03 :duration 60})

(let [a [1 2 3]
           b [:foo :bar]]
       (gen/fmap (partial apply zipmap)
                 (gen/tuple
                   (gen/shuffle a)
                   (gen/return (cycle b)))))

(defn gen-with-index-and-count-using-let
    "Return a generator that will return tuples of:
    [<value from coll-gen>
    [<valid index in coll>
    <count within bounds of index to end of coll>]."
    [coll-gen]
    (gen/let [coll coll-gen
              index (gen/choose 0 (max 0 (dec (count coll))))
              bounded-count (gen/choose 0 (- (count coll) index))]
      [coll [index bounded-count]]))

(gen/vector-distinct gen/double {:min-elements 2
                                               :max-elements 10})

(defn gen-image
  [nrows ncols]
  (gen/vector (gen/vector
               (gen/elements core/COLOURS)
               ncols)
              nrows))

(prop/for-all
 [nrows gen/pos-int
  ncols gen/pos-int
  mat (gen-image nrows ncols)])

;; generate a list of nodes
;; for each node x in the list
;;   generate a none-empty subset of nodes to the right of x in the list 
;;   for each node in the subset
;;     create an edge from x to the node

(gen/bind (gen/list-distinct gen-node {:min-elements 2})
           (fn [[node & possible-joins]]
             (gen/fmap (fn [adjacent-nodes]
                         (map (partial join-nodes node) adjacent-nodes))
                       (gen/set (gen/elements possible-joins)))))

$ lein repl
nREPL server started on port 55971 on host 127.0.0.1 - 
REPL-y 0.3.7, nREPL 0.2.12
Clojure 1.9.0-alpha17
Java HotSpot(TM) 64-Bit Server VM 1.8.0_131-b11
    Docs: (doc function-name-here)
          (find-doc "part-of-name-here")
  Source: (source function-name-here)
 Javadoc: (javadoc java-object-or-class-here)
    Exit: Control+D or (exit) or (quit)
 Results: Stored in vars *1, *2, *3, an exception in *e

user=> (require '[clojure.spec.alpha :as s]
  #_=>   '[clojure.spec.test.alpha :as st])
nil
user=> (defn ranged-rand [start end] 0)
#'user/ranged-rand
user=> (s/fdef ranged-rand
  #_=>   :args (s/and (s/cat :start int? :end int?)
  #_=>                #(< (:start %) (:end %)))
  #_=>   :ret int?
  #_=>   :fn (s/and #(>= (:ret %) (-> % :args :start))
  #_=>              #(< (:ret %) (-> % :args :end))))
user/ranged-rand
user=> (st/check `ranged-rand)
({:spec #object[clojure.spec.alpha$fspec_impl$reify__1215 0x2af92bb9 "

user=> (gen/sample (s/gen (:args (s/get-spec 'user/ranged-rand))) 10)
((0 1) (-1 0) (-1 2) (0 1) (-23 2) (1 3) (-16 -6) (-92 -10) (-1 2) (2 7))

user=> (st/check `ranged-rand {:clojure.spec.test.check/opts {:num-tests 2}})
-1 1
{:args {:start -1, :end 1}, :ret 0}
-4 -2
{:args {:start -4, :end -2}, :ret 0}
({:spec #object[clojure.spec.alpha$fspec_impl$reify__1215 0x77b18e9a "

cljs.user=> (defprotocol Result
       #_=>   (passing? [result])
       #_=>   (result-data [result] "A map of data about the trial."))
nil
cljs.user=> (extend-protocol Result
       #_=>   js/Error
       #_=>   (passing? [this] false)
       #_=>   (result-data [this] (ex-data this)))
#object[Function "function (this$){
var this$__$1 = this;
return cljs.core.ex_data.call(null,this$__$1);
}"]
cljs.user=> (result-data (ex-info "hi" {:a 1}))
{:a 1}

cljs.user=> (extend-protocol Result
       #_=>   js/Error
       #_=>   (passing? [this] false)
       #_=>   (result-data [this] (ex-message this)))
#object[Function "function (this$){
var this$__$1 = this;
return cljs.core.ex_message.call(null,this$__$1);
}"]
cljs.user=> (result-data (js/Error. "some string"))
"some string"

cljs.user=> (st/check `ranged-rand)
[{:spec #object[cljs.spec.alpha.t_cljs$spec$alpha5600],
  :clojure.test.check/ret {:result false,
                           :result-data {:a 1},
                           :seed 1497984200982,
                           :failing-size 0,
                           :num-tests 1,
                           :fail [(-1 0)],
                           :shrunk {:total-nodes-visited 0,
                                    :depth 0,
                                    :result false,
                                    :result-data {:a 1},
                                    :smallest [(-1 0)]}},
  :sym cljs.user/ranged-rand,
  :failure false}]

(passing? [this] false)
-  (result-data [this] {}))
+  (result-data [this] {})
+
+  #?(:clj Throwable :cljs js/Error)
+  (passing? [this] false)
+  (result-data [this] {:a 1}))

(let  [greater (gen/large-integer* {:min 0 :max 10})
        lesser (gen/bind greater (fn [x] (gen/large-integer* {:min 0 :max x})))]


    (prop/for-all [less lesser
                   great greater]
                  (is (<= less great)))

expected: (<= less great)
  actual: (not (<= 1 0))

(tc/quick-check 100
  (tc.prop/for-all [value (tc.gen/recursive-gen tc.gen/vector tc.gen/boolean)]
    (every? true? (flatten value))))

FAIL in (??round-trip) (:)
expected: (= e (parse (string d)))
  actual: (not (= [["_Iq1WSpRhKoq+0M?1?!CV-I+GD-ul?s**R?!*!6arO*hmmz!" "6KnðåómÔ(OD{hl$g\tÉ\"²Å¹Þˆß’" "6

(def gen-rand-double
  (gen/no-shrink
   (gen/->Generator
    (fn [rnd _size]
      (rose/pure (random/rand-double rnd))))))

(def gen-rand-long
  (gen/no-shrink
   (gen/->Generator
    (fn [rnd _size]
      (rose/pure (random/rand-long rnd))))))

(gen/generate (gen/vector gen-rand-long) 10 100) ;; => [6200754525179398429 -3542882520031353397]
(gen/generate (gen/vector gen-rand-long) 10 100) ;; => [6200754525179398429 -3542882520031353397]

{:result true, :num-tests 500, :seed 1509994998441, :test-var "the-name-of-my-test"}