       (let [a true]
         (expect a :to-be true))))
 
-(describe "The toBe matcher compares with ==="
-  (it "and has a positive case"
+(describe "expect"
+  (it "has a positive case"
       (expect true :to-be true))
-  (it "and can have a negative case"
+  (it "and a negative case"
       (dont-expect false :to-be true)))
 
 (describe "Included matchers:"
-  (it "The 'toBe' matcher compares with ==="
+  (it "The :to-be matcher compares with ==="
       (let [a 12
             b a]
         (expect a :to-be b)
         (dont-expect a :to-be nil)))
 
-  (describe "The 'toEqual' matcher"
+  (describe "The :to-equal matcher"
     (it "works for simple literals and variables"
         (let [a 12]
           (expect a :to-equal 12)))

        (expect a :to-be-falsy)
        (dont-expect foo :to-be-falsy)))

  (it "The 'toContain' matcher is for finding an item in an Array"
      (let [a (array "foo" "bar" "baz")]
        (expect a :to-contain "bar")
        (dont-expect a :to-contain "quux")))

  (it "The 'toBeLessThan' matcher is for mathematical comparisons"
      (let [pi 3.1415926
            e 2.78]
        (expect e :to-be-less-than pi)

              bar (js-obj "a" 12 "b" 34)]
          (expect foo :to-equal bar))))

  (it "The :to-match matcher is for regular expressions"
      (let [message "foo bar baz"]
        (expect message :to-match (re-pattern "bar"))
        (expect message :to-match "bar")
        (dont-expect message :to-match (re-pattern "quux"))))

  (it "The :to-be-defined matcher compares against 'undefined'"
      (let [a (js-obj "foo" "foo")]
        (expect (aget a "foo") :to-be-defined)
        (expect (aget a "bar") :to-be-undefined)))

  (it "The :to-be-nil matcher compares against null"
      (let [a nil
            foo "foo"]
        (expect nil :to-be-nil)
