Fix keyword and symbol tests

Author: Invertisment

clj/test/vim/syntax_test.clj

@@ -2,13 +2,16 @@
 ;;          Joel Holdbrooks <[email protected]>
 
 (ns vim.syntax-test
-  (:require [vim.test :refer [defpredicates defsyntaxtest]]))
+  (:require [vim.test :refer [defpredicates defsyntaxtest def-eq-predicates]]))
 
 ;; defpredicates also register not-equal vars, this is just for clj-kondo
 (declare !number !regexp-escape !regexp-posix-char-class !regexp-quantifier)
 
 (defpredicates number :clojureNumber)
-(defpredicates kw :clojureKeyword)
+(def-eq-predicates kw [:clojureKeywordNsColon :clojureKeyword])
+(def-eq-predicates kwWithNs [:clojureKeywordNsColon :clojureKeyword])
+(def-eq-predicates sym [:clojureSymbolNsColon :clojureSymbol])
+(def-eq-predicates symWithNs [:clojureSymbolNsColon :clojureSymbol])
 (defpredicates character :clojureCharacter)
 (defpredicates regexp :clojureRegexp)
 (defpredicates regexp-delimiter :clojureRegexpDelimiter)
@@ -115,16 +118,38 @@
     ":a" kw
     ":αβγ" kw
     "::a" kw
-    ":a/b" kw
+    ":a/b" kwWithNs
     ":a:b" kw
-    ":a:b/:c:b" kw
-    ":a/b/c/d" kw
-    "::a/b" kw
+    ":a:b/:c:b" kwWithNs
+    ":a/b/c/d" kwWithNs
+    "::a/b" kwWithNs
     "::" !kw
+    "::" !kwWithNs
     ":a:" !kw
+    ":a:" !kwWithNs
     ":a/" !kw
-    ; ":/" !kw ; This is legal, but for simplicity we do not match it
-    ":" !kw]])
+    ":a/" !kwWithNs
+    ":/" !kw       ; This is legal, but for simplicity we do not match it
+    ":/" !kwWithNs ; This is legal, but for simplicity we do not match it
+    ":" !kw
+    ":" !kwWithNs]])
+
+(defsyntaxtest symbols-test
+  ["%s"
+   ["1" !sym
+    "1" !symWithNs
+    "A" sym
+    "a" sym
+    "αβγ" sym
+    "a/b" symWithNs
+    "a:b" sym
+    "a:b/:c:b" symWithNs
+    "a/b/c/d" symWithNs
+    "a:" !sym
+    "a:" !symWithNs
+    "a/" !sym
+    "a/" !symWithNs
+    "/" sym]])
 
 (comment (test #'keywords-test))
 
@@ -403,8 +428,7 @@
     ;; (?>X)              X, as an independent, non-capturing group
     "(?>X)" regexp-mod
 
-    "(?X)" !regexp-mod
-    ]]
+    "(?X)" !regexp-mod]]
   ["#%s"
    [;; Backslashes with character classes
     "\"[\\\\]\"" (partial = [:clojureRegexpDelimiter :clojureRegexpCharClass :clojureRegexpCharClass :clojureRegexpCharClass :clojureRegexpCharClass :clojureRegexpDelimiter])

clj/test/vim/test.clj

@@ -90,21 +90,35 @@
                             ss λs)))
                 contexts)))))
 
-(defmacro defpredicates
+(defmacro defpredicates-general
   "Create two complementary predicate vars, `sym` and `!sym`, which test if
    all members of a passed collection are equal to `kw`"
-  [sym kw]
+  [pred-eq pred-neq sym kw]
   `(do
      (defn ~sym
        ~(str "Returns true if all elements of coll equal " kw)
        {:arglists '~'[coll]}
        [coll#]
-       (every? (partial = ~kw) coll#))
+       (~pred-eq ~kw coll#))
      (defn ~(symbol (str \! sym))
        ~(str "Returns true if any elements of coll do not equal " kw)
        {:arglists '~'[coll]}
        [coll#]
-       (boolean (some (partial not= ~kw) coll#)))))
+       (~pred-neq ~kw coll#))))
+
+(defmacro defpredicates
+  "Create two complementary predicate vars, `sym` and `!sym`, which test if
+   all members of a passed collection are equal to `kw`"
+  [sym kw]
+  (let [pred-eq (fn [expected results] (every? (partial = expected) results))
+        pred-neq (fn [expected results] (boolean (some (partial not= expected) results)))]
+    `(defpredicates-general ~pred-eq ~pred-neq ~sym ~kw)))
+
+(defmacro def-eq-predicates
+  "Create two complementary predicate vars, `sym` and `!sym`, which test if
+   input and result are equal"
+  [sym kw]
+  `(defpredicates-general '= 'not= ~sym ~kw))
 
 (defn benchmark [n file buf & exprs]
   (vim-exec file buf (format "Benchmark(%d, %s)"