ruby-wisp-source 0.7.0

data/vendor/test/reader.wisp

@@ -0,0 +1,228 @@
+(import [symbol quote deref name keyword
+         unquote meta dictionary pr-str] "../src/ast")
+(import [dictionary nil? str =] "../src/runtime")
+(import [read-from-string] "../src/reader")
+(import [list] "../src/sequence")
+
+(def read-string read-from-string)
+
+(print "name fn")
+
+(assert (identical? (name (read-string ":foo")) "foo")
+        "name of :foo is foo")
+(assert (identical? (name (read-string ":foo/bar")) "bar")
+        "name of :foo/bar is bar")
+(assert (identical? (name (read-string "foo")) "foo")
+        "name of foo is foo")
+(assert (identical? (name (read-string "foo/bar")) "bar")
+        "name of foo/bar is bar")
+(assert (identical? (name (read-string "\"foo\"")) "foo")
+        "name of \"foo\" is foo")
+
+(print "read simple list")
+
+(assert (= (read-string "(foo bar)")
+           '(foo bar))
+        "(foo bar) -> (foo bar)")
+
+(print "read comma is a whitespace")
+
+(assert (= (read-string "(foo, bar)")
+           '(foo bar))
+        "(foo, bar) -> (foo bar)")
+
+(print "read numbers")
+
+(assert (= (read-string "(+ 1 2 0)")
+           '(+ 1 2 0))
+        "(+ 1 2 0) -> (+ 1 2 0)")
+
+(print "read keywords")
+(assert (= (read-string "(foo :bar)")
+           '(foo :bar))
+        "(foo :bar) -> (foo :bar)")
+
+(print "read quoted list")
+(assert (= (read-string "'(foo bar)")
+           '(quote (foo bar)))
+        "'(foo bar) -> (quote (foo bar))")
+
+(print "read vector")
+(assert (= (read-string "(foo [bar :baz 2])")
+           '(foo [bar :baz 2]))
+        "(foo [bar :baz 2]) -> (foo [bar :baz 2])")
+
+(print "read special symbols")
+(assert (= (read-string "(true false nil)")
+           '(true false nil))
+        "(true false nil) -> (true false nil)")
+
+(print "read chars")
+(assert (= (read-string "(\\x \\y \\z)")
+           '("x" "y" "z"))
+        "(\\x \\y \\z) -> (\"x\" \"y\" \"z\")")
+
+(print "read strings")
+(assert (= (read-string "(\"hello world\" \"hi \\n there\")")
+           '("hello world" "hi \n there"))
+        "strings are read precisely")
+
+(print "read deref")
+(assert (= (read-string "(+ @foo 2)")
+           '(+ (deref foo) 2))
+        "(+ @foo 2) -> (+ (deref foo) 2)")
+
+(print "read unquote")
+
+(assert (= (read-string "(~foo ~@bar ~(baz))")
+           '((unquote foo)
+             (unquote-splicing bar)
+             (unquote (baz))))
+        "(~foo ~@bar ~(baz)) -> ((unquote foo) (unquote-splicing bar) (unquote (baz))")
+
+
+(assert (= (read-string "(~@(foo bar))")
+           '((unquote-splicing (foo bar))))
+        "(~@(foo bar)) -> ((unquote-splicing (foo bar)))")
+
+(print "read function")
+
+(assert (= (read-string "(defn List
+                        \"List type\"
+                        [head tail]
+                        (set! this.head head)
+                        (set! this.tail tail)
+                        (set! this.length (+ (.-length tail) 1))
+                        this)")
+           '(defn List
+              "List type"
+               [head tail]
+               (set! this.head head)
+               (set! this.tail tail)
+               (set! this.length (+ (.-length tail) 1))
+               this))
+        "function read correctly")
+
+(print "lambda syntax")
+
+(assert (= (read-string "#(apply sum %&)")
+           '(fn [& %&] (apply sum %&))))
+
+(assert (= (read-string "(map #(inc %) [1 2 3])")
+           '(map (fn [%1] (inc %1)) [1 2 3])))
+
+(assert (= (read-string "#(+ %1 % %& %5 %2)")
+           '(fn [%1 %2 %3 %4 %5 & %&] (+ %1 %1 %& %5 %2))))
+
+(print "read comments")
+(assert (= (read-string "; comment
+                         (program)")
+           '(program))
+        "comments are ignored")
+
+(assert (= (read-string "(hello ;; world\n you)")
+           '(hello you)))
+
+(print "clojurescript")
+
+(assert (= 1 (reader/read-string "1")))
+(assert (= 2 (reader/read-string "#_nope 2")))
+(assert (= -1 (reader/read-string "-1")))
+(assert (= -1.5 (reader/read-string "-1.5")))
+(assert (= [3 4] (reader/read-string "[3 4]")))
+(assert (= "foo" (reader/read-string "\"foo\"")))
+(assert (= ':hello (reader/read-string ":hello")))
+(assert (= 'goodbye (reader/read-string "goodbye")))
+(assert (= '#{1 2 3} (reader/read-string "#{1 2 3}")))
+(assert (= '(7 8 9) (reader/read-string "(7 8 9)")))
+(assert (= '(deref foo) (reader/read-string "@foo")))
+(assert (= '(quote bar) (reader/read-string "'bar")))
+
+;; TODO: Implement `namespace` fn and proper namespace support ?
+;;(assert (= 'foo/bar (reader/read-string "foo/bar")))
+;;(assert (= ':foo/bar (reader/read-string ":foo/bar")))
+(assert (= \a (reader/read-string "\\a")))
+(assert (= 'String
+            (:tag (meta (reader/read-string "^String {:a 1}")))))
+;; TODO: In quoted sets both keys and values should remain quoted
+;; (assert (= [:a 'b '#{c {:d [:e :f :g]}}]
+;;            (reader/read-string "[:a b #{c {:d [:e :f :g]}}]")))
+(assert (= nil (reader/read-string "nil")))
+(assert (= true (reader/read-string "true")))
+(assert (= false (reader/read-string "false")))
+(assert (= "string" (reader/read-string "\"string\"")))
+(assert (= "escape chars \t \r \n \\ \" \b \f"
+           (reader/read-string "\"escape chars \\t \\r \\n \\\\ \\\" \\b \\f\"")))
+
+(print "tagged literals")
+
+
+;; queue literals
+(assert (= '(PersistentQueue. [])
+            (reader/read-string "#queue []")))
+(assert (= '(PersistentQueue. [1])
+            (reader/read-string "#queue [1]")))
+(assert (= '(PersistentQueue. [1 2])
+            (reader/read-string "#queue [1 2]")))
+
+;; uuid literals
+(assert (= '(UUID. "550e8400-e29b-41d4-a716-446655440000")
+           (reader/read-string "#uuid \"550e8400-e29b-41d4-a716-446655440000\"")))
+
+(print "read unicode")
+
+(let [assets
+      ["اختبار" ; arabic
+       "ทดสอบ" ; thai
+       "こんにちは" ; japanese hiragana
+       "你好" ; chinese traditional
+       "אַ גוט יאָר" ; yiddish
+       "cześć" ; polish
+       "привет" ; russian
+       "გამარჯობა" ; georgian
+
+       ;; RTL languages skipped below because tricky to insert
+       ;; ' and : at the "start"
+
+       'ทดสอบ
+       'こんにちは
+       '你好
+       'cześć
+       'привет
+       'გამარჯობა
+
+       :ทดสอบ
+       :こんにちは
+       :你好
+       :cześć
+       :привет
+       :გამარჯობა
+
+       ;compound data
+       {:привет :ru "你好" :cn}
+       ]]
+  (.for-each assets
+             (fn [unicode]
+              (let [input (pr-str unicode)
+                    read (read-string input)]
+                (assert (= unicode read)
+                        (str "Failed to read-string \"" unicode "\" from: " input))))))
+
+(print "unicode error cases")
+
+; unicode error cases
+(let [unicode-errors
+      ["\"abc \\ua\"" ; truncated
+       "\"abc \\x0z ...etc\"" ; incorrect code
+       "\"abc \\u0g00 ..etc\"" ; incorrect code
+       ]]
+  (.for-each
+   unicode-errors
+   (fn [unicode-error]
+     (assert
+      (= :threw
+         (try
+           (reader/read-string unicode-error)
+           :failed-to-throw
+           (catch e :threw)))
+      (str "Failed to throw reader error for: " unicode-error)))))

data/vendor/test/runtime.wisp

@@ -0,0 +1,180 @@
+(import [dictionary? vector? subs str
+        and or
+         = == > >= < <= + - / *] "../src/runtime")
+(import [list concat] "../src/sequence")
+(import [symbol] "../src/ast")
+
+
+(print "test dictionary?")
+
+(assert (not (dictionary? 2)) "2 is not dictionary")
+(assert (not (dictionary? [])) "[] is not dictionary")
+(assert (not (dictionary? '())) "() is not dictionary")
+(assert (dictionary? {}) "{} is dictionary")
+
+(print "test vector?")
+
+(assert (not (vector? 2)) "2 is not vector")
+(assert (not (vector? {})) "{} is not vector")
+(assert (not (vector? '())) "() is not vector")
+(assert (vector? []) "[] is vector")
+
+(assert (=
+          '(1 2 3 4 5)
+          `(1 ~@'(2 3) 4 ~@'(5))))
+
+(print "subs")
+
+(assert (= "lojure" (subs "Clojure" 1)))
+(assert (= "lo" (subs "Clojure" 1 3)))
+
+(print "special functions")
+
+(assert (apply = [1]))
+(assert (apply = [1 1]))
+(assert (not (apply = [1 2])))
+(assert (apply = [1 1 1]))
+(assert (not (apply = [1 2 3])))
+(assert (apply = [1 1 1 1 1 1]))
+(assert (not (apply = [1 1 1 1 2 1])))
+
+(assert (apply == [1]))
+(assert (apply == [1 1]))
+(assert (not (apply == [1 2])))
+(assert (apply == [1 1 1]))
+(assert (not (apply == [1 2 3])))
+(assert (apply == [1 1 1 1 1 1]))
+(assert (not (apply == [1 1 1 1 2 1])))
+
+(assert (apply > [1]))
+(assert (apply > [2 1]))
+(assert (not (apply > [1 2])))
+(assert (not (apply > [1 1])))
+(assert (apply > [3 2 1]))
+(assert (not (apply > [3 2 4])))
+(assert (not (apply > [3 2 2])))
+(assert (apply > [5 4 3 2 1 0]))
+(assert (not (apply > [5 4 3 2 2 1])))
+(assert (not (apply > [5 4 3 2 3 1])))
+
+(assert (apply >= [1]))
+(assert (apply >= [2 1]))
+(assert (apply >= [2 2]))
+(assert (not (apply >= [1 2])))
+(assert (apply >= [3 2 1]))
+(assert (apply >= [3 2 2]))
+(assert (not (apply >= [3 2 4])))
+(assert (apply >= [5 4 3 2 2 1 0]))
+(assert (not (apply >= [5 4 3 2 0 1])))
+
+(assert (apply < [1]))
+(assert (apply < [1 2]))
+(assert (not (apply < [2 1])))
+(assert (not (apply < [2 2])))
+(assert (apply < [1 2 3]))
+(assert (not (apply < [3 2 4])))
+(assert (not (apply < [3 4 4])))
+(assert (apply < [0 1 2 3 4 5]))
+(assert (not (apply < [0 1 2 3 4 4])))
+(assert (not (apply < [0 1 2 1 4 5])))
+
+(assert (apply <= [1]))
+(assert (apply <= [1 2]))
+(assert (apply <= [2 2]))
+(assert (not (apply <= [2 1])))
+(assert (apply <= [1 2 3]))
+(assert (apply <= [1 2 2]))
+(assert (not (apply <= [4 5 3])))
+(assert (apply <= [0 1 2 3 4 5]))
+(assert (apply <= [0 1 2 3 4 4]))
+(assert (not (apply <= [0 1 2 1 4 5])))
+
+(assert (= 0 (apply + [])))
+(assert (= 1 (apply + [1])))
+(assert (= 3 (apply + [1 2])))
+(assert (= 6 (apply + [1 2 3])))
+(assert (= 21 (apply + [1 2 3 4 5 6])))
+
+(assert (= -1 (apply - [1])))
+(assert (= 3 (apply - [5 2])))
+(assert (= 5 (apply - [10 2 3])))
+(assert (= 9 (apply - [30 1 2 3 4 5 6])))
+
+(assert (= 1 (apply * [])))
+(assert (= 5 (apply * [5])))
+(assert (= 4 (apply * [2 2])))
+(assert (= 6 (apply * [1 2 3])))
+(assert (= 720 (apply * [1 2 3 4 5 6])))
+
+(assert (= 1 (apply / [1])))
+(assert (= 1/2 (apply / [2])))
+(assert (= 5/2 (apply / [5 2])))
+(assert (= 3 (apply / [6 2])))
+(assert (= 5/3 (apply / [10 2 3])))
+(assert (= 1/24 (apply / [30 1 2 3 4 5 6])))
+
+(assert (= true (apply and [])))
+(assert (= 1 (apply and [1])))
+(assert (= 2 (apply and [1 2])))
+(assert (= 2 (apply and [5 2])))
+(assert (= false (apply and [6 false 2])))
+(assert (= nil (apply and [6 4 nil 2])))
+(assert (= 3 (apply and [10 2 3])))
+(assert (= 6 (apply and [30 1 2 3 4 5 6])))
+(assert (= false (apply and [30 1 2 false 3 4 5 6])))
+(assert (= 17 (apply and [30 1 2 3 4 5 6 30 1 2 3 4 5 6 17])))
+
+(assert (= nil (apply or [])))
+(assert (= 1 (apply or [nil 1])))
+(assert (= 1 (apply or [1 nil 2])))
+(assert (= 5 (apply or [5 2])))
+(assert (= 2 (apply or [nil false 2])))
+(assert (= false (apply or [nil nil nil nil nil nil nil nil nil false])))
+(assert (= 17 (apply or [nil nil nil nil nil nil nil nil nil nil nil nil nil 17 18])))
+
+(print "test =")
+
+(assert (apply = []))
+(assert (apply = [1 1]))
+(assert (not (apply = [1 2])))
+(assert (not (apply = [1 "1"])))
+(assert (not (apply = [1 :1])))
+(assert (not (apply = ["b" 'b])))
+(assert (apply = [[] []]))
+(assert (apply = [[1] [1]]))
+(assert (apply = [[1 2] [1 2]]))
+(assert (not (apply = [[1 2] [2 1]])))
+(assert (not (apply = [[1 2] [1 2 3]])))
+(assert (apply = [[1 2 [3 [4 5]]] [1 2 [3 [4 5]]]]))
+(assert (apply = [[1 2 [3 [4 5]]] [1 2 [3 [4 5]]] [1 2 [3 [4 5]]]]))
+(assert (not (apply = [[1 2 [3 [4 5]]] [1 2 [3 [4 5]]] [1 2 [3 [4 4]]]])))
+(assert (apply = [#"foo" #"foo"]))
+(assert (not (apply = [#"(?i)foo" #"foo"])))
+(assert (not (apply = [#"(?i)foo" #"(?m)foo"])))
+(assert (apply = [#"(?i)foo" #"(?i)foo"]))
+(assert (apply = [#"(?mi)foo" #"(?im)foo"]))
+(assert (not (apply = [#"(?mi)foo" #"(?im)foo" "?(i)foo"])))
+(assert (not (apply = [#"foo" "foo"])))
+(assert (not (apply = [#"foo" 1])))
+(assert (not (apply = ["foo" 1])))
+(assert (not (apply = ["foo" ["foo"]])))
+(assert (not (apply = ["foo" ["f" "o" "o"]])))
+(assert (apply = ['() '()]))
+(assert (apply = ['(foo bar) '(foo bar)]))
+(assert (not (apply = ['(foo bar) '(bar foo)])))
+(assert (not (apply = ['(foo bar) '(foo bar baz)])))
+(assert (not (apply = ['(foo bar) '(foo :bar)])))
+(assert (not (apply = ['(foo bar) '(foo "bar")])))
+(assert (apply = [{} {}]))
+(assert (apply = [{:x 1} {:x 1}]))
+(assert (not (apply = [{:x 1} {:x 2}])))
+(assert (not (apply = [{:x 1} {:x 1 :y 2}])))
+(assert (not (apply = [{:x 2 :y 1} {:x 1 :y 2}])))
+(assert (apply = [{:x 1 :y 1} {:y 1 :x 1}]))
+(assert (not (apply = [{:x 1 :y 2} {:y 1 :x 2}])))
+(assert (apply = [{:x 1 :y [2 [3 {:z 4}]]} {:x 1 :y [2 [3 {:z 4}]]}]))
+(assert (not (apply = [{:x 1 :y [2 [3 {:z 4}]]} {:x 1 :y [2 [3 {:z 4}]]} {}])))
+(assert (apply = [{:x 1 :y [2 [3 {:z 4}]]}
+                  {:x 1 :y [2 [3 {:z 4}]]}
+                  {:x 1 :y [2 [3 {:z 4}]]}
+                  {:x 1 :y [2 [3 {:z 4}]]}]))