code.test.compile — xyz.zcaudate/code.test 4.0.5

*compile-desc* clj

*compile-meta* clj

+arrows+ clj

=> clj

arrow? clj

(arrow? obj)

checks if form is an arrow

create-fact clj

(create-fact meta body)

creates a fact given meta and body

fact clj macro

(fact desc & body)

top level macro for test definitions

fact-allowed? clj

fact-eval clj

(fact-eval {:keys [ns id] :as fpkg})

creates the forms in eval mode

fact-eval-current clj

(fact-eval-current id meta)

helper function for eval

fact-id clj

(fact-id {:keys [id refer] :as m} desc)

creates an id from fact data

(fact-id {} "hello there") => 'test-hello-there

fact-prepare-core clj

(fact-prepare-core desc? body meta)

prepares fact for a core form

fact-prepare-derived clj

(fact-prepare-derived fsource title {:keys [id] :as meta})

prepares fact for a derived form

fact-prepare-link clj

(fact-prepare-link fsource title {:keys [id line column type]})

prepares fact for a linked form

fact-prepare-meta clj

(fact-prepare-meta id meta desc body)

parses and converts fact to symbols

(fact-prepare-meta 'test-hello {} "hello" '(1 => 1))

fact-skip? clj

(fact-skip? x)

checks if form should be skipped

(fact-skip? '(fact:component)) => true

fact-thunk clj

(fact-thunk {:keys [full] :as fpkg})

creates a thunk form

fact:all clj macro

(fact:all)

(fact:all ns)

returns all facts in namespace

fact:bench clj macro

(fact:bench)

(fact:bench params & inputs)

runs a small micro bench for the current fact

fact:bench-install clj

(fact:bench-install params inputs meta)

installer for fact:bench macro

fact:check clj macro

(fact:check inputs)

runs a check over a range of values

fact:check-install clj

(fact:check-install inputs meta)

installer for fact:check macro

fact:compile clj

(fact:compile fpkg)

(fact:compile fpkg global)

recompiles fact with a different global

fact:derive clj macro

(fact:derive desc)

runs a form derived from a previous test

fact:derive-install clj

(fact:derive-install desc meta)

installer for fact:derive macro

fact:exec clj macro

(fact:exec)

(fact:exec id)

(fact:exec ns id)

runs main hook for fact form

fact:get clj macro

(fact:get)

(fact:get id)

(fact:get ns id)

gets elements of the current fact

fact:let clj macro

(fact:let args)

runs a form that has binding substitutions

fact:let-install clj

(fact:let-install args meta)

installer for fact:let macro

fact:list clj

(fact:list)

lists all facts in namespace

fact:missing clj

(fact:missing)

(fact:missing ns)

returns all missing facts for a given namespace

fact:purge clj

(fact:purge)

purges all facts in namespace

fact:remove clj macro

(fact:remove)

removes the current fact

fact:rerun clj

(fact:rerun facts)

(fact:rerun facts filters)

(fact:rerun facts filters global)

reruns all facts along with filter and compile options

fact:setup clj macro

(fact:setup)

runs setup hook for current fact

fact:setup? clj macro

(fact:setup?)

checks if setup hook has been ran

fact:symbol clj macro

(fact:symbol)

gets the current fact symbol

fact:table clj macro

(fact:table header & inputs)

runs a form with tabular value substitutions

fact:table-install clj

(fact:table-install header inputs meta)

installer for fact:table macro

fact:teardown clj macro

(fact:teardown)

runs teardown hook for current fact

fact:template clj macro

(fact:template desc & body)

adds a template to the file

install-fact clj

(install-fact meta body)

installs the current fact

split clj

(split body)

(split [x y z & more :as arr] out)

creates a sequence of pairs from a loose sequence (split '[(def a 1) (+ a 3) => 5]) (contains-in '[{:type :form, :meta {:line 8, :column 12}, :form '(def a 1)} {:type :test-equal, :meta {:line 9, :column 12}, :input {:form '(+ a 3)}, :output {:form 5}}])

strip clj

(strip body)

(strip [x y z & more :as arr] out)

removes all checks in the function

(strip '[(def a 1) (+ a 3) => 5]) => '[(def a 1) (+ a 3)]