aboutsummaryrefslogtreecommitdiff
path: root/stdlib/test
diff options
context:
space:
mode:
Diffstat (limited to 'stdlib/test')
-rw-r--r--stdlib/test/test/lux/data/format/json.lux55
-rw-r--r--stdlib/test/test/lux/data/text/lexer.lux162
2 files changed, 105 insertions, 112 deletions
diff --git a/stdlib/test/test/lux/data/format/json.lux b/stdlib/test/test/lux/data/format/json.lux
index b52b72635..88e4603d8 100644
--- a/stdlib/test/test/lux/data/format/json.lux
+++ b/stdlib/test/test/lux/data/format/json.lux
@@ -14,28 +14,28 @@
[number "i/" Number<Int>]
(format ["&" json])
(coll [vector #+ vector]
- [dict]
+ ["d" dict]
[list]))
[macro #+ with-gensyms]
(macro [code]
[syntax #+ syntax:]
[poly #+ derived:])
- ["R" math/random]
+ ["r" math/random]
test)
)
(def: gen-json
- (R;Random &;JSON)
- (R;rec (function [gen-json]
- (do R;Monad<Random>
- [size (:: @ map (n.% +2) R;nat)]
- ($_ R;alt
+ (r;Random &;JSON)
+ (r;rec (function [gen-json]
+ (do r;Monad<Random>
+ [size (:: @ map (n.% +2) r;nat)]
+ ($_ r;alt
(:: @ wrap [])
- R;bool
- (|> R;real (:: @ map (r.* 1_000_000.0)))
- (R;text size)
- (R;vector size gen-json)
- (R;dict text;Hash<Text> size (R;text size) gen-json)
+ r;bool
+ (|> r;real (:: @ map (r.* 1_000_000.0)))
+ (r;text size)
+ (r;vector size gen-json)
+ (r;dict text;Hash<Text> size (r;text size) gen-json)
)))))
(test: "JSON"
@@ -70,24 +70,26 @@
#maybe (Maybe Int)
#list (List Int)
#variant Variant
- #tuple [Int Real Char]})
+ #tuple [Int Real Char]
+ #dict (d;Dict Text Int)})
(def: gen-record
- (R;Random Record)
- (do R;Monad<Random>
- [size (:: @ map (n.% +2) R;nat)
- #let [gen-int (|> R;int (:: @ map (|>. i/abs (i.% 1_000_000))))]]
- ($_ R;seq
+ (r;Random Record)
+ (do r;Monad<Random>
+ [size (:: @ map (n.% +2) r;nat)
+ #let [gen-int (|> r;int (:: @ map (|>. i/abs (i.% 1_000_000))))]]
+ ($_ r;seq
(:: @ wrap [])
- R;bool
+ r;bool
gen-int
- R;real
- R;char
- (R;text size)
- (R;maybe gen-int)
- (R;list size gen-int)
- ($_ R;alt R;bool gen-int R;real)
- ($_ R;seq gen-int R;real R;char)
+ r;real
+ r;char
+ (r;text size)
+ (r;maybe gen-int)
+ (r;list size gen-int)
+ ($_ r;alt r;bool gen-int r;real)
+ ($_ r;seq gen-int r;real r;char)
+ (r;dict text;Hash<Text> size (r;text size) gen-int)
)))
(derived: (&;Codec<JSON,?> Record))
@@ -120,6 +122,7 @@
(and (i.= tL0 tR0)
(r.= tL1 tR1)
(:: char;Eq<Char> = tL2 tR2)))
+ (:: (d;Eq<Dict> i.=) = (get@ #dict recL) (get@ #dict recR))
))))
(test: "Polytypism"
diff --git a/stdlib/test/test/lux/data/text/lexer.lux b/stdlib/test/test/lux/data/text/lexer.lux
index f9b6bdc79..df77f804a 100644
--- a/stdlib/test/test/lux/data/text/lexer.lux
+++ b/stdlib/test/test/lux/data/text/lexer.lux
@@ -3,33 +3,23 @@
(lux (control monad
pipe)
[io]
- (data ["E" result]
+ (data ["R" result]
[text "T/" Eq<Text>]
text/format
["&" text/lexer]
- [char "C/" Eq<Char>]
(coll [list]))
- ["R" math/random])
+ ["r" math/random])
lux/test)
## [Utils]
(def: (should-fail input)
- (All [a] (-> (E;Result a) Bool))
+ (All [a] (-> (R;Result a) Bool))
(case input
(#;Left _) true
_ false))
-(def: (should-passC test input)
- (-> Char (E;Result Char) Bool)
- (case input
- (#;Right output)
- (C/= test output)
-
- _
- false))
-
(def: (should-passT test input)
- (-> Text (E;Result Text) Bool)
+ (-> Text (R;Result Text) Bool)
(case input
(#;Right output)
(T/= test output)
@@ -38,8 +28,8 @@
false))
(def: (should-passL test input)
- (-> (List Char) (E;Result (List Char)) Bool)
- (let [(^open "L/") (list;Eq<List> char;Eq<Char>)]
+ (-> (List Text) (R;Result (List Text)) Bool)
+ (let [(^open "L/") (list;Eq<List> text;Eq<Text>)]
(case input
(#;Right output)
(L/= test output)
@@ -48,15 +38,15 @@
false)))
(def: (should-passE test input)
- (-> (Either Char Char) (E;Result (Either Char Char)) Bool)
+ (-> (Either Text Text) (R;Result (Either Text Text)) Bool)
(case input
(#;Right output)
(case [test output]
[(#;Left test) (#;Left output)]
- (C/= test output)
+ (T/= test output)
[(#;Right test) (#;Right output)]
- (C/= test output)
+ (T/= test output)
_
false)
@@ -79,17 +69,17 @@
))
(test: "Literals"
- [size (|> R;nat (:: @ map (|>. (n.% +100) (n.max +10))))
- pre (R;text size)
- post (|> (R;text size)
- (R;filter (|>. (text;starts-with? pre) not)))]
+ [size (|> r;nat (:: @ map (|>. (n.% +100) (n.max +10))))
+ pre (r;text size)
+ post (|> (r;text size)
+ (r;filter (|>. (text;starts-with? pre) not)))]
($_ seq
(assert "Can find literal text fragments."
(and (|> (&;run (format pre post)
- (&;text pre))
- (case> (#;Right found) (T/= pre found) _ false))
+ (&;this pre))
+ (case> (#;Right []) true _ false))
(|> (&;run post
- (&;text pre))
+ (&;this pre))
(case> (#;Left _) true _ false))))
))
@@ -97,15 +87,15 @@
($_ seq
(assert "Can lex characters."
(and (|> (&;run "YOLO"
- (&;char #"Y"))
- (case> (#;Right #"Y") true _ false))
+ (&;this "Y"))
+ (case> (#;Right []) true _ false))
(|> (&;run "MEME"
- (&;char #"Y"))
+ (&;this "Y"))
(case> (#;Left _) true _ false))))
(assert "Can lex characters ranges."
- (and (should-passC #"Y" (&;run "YOLO"
- (&;char-range #"X" #"Z")))
+ (and (should-passT "Y" (&;run "YOLO"
+ (&;char-range #"X" #"Z")))
(should-fail (&;run "MEME"
(&;char-range #"X" #"Z")))))
))
@@ -113,64 +103,64 @@
(test: "Custom lexers"
($_ seq
(assert "Can lex anything"
- (and (should-passC #"A" (&;run "A"
- &;any))
+ (and (should-passT "A" (&;run "A"
+ &;any))
(should-fail (&;run ""
&;any))))
(assert "Can lex upper-case and &;lower-case letters."
- (and (should-passC #"Y" (&;run "YOLO"
- &;upper))
+ (and (should-passT "Y" (&;run "YOLO"
+ &;upper))
(should-fail (&;run "meme"
&;upper))
- (should-passC #"y" (&;run "yolo"
- &;lower))
+ (should-passT "y" (&;run "yolo"
+ &;lower))
(should-fail (&;run "MEME"
&;lower))))
(assert "Can lex numbers."
- (and (should-passC #"1" (&;run "1"
- &;digit))
+ (and (should-passT "1" (&;run "1"
+ &;digit))
(should-fail (&;run " "
&;digit))
- (should-passC #"7" (&;run "7"
- &;oct-digit))
+ (should-passT "7" (&;run "7"
+ &;oct-digit))
(should-fail (&;run "8"
&;oct-digit))
- (should-passC #"1" (&;run "1"
- &;hex-digit))
- (should-passC #"a" (&;run "a"
- &;hex-digit))
- (should-passC #"A" (&;run "A"
- &;hex-digit))
+ (should-passT "1" (&;run "1"
+ &;hex-digit))
+ (should-passT "a" (&;run "a"
+ &;hex-digit))
+ (should-passT "A" (&;run "A"
+ &;hex-digit))
(should-fail (&;run " "
&;hex-digit))
))
(assert "Can lex alphabetic characters."
- (and (should-passC #"A" (&;run "A"
- &;alpha))
- (should-passC #"a" (&;run "a"
- &;alpha))
+ (and (should-passT "A" (&;run "A"
+ &;alpha))
+ (should-passT "a" (&;run "a"
+ &;alpha))
(should-fail (&;run "1"
&;alpha))))
(assert "Can lex alphanumeric characters."
- (and (should-passC #"A" (&;run "A"
- &;alpha-num))
- (should-passC #"a" (&;run "a"
- &;alpha-num))
- (should-passC #"1" (&;run "1"
- &;alpha-num))
+ (and (should-passT "A" (&;run "A"
+ &;alpha-num))
+ (should-passT "a" (&;run "a"
+ &;alpha-num))
+ (should-passT "1" (&;run "1"
+ &;alpha-num))
(should-fail (&;run " "
&;alpha-num))))
(assert "Can lex white-space."
- (and (should-passC #" " (&;run " "
- &;space))
+ (and (should-passT " " (&;run " "
+ &;space))
(should-fail (&;run "8"
&;space))))
))
@@ -180,48 +170,48 @@
(assert "Can combine lexers sequentially."
(and (|> (&;run "YOLO"
(&;seq &;any &;any))
- (case> (#;Right [#"Y" #"O"]) true
+ (case> (#;Right ["Y" "O"]) true
_ false))
(should-fail (&;run "Y"
(&;seq &;any &;any)))))
(assert "Can combine lexers alternatively."
- (and (should-passE (#;Left #"0") (&;run "0"
+ (and (should-passE (#;Left "0") (&;run "0"
+ (&;alt &;digit &;upper)))
+ (should-passE (#;Right "A") (&;run "A"
(&;alt &;digit &;upper)))
- (should-passE (#;Right #"A") (&;run "A"
- (&;alt &;digit &;upper)))
(should-fail (&;run "a"
(&;alt &;digit &;upper)))))
(assert "Can create the opposite of a lexer."
- (and (should-passC #"a" (&;run "a"
- (&;not (&;alt &;digit &;upper))))
+ (and (should-passT "a" (&;run "a"
+ (&;not (&;alt &;digit &;upper))))
(should-fail (&;run "A"
(&;not (&;alt &;digit &;upper))))))
(assert "Can use either lexer."
- (and (should-passC #"0" (&;run "0"
- (&;either &;digit &;upper)))
- (should-passC #"A" (&;run "A"
- (&;either &;digit &;upper)))
+ (and (should-passT "0" (&;run "0"
+ (&;either &;digit &;upper)))
+ (should-passT "A" (&;run "A"
+ (&;either &;digit &;upper)))
(should-fail (&;run "a"
(&;either &;digit &;upper)))))
(assert "Can select from among a set of characters."
- (and (should-passC #"C" (&;run "C"
- (&;one-of "ABC")))
+ (and (should-passT "C" (&;run "C"
+ (&;one-of "ABC")))
(should-fail (&;run "D"
(&;one-of "ABC")))))
(assert "Can avoid a set of characters."
- (and (should-passC #"D" (&;run "D"
- (&;none-of "ABC")))
+ (and (should-passT "D" (&;run "D"
+ (&;none-of "ABC")))
(should-fail (&;run "C"
(&;none-of "ABC")))))
(assert "Can lex using arbitrary predicates."
- (and (should-passC #"D" (&;run "D"
- (&;satisfies (function [c] true))))
+ (and (should-passT "D" (&;run "D"
+ (&;satisfies (function [c] true))))
(should-fail (&;run "C"
(&;satisfies (function [c] false))))))
@@ -250,7 +240,7 @@
_ false))))
(assert "Can apply a lexer multiple times."
- (and (should-passL (list #"0" #"1" #"2" #"3" #"4" #"5" #"6" #"7" #"8" #"9" #"A" #"B" #"C" #"D" #"E" #"F")
+ (and (should-passL (list "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F")
(&;run "0123456789ABCDEF yolo"
(&;many &;hex-digit)))
(should-fail (&;run "yolo"
@@ -261,43 +251,43 @@
(&;some &;hex-digit)))))
(assert "Can lex exactly N elements."
- (and (should-passL (list #"0" #"1" #"2" #"3" #"4" #"5" #"6" #"7" #"8" #"9" #"A" #"B" #"C" #"D" #"E" #"F")
+ (and (should-passL (list "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F")
(&;run "0123456789ABCDEF yolo"
(&;exactly +16 &;hex-digit)))
- (should-passL (list #"0" #"1" #"2")
+ (should-passL (list "0" "1" "2")
(&;run "0123456789ABCDEF yolo"
(&;exactly +3 &;hex-digit)))
(should-fail (&;run "0123456789ABCDEF yolo"
(&;exactly +17 &;hex-digit)))))
(assert "Can lex at-most N elements."
- (and (should-passL (list #"0" #"1" #"2" #"3" #"4" #"5" #"6" #"7" #"8" #"9" #"A" #"B" #"C" #"D" #"E" #"F")
+ (and (should-passL (list "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F")
(&;run "0123456789ABCDEF yolo"
(&;at-most +16 &;hex-digit)))
- (should-passL (list #"0" #"1" #"2")
+ (should-passL (list "0" "1" "2")
(&;run "0123456789ABCDEF yolo"
(&;at-most +3 &;hex-digit)))
- (should-passL (list #"0" #"1" #"2" #"3" #"4" #"5" #"6" #"7" #"8" #"9" #"A" #"B" #"C" #"D" #"E" #"F")
+ (should-passL (list "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F")
(&;run "0123456789ABCDEF yolo"
(&;at-most +17 &;hex-digit)))))
(assert "Can lex tokens between lower and upper boundaries of quantity."
- (and (should-passL (list #"0" #"1" #"2" #"3" #"4" #"5" #"6" #"7" #"8" #"9" #"A" #"B" #"C" #"D" #"E" #"F")
+ (and (should-passL (list "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F")
(&;run "0123456789ABCDEF yolo"
(&;between +0 +16 &;hex-digit)))
- (should-passL (list #"0" #"1" #"2" #"3" #"4" #"5" #"6" #"7" #"8" #"9" #"A" #"B" #"C" #"D" #"E" #"F")
+ (should-passL (list "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F")
(&;run "0123456789ABCDEF yolo"
(&;between +3 +16 &;hex-digit)))
(should-fail (&;run "0123456789ABCDEF yolo"
(&;between +17 +100 &;hex-digit)))
- (should-passL (list #"0" #"1" #"2" #"3" #"4" #"5" #"6" #"7" #"8" #"9" #"A" #"B" #"C" #"D" #"E" #"F")
+ (should-passL (list "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F")
(&;run "0123456789ABCDEF yolo"
(&;between +15 +20 &;hex-digit)))))
(assert "Can optionally lex a token."
(and (|> (&;run "123abc"
(&;opt &;hex-digit))
- (case> (#;Right (#;Some #"1")) true
+ (case> (#;Right (#;Some "1")) true
_ false))
(|> (&;run "yolo"
(&;opt &;hex-digit))
@@ -305,7 +295,7 @@
_ false))))
(assert "Can take into account separators during lexing."
- (should-passL (list #"0" #"1" #"2" #"3" #"4" #"5" #"6" #"7" #"8" #"9" #"a" #"b" #"c" #"d" #"e" #"f")
+ (should-passL (list "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "a" "b" "c" "d" "e" "f")
(&;run "0 1 2 3 4 5 6 7 8 9 a b c d e f YOLO"
(&;sep-by &;space &;hex-digit))))
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-23 12:40:03 +0000