     (it "fails with an error message"
       (should=
         (str "Expected :bar not to be an instance of " (-to-s (type :bar)) " but was (using isa?)")
-        (failure-message (should-not-be-a (type :foo) :bar))))
-
-    )
+        (failure-message (should-not-be-a (type :foo) :bar)))))
 
   (context "should<"
     (it "degenerate cases"

            [speclj.run.standard :refer [run-specs]]))

(describe "Should Assertions: "
  (it "should tests truthy"
    (should-pass! (should true))
    (should-fail! (should false)))

  (it "should-not tests falsy"
    (should-fail! (should-not true))
    (should-pass! (should-not false)))

  (it "should failure message is nice"
    (should= "Expected truthy but was: false" (failure-message (should false)))
    (should= "Expected truthy but was: nil" (failure-message (should nil))))

  (it "should failure message is nice"
    (should= "Expected falsy but was: true" (failure-message (should-not true)))
    (should= "Expected falsy but was: 1" (failure-message (should-not 1))))

  (it "should= tests equality"
    (should-pass! (should= 1 1))
    (should-pass! (should= "hello" "hello"))
    (should-fail! (should= 1 2))
    (should-fail! (should= "hello" "goodbye")))

  (it "should-be tests functionality"
    (should-pass! (should-be empty? []))
    (should-fail! (should-be empty? [1 2 3]))
    (should= "Expected [1 2 3] to satisfy: empty?" (failure-message (should-be empty? [1 2 (+ 1 2)])))
    (should= "Expected [1 2 3] to satisfy: (comp zero? first)" (failure-message (should-be (comp zero? first) [1 2 (+ 1 2)]))))

  (it "should-not-be tests complementary functionality"
    (should-pass! (should-not-be empty? [1 2 3]))
    (should-fail! (should-not-be empty? []))
    (should= "Expected 1 not to satisfy: pos?" (failure-message (should-not-be pos? 1)))
    (should= "Expected 1 not to satisfy: (comp pos? inc)" (failure-message (should-not-be (comp pos? inc) 1))))

  (it "should= checks equality of doubles within a delta"
    (should-pass! (should= 1.0 1.0 0.1))
    (should-pass! (should= 1.0 1.09 0.1))
    (should-pass! (should= 1.0 0.91 0.1))
    (should-fail! (should= 1.0 1.2 0.1))
    (should-pass! (should= 3.141592 3.141592 0.000001))
    (should-pass! (should= 3.141592 3.141593 0.000001))
    (should-fail! (should= 3.141592 3.141594 0.000001)))

  (it "should= failure message is nice"
    (should= (str "Expected: 1" endl "     got: 2 (using =)") (failure-message (should= 1 2))))

  (it "nil is printed as 'nil' instead of blank"
    (should= (str "Expected: 1" endl "     got: nil (using =)") (failure-message (should= 1 nil))))

  (it "should= failure message with delta is nice"
    (should= (str "Expected: 1" endl "     got: 2 (using delta: 0.1)") (failure-message (should= 1 2 0.1))))

  (it "prints lazy seqs nicely"
    (should= (str "Expected: (1 2 3)" endl "     got: (3 2 1) (using =)")
             (failure-message (should= '(1 2 3) (concat '(3) '(2 1))))))

  (it "should_not= tests inequality"
    (should-pass! (should-not= 1 2))
    (should-fail! (should-not= 1 1)))

  (it "should_not= failure message is nice"
    (should=
      (str "Expected: 1" endl "not to =: 1")
      (failure-message (should-not= 1 1))))

  (it "should-be-same tests identity"
    (should-pass! (should-be-same "foo" "foo"))
    (should-pass! (should-be-same 1 1))
    (should-fail! (should-be-same [] ()))
    #?(:clj
       (should-fail! (should-be-same 1 1.0)))
    )

  (it "should-be-same failure message is nice"
    (should= (str "         Expected: 1" endl "to be the same as: 2 (using identical?)")
             (failure-message (should-be-same 1 2))))

  (it "should-not-be-same tests identity"
    (should-fail! (should-not-be-same "foo" "foo"))
    (should-fail! (should-not-be-same 1 1))
    (should-pass! (should-not-be-same [] ()))

    #?(:clj
       (should-pass! (should-not-be-same 1 1.0)))
    )

  (it "should-not-be-same failure message is nice"
    (should= (str "             Expected: 1" endl "not to be the same as: 1 (using identical?)")
             (failure-message (should-not-be-same 1 1))))

  (it "should-be-nil checks for equality with nil"
    (should-pass! (should-be-nil nil))
    (should-fail! (should-be-nil true))
    (should-fail! (should-be-nil false)))

  (context "should=="


    (it "fails with an error message"
      (should=
        (str "Expected 1 to be an instance of: " (-to-s (type :foo)) endl "           but was an instance of: " (-to-s (type 1)) " (using isa?)")
        (failure-message (should-be-a (type :foo) 1)))))

  (context "should-not-be-a"

