test.check

(deftest my-sort-is-correct
  (are [x y] (= x y)
       (my-sort [1])         [1]
       (my-sort [1 2])       [1 2]
       (my-sort [2 1])       [1 2]
       (my-sort [:foo :bar]) [:bar :foo]
       (my-sort [1 4 5 3 2]) [1 2 3 4 5]))

(defn my-sort [coll] (seq (into (sorted-set) coll)))

(defspec my-sort-output-increasing-prop 100
  (for-all [input (gen/vector gen/int)]
    (let [output (my-sort input)]
      (or (empty? output)
          (apply <= output)))))

(defspec my-sort-output-permutation-of-input 100
  (for-all [input (gen/vector gen/int)]
    (let [output (my-sort input)]
      (= (frequencies input) (frequencies output)))))

(defn my-sort [coll] (seq (into (sorted-set) coll)))

(my-sort [-2 -2])

;=> (-2)

(my-sort [-9 -20 -49 -20 39 -22 -40 -46 -5 30 41 44 -23 27 37 -37 -45 26 -5 -40 41 32 26 -1 41 50 -1 -29 -24 47 -33 -30 8 37])

;=> (-49 -46 -45 -40 -37 -33 -30 -29 -24 -23 -22 -20 -9 -5 -1 8 26 27 30 32 37 39 41 44 47 50)

(defn encode-state [st]
  (-> st
      json/write-str
      .getBytes
      b64/encode
      String.))

(defn decode-state [st]
  (-> st
      .getBytes
      b64/decode
      String.
      (json/read-str :key-fn keyword)))

(for-all [state gen/any]
  (= state (decode-state (encode-state state))))

;=> java.lang.Exception:
;   Don't know how to write JSON of class java.lang.Character

(for-all [state (gen/map gen/keyword gen/string)]
  (= state (decode-state (encode-state state))))

; Ran 100 tests. 0 failures, 0 errors.

(def gen-json-data
  (gen/map gen/keyword
           (gen/one-of [gen/string gen/int gen/boolean])))

(for-all [state gen-json-data]
  (= state (decode-state (encode-state state))))

; Ran 100 tests. 0 failures, 0 errors.

;; === SCHEMA ===
{ :x Int,
  (optional-key "hi") java.lang.Boolean,
  Keyword java.lang.Boolean}
;; == Samples ==
({:x 0}
 {:x 1, :FP false}
 {:x -2, :8j true, :5J false, "hi" true}
 {:x -2}
 {:x -3, :npv false, :937 true, :GtNL false}
 {:x 1, :RD1P false, :1yjJ7 false, :MvJJB false, "hi" true}
 {:x -5, :G0z6Q5 false, :Y9XT true, :YJ false, "hi" true}
 {:x 4, "hi" false}
 {:x -5, :3tTmb3H false, :Ms59j false, :7g5 true,
  :pGu69 true, :1J false, :GF27V16 false,
  "hi" false}
 {:x 1, :IK true, :V87X4F3mY false, :uX false, :mqOcoU false,
  :559khUj5 false, :UXE2 false, :Wu9b95x2 false})

(assert-set-like 1e5 my-empty-set gen/int)

(assert-set-like 1e5 my-empty-set gen/int)

;; abridged for slides
(defn assert-set-like [n empty-coll element-generator]
  (quick-check n
    (for-all [actions (gen-set-actions element-generator)]
      (let [[a b] (build-collections empty-coll #{} actions)]
        (assert-equivalent-sets a b)))))

(assert-set-like 1e5 my-empty-set gen/int)

([:conj 5]
 [:transient]
 [:disj! 5]
 [:persistent!])

(-> #{}
    (conj 5)
    transient
    (disj! 5)
    persistent!)

(-> my-empty-set
    (conj 5)
    transient
    (disj! 5)
    persistent!)

(defn create-queue [] (atom PersistentQueue/EMPTY))

(defn add [q item]
  (swap! q conj item)
  nil)

(defn remove [q]
  (let [[item rest] ((juxt first pop) @q)]
    (reset! q rest)
    item))

([:add 'ham]
 [:add 'egg]
 [:remove]
 [:add 'chips]
 [:remove])

([:add 'ham]
 [:add 'egg]
 [:remove 'ham]
 [:add 'chips]
 [:remove 'egg])

(defrecord QueueModel [items]
  Model
  (step [r {:keys [f value]}]
    (condp = f
      :add    (QueueModel. (conj items value))
      :remove (let [acquired-item value]
                (if-not (= acquired-item (first items))
                  (inconsistent
                   (str "Tried to take " acquired-item
                        " from queue offering " (first items)))
                  (QueueModel. (pop items)))))))

(defspec queue0-should-fit-model-sequentially
  (for-all [ops (gen/not-empty (gen/vector gen-queue-action))]
    (:valid? (knossos.core/analysis
               empty-queue-model
               (sequential-history (q0/create-queue) actions ops)))))

; Ran 100 tests. 0 failures, 0 errors.

(([:add 'a1] [:add 'a2]    [:remove])
 ([:add 'b1] [:remove]     [:add 'b2]))

(([:add 'a1] [:add 'a2]    [:remove 'b1])
 ([:add 'b1] [:remove 'a1] [:add 'b2]))

(([:add 'a1] [:add 'a2]    [:remove 'a1])
 ([:add 'b1] [:remove 'a2] [:add 'b2]))

(defn always [n prop]
  (gen/fmap #(or (first (remove :result (drop-last %))) (last %))
            (apply gen/tuple (repeat n prop))))

(defspec queue0-should-have-linearizable-parallel-behaviour
  (always 40
    (for-all [t1 (gen/not-empty (gen/vector gen-queue-action))
              t2 (gen/not-empty (gen/vector gen-queue-action))]
      (:valid? (knossos.core/analysis
                 empty-queue-model
                 (recorded-parallel-history
                   (q0/create-queue)
                   actions
                   {:t1 t1 :t2 t2}))))))

{:test-var queue0-should-have-linearizable-parallel-behaviour,
 :result false,
 :seed 1403643157336,
 :failing-size 0,
 :num-tests 1,
 :fail [[[:remove] [:remove]]
        [[:add 2] [:add -1]]], 
 :shrunk {:total-nodes-visited 108, :depth 66, :result false,
          :smallest [[[:add 0] [:remove]]
                     [[:remove]]]}}

;; old and busted:
(defn remove [q]
  (let [[item rest] ((juxt first pop) @q)]
    (reset! q rest)
    item))

;; new hotness:
(defn remove [q]
  (let [item (first @q)]
    (swap! q pop)
    item))

{:test-var queue1-should-have-linearizable-parallel-behaviour,
 :result false,
 :seed 1403643165214,
 :failing-size 0,
 :num-tests 1,
 :fail [[[:remove]]
        [[:add 0] [:remove]]],
 :shrunk {:total-nodes-visited 108, :depth 57, :result false,
          :smallest [[[:remove]]
                     [[:add 0] [:remove]]]}}

(defn remove [q]
  (loop []
    (let [oldval @q]
      (if (compare-and-set! q oldval (pop oldval))
        (first oldval)
        (recur)))))

;; can also use trade! from flatland/useful
;; (but don't look at the implementation!)

; Ran 100 tests. 0 failures, 0 errors.

(ns philandstuff.test-check-knossos.java-queue
  (:import [java.util.concurrent ConcurrentLinkedQueue]
           [java.util Queue])
  (:refer-clojure :exclude [remove]))

(defn create-queue [] (ConcurrentLinkedQueue.))

(defn add [^Queue q item]
  (.add q item))

(defn remove [^Queue q]
  (.poll q))

; Ran 100 tests. 0 failures, 0 errors.