Carp/test/result.carp

(load "Test.carp")

(use-all Test Result)

(deftest test
  (assert-true test
               (success? &(the (Result Int (Ref String)) (Success 1)))
               "success? works with Success"
  )
  (assert-false test
                (success? &(the (Result Int (Ref String)) (Error "error")))
                "success? works with Error"
  )
  (assert-true test
               (error? &(the (Result Int (Ref String)) (Error "error")))
               "error? works with Error"
  )
  (assert-false test
                (error? &(the (Result Int (Ref String)) (Success 1)))
                "error? works with Success"
  )
  (assert-equal test
                &(Success 1)
                &(apply (Success 0) Int.inc Int.dec)
                "apply works with Success"
  )
  (assert-equal test
                &(Error -1)
                &(apply (Error 0) Int.inc Int.dec)
                "apply works with Error"
  )
  (assert-true test
               (error? &(map (Error "hi") Int.inc))
               "map works with Error"
  )
  (assert-equal test
                &(Success 2)
                &(map (the (Result Int (Ref String)) (Success 1)) Int.inc)
                "map works with Success"
  )
  (assert-true test
               (error? &(and-then (Error "hi") (fn [x] (Success (Int.inc x)))))
               "and-then works with Error"
  )
  (assert-equal test
                &(Success 2)
                &(and-then (the (Result Int (Ref String)) (Success 1))
                           (fn [x] (Success (Int.inc x))))
                "and-then works with Success"
  )
  (assert-equal test
                2
                (unwrap-or-zero (the (Result Int (Ref String)) (Success 2)))
                "unwrap-or-zero works with Success"
  )
  (assert-equal test
                0
                (unwrap-or-zero (Error "error"))
                "unwrap-or-zero works with Error"
  )
  (assert-equal test
                &(Error 5)
                &(or-else (the (Result Int (Ref String)) (Error "error"))
                          (fn [x] (Error (String.length x))))
                "or-else works with Error"
  )
  (assert-equal test
                &(Success 1)
                &(or-else (Success 1) (fn [x] (Error (String.length x))))
                "or-else works with Success"
  )
  (assert-equal test
                5
                (unwrap-or-else (the (Result Int (Ref String)) (Error "error"))
                                String.length)
                "unwrap-or-else works with Error"
  )
  (assert-equal test
                1
                (unwrap-or-else (Success 1) String.length)
                "unwrap-or-else works with Success"
  )
  (assert-equal test
                1
                (unsafe-from-success (the (Result Int (Ref String)) (Success 1)))
                "unsafe-from-success works with Success"
  )
  (assert-equal test
                1
                (from-success (the (Result Int (Ref String)) (Success 1)) 0)
                "from-success works with Success"
  )
  (assert-equal test
                0
                (from-success (Error "error") 0)
                "from-success works with Error"
  )
  (assert-equal test
                "error"
                &(unsafe-from-error (the (Result Int String) (Error @"error")))
                "unsafe-from-Error works with Error"
  )
  (assert-equal test
                "error"
                &(from-error (the (Result Int String) (Error @"error"))
                             @"success")
                "from-error works with Error"
  )
  (assert-equal test
                "success"
                &(from-error (Success 1) @"success")
                "from-error works with Success"
  )
  (assert-equal test
                &(Maybe.Just 1)
                &(to-maybe (the (Result Int (Ref String)) (Success 1)))
                "to-maybe works with Success"
  )
  (assert-equal test
                &(Maybe.Nothing)
                &(to-maybe (the (Result Int (Ref String)) (Error "error")))
                "to-maybe works with Error"
  )
)