Add tests for >=

test/clojure/core_test/gt_eq.cljc

@@ -0,0 +1,128 @@
+(ns clojure.core-test.gt-eq
+  (:require [clojure.test :as t :refer [are deftest is testing]]
+            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer) [when-var-exists] :as p]))
+
+(when-var-exists >=
+  (deftest test->=
+    (testing "arity 1"
+      ;; Doesn't matter what the argument is, `>=` return `true` for
+      ;; one argument.
+      (is (>= 1))
+      (is (>= 0))
+      (is (>= -1))
+      ;; Doesn't check whether arg is a number
+      (is (>= "abc"))
+      (is (>= :foo))
+      (is (>= nil)))
+
+    (testing "arity 2"
+      (are [expected x y] (= expected (>= x y))
+        false 0 1
+        false -1 0
+        false 0N 1N
+        false -1N 0N
+        false 0.0 1.0
+        false -1.0 0.0
+        false 0.0M 1.0M
+        false -1.0M 0.0M
+        false ##-Inf -1
+        false 1 ##Inf
+        false 1 ##NaN                   ; Anything compared with ##NaN is false
+        false ##NaN 1
+
+        true 1 0
+        true 0 -1
+        true 1N 0N
+        true 0N -1N
+        true 1.0 0.0
+        true 0.0 -1.0
+        true 1.0M 0.0M
+        true 0.0M -1.0M
+        true -1 ##-Inf
+        true ##Inf 1
+
+        true 0 0
+        true  1 1
+        true  -1 -1
+        true  ##Inf ##Inf
+        true  ##-Inf ##-Inf
+        false ##NaN ##NaN               ; ##NaN is never equal, even to itself
+
+        ;; Mixing numeric types should't matter
+        true 1.0 0
+        true 0 -1.0
+        true 1.0M 0N
+        true 0.0M -1N)
+
+      #?(:cljs nil
+         :default
+         (testing "Rationals"
+           (are [expected x y] (= expected (>= x y))
+             true 1/2 1/16
+             true -1/16 -1/2
+             true 0.5 1/16
+             true -1/16 -0.5
+             false 1/16 1/2
+             false 1/16 0.5
+             false -1/2 -1/16
+             false -0.5 -1/16
+             true 1/2 1/2
+             true 1/3 1/3
+             true -1/2 -1/2
+             true -1/3 -1/3))))
+
+    (testing "arity 3 and more"
+      (are [expected x y z] (= expected (>= x y z))
+        true 2 1 0
+        true 0 -1 -2
+        true 1 0 -1
+        false 2 0 1
+        false 0 2 1
+        false -1 -2 0
+        false -1 0 -2
+        true 1 0 0
+        true 1 1 0
+        false 0 0 1
+        false 0 1 1
+        true ##Inf 0 ##-Inf
+        false ##-Inf 0 ##Inf)
+      (is (= true (apply >= (reverse (range 10)))))
+      (is (= true (apply >= 10 (reverse (range 10)))))
+      (is (= false (apply >= -1 (reverse (range 10))))))
+
+    (testing "negative tests"
+      ;; `<=` only compares numbers, except in ClojureScript (really
+      ;; JavaScript under the hood) where comparisons are just a bit
+      ;; of a mess.
+      #?@(:cljs
+          [(is (= true (>= 1 nil)))
+           (is (= false (>= nil 1)))
+           (is (= true (>= 2 1 nil)))
+           (is (= false (>= nil 2 1)))
+           (is (= true (>= "2" "1")))
+           (is (= false (>= "bar" "foo")))
+           (is (= false (>= :bar :foo)))]
+          :cljr
+          [(is (p/thrown? (>= 1 nil)))
+           (is (p/thrown? (>= nil 1)))
+           (is (p/thrown? (>= 2 1 nil)))
+           (is (p/thrown? (>= nil 2 1)))
+           (is (= true (>= "2" "1")))
+           (is (p/thrown? (>= "bar" "foo")))
+           (is (p/thrown? (>= :bar :foo)))]
+          :lpy
+          [(is (p/thrown? (>= 1 nil)))
+           (is (p/thrown? (>= nil 1)))
+           (is (p/thrown? (>= 2 1 nil)))
+           (is (p/thrown? (>= nil 2 1)))
+           (is (= true (>= "2" "1")))
+           (is (= false (>= "bar" "foo")))
+           (is (= false (>= :bar :foo)))]
+          :default
+          [(is (p/thrown? (>= 1 nil)))
+           (is (p/thrown? (>= nil 1)))
+           (is (p/thrown? (>= 2 1 nil)))
+           (is (p/thrown? (>= nil 2 1)))
+           (is (p/thrown? (>= "2" "1")))
+           (is (p/thrown? (>= "bar" "foo")))
+           (is (p/thrown? (>= :bar :foo)))]))))