expectations — expectations 2.1.10

*prune-stacktrace* clj/s

*report-counters* clj/s

*test-meta* clj/s

*test-name* clj/s

*test-var* clj/s

->failure-message clj/s

(->failure-message {:keys [raw ref-data result expected-message actual-message
                           message list show-raw]})

->vars clj

(->vars ns)

add-watch-every-iref-for-updates clj/s

(add-watch-every-iref-for-updates iref-vars)

ansi clj/s

(ansi code)

ansi-colors clj/s

approximately clj/s

(approximately v)

(approximately v d)

Given a value and an optional delta (default 0.001), return a predicate that expects its argument to be within that delta of the given value.

by-kind clj/s

(by-kind vars)

color clj/s

(color code & s)

colorize-choice clj/s

(colorize-choice)

colorize-filename clj/s

(colorize-filename s)

colorize-raw clj/s

(colorize-raw s)

colorize-results clj/s

(colorize-results pred s)

colorize-warn clj/s

(colorize-warn s)

compare-expr clj/s multimethod

context clj macro

(context [sym-kw val & contexts :as args] & forms)

create-context clj/s

(create-context in-context-vars work)

CustomPred clj/s≠ protocol

message clj/s

(message e a str-e str-a)

expected-message clj/s

(expected-message e a str-e str-a)

expect-fn clj/s

(expect-fn e a)

actual-message clj/s

(actual-message e a str-e str-a)

disable-run-on-shutdown clj/s

(disable-run-on-shutdown)

doexpect clj macro

(doexpect e a)

execute-vars clj/s

(execute-vars vars)

expanding clj macro

(expanding n)

expect clj macro

(expect a)

(expect e a)

expect-focused clj macro

(expect-focused a)

(expect-focused e a)

expectation-finished clj/s

(expectation-finished a-var)

fail clj/s

(fail test-name test-meta msg)

find-failures clj/s

(find-failures the-seq)

find-successes clj/s

(find-successes the-seq)

finished clj/s

(finished test-name test-meta)

freeze-time clj macro

(freeze-time time & forms)

from-each clj macro

(from-each seq-exprs body-expr)

Functionally cljs

functionally clj/s

(functionally expected-fn actual-fn)

(functionally expected-fn actual-fn difference-fn)

Given a pair of functions, return a custom predicate that checks that they return the same result when applied to a value. May optionally accept a 'difference' function that should accept the result of each function and return a string explaininhg how they actually differ. For explaining strings, you could use expectations/strings-difference.

ignored-fns clj/s

(ignored-fns {:keys [className fileName]})

in clj/s

(in n)

inc-report-counter clj/s

(inc-report-counter name)

initial-report-counters clj/s

localize clj/s multimethod

more clj macro

(more & expects)

more-> clj macro

(more-> & expect-pairs)

more-of clj macro

(more-of let-sexp & expect-pairs)

no-op clj/s

(no-op & _)

ns-finished clj/s

(ns-finished a-ns)

pp-str clj/s

(pp-str e)

pruned-stack-trace clj/s

(pruned-stack-trace t)

raw-str clj/s

(raw-str [e a])

redef-state clj macro

(redef-state namespaces & forms)

reminder clj/s

remove-watch-every-iref-for-updates clj/s

(remove-watch-every-iref-for-updates iref-vars)

report clj/s multimethod

run-all-tests clj

(run-all-tests)

(run-all-tests re)

run-tests clj

(run-tests namespaces)

run-tests-in-vars clj/s

(run-tests-in-vars vars-by-kind)

run-tests-on-shutdown clj/s

show-raw-choice clj/s

(show-raw-choice)

side-effects clj macro

(side-effects fn-vec & forms)

started clj/s

(started test-name test-meta)

string-join clj/s

(string-join s coll)

strings-difference clj/s

(strings-difference e a)

summary clj/s

(summary msg)

test-file clj/s

(test-file {:keys [file line]})

test-name clj/s

(test-name {:keys [line ns]})

test-var clj/s

(test-var v)

test-vars clj/s

(test-vars vars-by-kind ignored-expectations)

var-kind clj/s

(var-kind v)

warn-on-iref-updates clj/s

(warn-on-iref-updates)

warn-on-iref-updates-boolean clj/s