aboutsummaryrefslogtreecommitdiff
path: root/stdlib/source/test/lux/data/text/regex.lux
diff options
context:
space:
mode:
Diffstat (limited to 'stdlib/source/test/lux/data/text/regex.lux')
-rw-r--r--stdlib/source/test/lux/data/text/regex.lux386
1 files changed, 193 insertions, 193 deletions
diff --git a/stdlib/source/test/lux/data/text/regex.lux b/stdlib/source/test/lux/data/text/regex.lux
index 58c26d067..a9f5d8cc4 100644
--- a/stdlib/source/test/lux/data/text/regex.lux
+++ b/stdlib/source/test/lux/data/text/regex.lux
@@ -78,120 +78,120 @@
(def: system_character_classes
Test
- ($_ _.and
- (_.test "Can parse anything."
- (should_pass (/.regex ".") "a"))
+ (all _.and
+ (_.test "Can parse anything."
+ (should_pass (/.regex ".") "a"))
- (_.test "Can parse digits."
- (and (should_pass (/.regex "\d") "0")
- (should_fail (/.regex "\d") "m")))
+ (_.test "Can parse digits."
+ (and (should_pass (/.regex "\d") "0")
+ (should_fail (/.regex "\d") "m")))
- (_.test "Can parse non digits."
- (and (should_pass (/.regex "\D") "m")
- (should_fail (/.regex "\D") "0")))
+ (_.test "Can parse non digits."
+ (and (should_pass (/.regex "\D") "m")
+ (should_fail (/.regex "\D") "0")))
- (_.test "Can parse white-space."
- (and (should_pass (/.regex "\s") " ")
- (should_fail (/.regex "\s") "m")))
+ (_.test "Can parse white-space."
+ (and (should_pass (/.regex "\s") " ")
+ (should_fail (/.regex "\s") "m")))
- (_.test "Can parse non white-space."
- (and (should_pass (/.regex "\S") "m")
- (should_fail (/.regex "\S") " ")))
+ (_.test "Can parse non white-space."
+ (and (should_pass (/.regex "\S") "m")
+ (should_fail (/.regex "\S") " ")))
- (_.test "Can parse word characters."
- (and (should_pass (/.regex "\w") "_")
- (should_fail (/.regex "\w") "^")))
+ (_.test "Can parse word characters."
+ (and (should_pass (/.regex "\w") "_")
+ (should_fail (/.regex "\w") "^")))
- (_.test "Can parse non word characters."
- (and (should_pass (/.regex "\W") ".")
- (should_fail (/.regex "\W") "a")))
- ))
+ (_.test "Can parse non word characters."
+ (and (should_pass (/.regex "\W") ".")
+ (should_fail (/.regex "\W") "a")))
+ ))
(def: special_system_character_classes
Test
- ($_ _.and
- (_.test "Lower-case."
- (and (should_pass (/.regex "\p{Lower}") "m")
- (should_fail (/.regex "\p{Lower}") "M")))
- (_.test "Upper-case."
- (and (should_pass (/.regex "\p{Upper}") "M")
- (should_fail (/.regex "\p{Upper}") "m")))
- (_.test "Alphabetic."
- (and (should_pass (/.regex "\p{Alpha}") "M")
- (should_fail (/.regex "\p{Alpha}") "0")))
- (_.test "Numeric digits."
- (and (should_pass (/.regex "\p{Digit}") "1")
- (should_fail (/.regex "\p{Digit}") "n")))
- (_.test "Alphanumeric."
- (and (should_pass (/.regex "\p{Alnum}") "1")
- (should_fail (/.regex "\p{Alnum}") ".")))
- (_.test "Whitespace."
- (and (should_pass (/.regex "\p{Space}") " ")
- (should_fail (/.regex "\p{Space}") ".")))
- (_.test "Hexadecimal."
- (and (should_pass (/.regex "\p{HexDigit}") "a")
- (should_fail (/.regex "\p{HexDigit}") ".")))
- (_.test "Octal."
- (and (should_pass (/.regex "\p{OctDigit}") "6")
- (should_fail (/.regex "\p{OctDigit}") ".")))
- (_.test "Blank."
- (and (should_pass (/.regex "\p{Blank}") text.tab)
- (should_fail (/.regex "\p{Blank}") ".")))
- (_.test "ASCII."
- (and (should_pass (/.regex "\p{ASCII}") text.tab)
- (should_fail (/.regex "\p{ASCII}") (text.of_char (hex "1234")))))
- (_.test "Control characters."
- (and (should_pass (/.regex "\p{Contrl}") (text.of_char (hex "12")))
- (should_fail (/.regex "\p{Contrl}") "a")))
- (_.test "Punctuation."
- (and (should_pass (/.regex "\p{Punct}") "@")
- (should_fail (/.regex "\p{Punct}") "a")))
- (_.test "Graph."
- (and (should_pass (/.regex "\p{Graph}") "@")
- (should_fail (/.regex "\p{Graph}") " ")))
- (_.test "Print."
- (and (should_pass (/.regex "\p{Print}") (text.of_char (hex "20")))
- (should_fail (/.regex "\p{Print}") (text.of_char (hex "1234")))))
- ))
+ (all _.and
+ (_.test "Lower-case."
+ (and (should_pass (/.regex "\p{Lower}") "m")
+ (should_fail (/.regex "\p{Lower}") "M")))
+ (_.test "Upper-case."
+ (and (should_pass (/.regex "\p{Upper}") "M")
+ (should_fail (/.regex "\p{Upper}") "m")))
+ (_.test "Alphabetic."
+ (and (should_pass (/.regex "\p{Alpha}") "M")
+ (should_fail (/.regex "\p{Alpha}") "0")))
+ (_.test "Numeric digits."
+ (and (should_pass (/.regex "\p{Digit}") "1")
+ (should_fail (/.regex "\p{Digit}") "n")))
+ (_.test "Alphanumeric."
+ (and (should_pass (/.regex "\p{Alnum}") "1")
+ (should_fail (/.regex "\p{Alnum}") ".")))
+ (_.test "Whitespace."
+ (and (should_pass (/.regex "\p{Space}") " ")
+ (should_fail (/.regex "\p{Space}") ".")))
+ (_.test "Hexadecimal."
+ (and (should_pass (/.regex "\p{HexDigit}") "a")
+ (should_fail (/.regex "\p{HexDigit}") ".")))
+ (_.test "Octal."
+ (and (should_pass (/.regex "\p{OctDigit}") "6")
+ (should_fail (/.regex "\p{OctDigit}") ".")))
+ (_.test "Blank."
+ (and (should_pass (/.regex "\p{Blank}") text.tab)
+ (should_fail (/.regex "\p{Blank}") ".")))
+ (_.test "ASCII."
+ (and (should_pass (/.regex "\p{ASCII}") text.tab)
+ (should_fail (/.regex "\p{ASCII}") (text.of_char (hex "1234")))))
+ (_.test "Control characters."
+ (and (should_pass (/.regex "\p{Contrl}") (text.of_char (hex "12")))
+ (should_fail (/.regex "\p{Contrl}") "a")))
+ (_.test "Punctuation."
+ (and (should_pass (/.regex "\p{Punct}") "@")
+ (should_fail (/.regex "\p{Punct}") "a")))
+ (_.test "Graph."
+ (and (should_pass (/.regex "\p{Graph}") "@")
+ (should_fail (/.regex "\p{Graph}") " ")))
+ (_.test "Print."
+ (and (should_pass (/.regex "\p{Print}") (text.of_char (hex "20")))
+ (should_fail (/.regex "\p{Print}") (text.of_char (hex "1234")))))
+ ))
(def: custom_character_classes
Test
- ($_ _.and
- (_.test "Can parse using custom character classes."
- (and (should_pass (/.regex "[abc]") "a")
- (should_fail (/.regex "[abc]") "m")))
- (_.test "Can parse using character ranges."
- (and (should_pass (/.regex "[a-z]") "a")
- (should_pass (/.regex "[a-z]") "m")
- (should_pass (/.regex "[a-z]") "z")))
- (_.test "Can combine character ranges."
- (and (should_pass (/.regex "[a-zA-Z]") "a")
- (should_pass (/.regex "[a-zA-Z]") "m")
- (should_pass (/.regex "[a-zA-Z]") "z")
- (should_pass (/.regex "[a-zA-Z]") "A")
- (should_pass (/.regex "[a-zA-Z]") "M")
- (should_pass (/.regex "[a-zA-Z]") "Z")))
- (_.test "Can negate custom character classes."
- (and (should_fail (/.regex "[^abc]") "a")
- (should_pass (/.regex "[^abc]") "m")))
- (_.test "Can negate character ranges.."
- (and (should_fail (/.regex "[^a-z]") "a")
- (should_pass (/.regex "[^a-z]") "0")))
- (_.test "Can parse negate combinations of character ranges."
- (and (should_fail (/.regex "[^a-zA-Z]") "a")
- (should_pass (/.regex "[^a-zA-Z]") "0")))
- (_.test "Can make custom character classes more specific."
- (and (let [RE (/.regex "[a-z&&[def]]")]
- (and (should_fail RE "a")
- (should_pass RE "d")))
- (let [RE (/.regex "[a-z&&[^bc]]")]
- (and (should_pass RE "a")
- (should_fail RE "b")))
- (let [RE (/.regex "[a-z&&[^m-p]]")]
- (and (should_pass RE "a")
- (should_fail RE "m")
- (should_fail RE "p")))))
- ))
+ (all _.and
+ (_.test "Can parse using custom character classes."
+ (and (should_pass (/.regex "[abc]") "a")
+ (should_fail (/.regex "[abc]") "m")))
+ (_.test "Can parse using character ranges."
+ (and (should_pass (/.regex "[a-z]") "a")
+ (should_pass (/.regex "[a-z]") "m")
+ (should_pass (/.regex "[a-z]") "z")))
+ (_.test "Can combine character ranges."
+ (and (should_pass (/.regex "[a-zA-Z]") "a")
+ (should_pass (/.regex "[a-zA-Z]") "m")
+ (should_pass (/.regex "[a-zA-Z]") "z")
+ (should_pass (/.regex "[a-zA-Z]") "A")
+ (should_pass (/.regex "[a-zA-Z]") "M")
+ (should_pass (/.regex "[a-zA-Z]") "Z")))
+ (_.test "Can negate custom character classes."
+ (and (should_fail (/.regex "[^abc]") "a")
+ (should_pass (/.regex "[^abc]") "m")))
+ (_.test "Can negate character ranges.."
+ (and (should_fail (/.regex "[^a-z]") "a")
+ (should_pass (/.regex "[^a-z]") "0")))
+ (_.test "Can parse negate combinations of character ranges."
+ (and (should_fail (/.regex "[^a-zA-Z]") "a")
+ (should_pass (/.regex "[^a-zA-Z]") "0")))
+ (_.test "Can make custom character classes more specific."
+ (and (let [RE (/.regex "[a-z&&[def]]")]
+ (and (should_fail RE "a")
+ (should_pass RE "d")))
+ (let [RE (/.regex "[a-z&&[^bc]]")]
+ (and (should_pass RE "a")
+ (should_fail RE "b")))
+ (let [RE (/.regex "[a-z&&[^m-p]]")]
+ (and (should_pass RE "a")
+ (should_fail RE "m")
+ (should_fail RE "p")))))
+ ))
(def: references
Test
@@ -203,78 +203,78 @@
(def: fuzzy_quantifiers
Test
- ($_ _.and
- (_.test "Can sequentially combine patterns."
- (text_should_pass "aa" (/.regex "aa") "aa"))
+ (all _.and
+ (_.test "Can sequentially combine patterns."
+ (text_should_pass "aa" (/.regex "aa") "aa"))
- (_.test "Can match patterns optionally."
- (and (text_should_pass "a" (/.regex "a?") "a")
- (text_should_pass "" (/.regex "a?") "")))
+ (_.test "Can match patterns optionally."
+ (and (text_should_pass "a" (/.regex "a?") "a")
+ (text_should_pass "" (/.regex "a?") "")))
- (_.test "Can match a pattern 0 or more times."
- (and (text_should_pass "aaa" (/.regex "a*") "aaa")
- (text_should_pass "" (/.regex "a*") "")))
+ (_.test "Can match a pattern 0 or more times."
+ (and (text_should_pass "aaa" (/.regex "a*") "aaa")
+ (text_should_pass "" (/.regex "a*") "")))
- (_.test "Can match a pattern 1 or more times."
- (and (text_should_pass "aaa" (/.regex "a+") "aaa")
- (text_should_pass "a" (/.regex "a+") "a")
- (should_fail (/.regex "a+") "")))
- ))
+ (_.test "Can match a pattern 1 or more times."
+ (and (text_should_pass "aaa" (/.regex "a+") "aaa")
+ (text_should_pass "a" (/.regex "a+") "a")
+ (should_fail (/.regex "a+") "")))
+ ))
(def: crisp_quantifiers
Test
- ($_ _.and
- (_.test "Can match a pattern N times."
- (and (text_should_pass "aa" (/.regex "a{2}") "aa")
- (text_should_pass "a" (/.regex "a{1}") "a")
- (should_fail (/.regex "a{3}") "aa")))
-
- (_.test "Can match a pattern at-least N times."
- (and (text_should_pass "aa" (/.regex "a{1,}") "aa")
- (text_should_pass "aa" (/.regex "a{2,}") "aa")
- (should_fail (/.regex "a{3,}") "aa")))
-
- (_.test "Can match a pattern at-most N times."
- (and (text_should_pass "aa" (/.regex "a{,2}") "aa")
- (text_should_pass "aa" (/.regex "a{,3}") "aa")))
-
- (_.test "Can match a pattern between N and M times."
- (and (text_should_pass "a" (/.regex "a{1,2}") "a")
- (text_should_pass "aa" (/.regex "a{1,2}") "aa")))
- ))
+ (all _.and
+ (_.test "Can match a pattern N times."
+ (and (text_should_pass "aa" (/.regex "a{2}") "aa")
+ (text_should_pass "a" (/.regex "a{1}") "a")
+ (should_fail (/.regex "a{3}") "aa")))
+
+ (_.test "Can match a pattern at-least N times."
+ (and (text_should_pass "aa" (/.regex "a{1,}") "aa")
+ (text_should_pass "aa" (/.regex "a{2,}") "aa")
+ (should_fail (/.regex "a{3,}") "aa")))
+
+ (_.test "Can match a pattern at-most N times."
+ (and (text_should_pass "aa" (/.regex "a{,2}") "aa")
+ (text_should_pass "aa" (/.regex "a{,3}") "aa")))
+
+ (_.test "Can match a pattern between N and M times."
+ (and (text_should_pass "a" (/.regex "a{1,2}") "a")
+ (text_should_pass "aa" (/.regex "a{1,2}") "aa")))
+ ))
(def: groups
Test
- ($_ _.and
- (_.test "Can extract groups of sub-matches specified in a pattern."
- (and (should_check ["abc" "b"] (/.regex "a(.)c") "abc")
- (should_check ["abbbbbc" "bbbbb"] (/.regex "a(b+)c") "abbbbbc")
- (should_check ["809-345-6789" "809" "345" "6789"] (/.regex "(\d{3})-(\d{3})-(\d{4})") "809-345-6789")
- (should_check ["809-345-6789" "809" "6789"] (/.regex "(\d{3})-(?:\d{3})-(\d{4})") "809-345-6789")
- (should_check ["809-809-6789" "809" "6789"] (/.regex "(\d{3})-\0-(\d{4})") "809-809-6789")
- (should_check ["809-809-6789" "809" "6789"] (/.regex "(?<code>\d{3})-\k<code>-(\d{4})") "809-809-6789")
- (should_check ["809-809-6789-6789" "809" "6789"] (/.regex "(?<code>\d{3})-\k<code>-(\d{4})-\0") "809-809-6789-6789")))
-
- (_.test "Can specify groups within groups."
- (should_check ["809-345-6789" "809" ["345-6789" "345" "6789"]] (/.regex "(\d{3})-((\d{3})-(\d{4}))") "809-345-6789"))
- ))
+ (all _.and
+ (_.test "Can extract groups of sub-matches specified in a pattern."
+ (and (should_check ["abc" "b"] (/.regex "a(.)c") "abc")
+ (should_check ["abbbbbc" "bbbbb"] (/.regex "a(b+)c") "abbbbbc")
+ (should_check ["809-345-6789" "809" "345" "6789"] (/.regex "(\d{3})-(\d{3})-(\d{4})") "809-345-6789")
+ (should_check ["809-345-6789" "809" "6789"] (/.regex "(\d{3})-(?:\d{3})-(\d{4})") "809-345-6789")
+ (should_check ["809-809-6789" "809" "6789"] (/.regex "(\d{3})-\0-(\d{4})") "809-809-6789")
+ (should_check ["809-809-6789" "809" "6789"] (/.regex "(?<code>\d{3})-\k<code>-(\d{4})") "809-809-6789")
+ (should_check ["809-809-6789-6789" "809" "6789"] (/.regex "(?<code>\d{3})-\k<code>-(\d{4})-\0") "809-809-6789-6789")))
+
+ (_.test "Can specify groups within groups."
+ (should_check ["809-345-6789" "809" ["345-6789" "345" "6789"]] (/.regex "(\d{3})-((\d{3})-(\d{4}))") "809-345-6789"))
+ ))
(def: alternation
Test
- ($_ _.and
- (_.test "Can specify alternative patterns."
- (and (should_check ["a" {0 #0 []}] (/.regex "a|b") "a")
- (should_check ["b" {0 #1 []}] (/.regex "a|b") "b")
- (should_fail (/.regex "a|b") "c")))
- (_.test "Can have groups within alternations."
- (and (should_check ["abc" {0 #0 ["b" "c"]}] (/.regex "a(.)(.)|b(.)(.)") "abc")
- (should_check ["bcd" {0 #1 ["c" "d"]}] (/.regex "a(.)(.)|b(.)(.)") "bcd")
- (should_fail (/.regex "a(.)(.)|b(.)(.)") "cde")
-
- (should_check ["123-456-7890" {0 #0 ["123" "456-7890" "456" "7890"]}]
- (/.regex "(\d{3})-((\d{3})-(\d{4}))|b(.)d")
- "123-456-7890")))
- ))
+ (all _.and
+ (_.test "Can specify alternative patterns."
+ (and (should_check ["a" {0 #0 []}] (/.regex "a|b") "a")
+ (should_check ["b" {0 #1 []}] (/.regex "a|b") "b")
+ (should_fail (/.regex "a|b") "c")))
+ (_.test "Can have groups within alternations."
+ (and (should_check ["abc" {0 #0 ["b" "c"]}] (/.regex "a(.)(.)|b(.)(.)") "abc")
+ (should_check ["bcd" {0 #1 ["c" "d"]}] (/.regex "a(.)(.)|b(.)(.)") "bcd")
+ (should_fail (/.regex "a(.)(.)|b(.)(.)") "cde")
+
+ (should_check ["123-456-7890" {0 #0 ["123" "456-7890" "456" "7890"]}]
+ (/.regex "(\d{3})-((\d{3})-(\d{4}))|b(.)d")
+ "123-456-7890")))
+ ))
(syntax: (expands? [form <code>.any])
(function (_ lux)
@@ -288,34 +288,34 @@
(def: .public test
Test
(<| (_.covering /._)
- ($_ _.and
- (_.for [/.regex]
- ($_ _.and
- ..basics
- ..system_character_classes
- ..special_system_character_classes
- ..custom_character_classes
- ..references
- ..fuzzy_quantifiers
- ..crisp_quantifiers
- ..groups
- ..alternation
- ))
- (do random.monad
- [sample1 (random.unicode 3)
- sample2 (random.unicode 3)
- sample3 (random.unicode 4)]
- (_.cover [/.pattern]
- (case (format sample1 "-" sample2 "-" sample3)
- (/.pattern "(.{3})-(.{3})-(.{4})"
- [_ match1 match2 match3])
- (and (text#= sample1 match1)
- (text#= sample2 match2)
- (text#= sample3 match3))
-
- _
- false)))
- (_.cover [/.incorrect_quantification]
- (and (expands? (/.regex "a{1,2}"))
- (not (expands? (/.regex "a{2,1}")))))
- )))
+ (all _.and
+ (_.for [/.regex]
+ (all _.and
+ ..basics
+ ..system_character_classes
+ ..special_system_character_classes
+ ..custom_character_classes
+ ..references
+ ..fuzzy_quantifiers
+ ..crisp_quantifiers
+ ..groups
+ ..alternation
+ ))
+ (do random.monad
+ [sample1 (random.unicode 3)
+ sample2 (random.unicode 3)
+ sample3 (random.unicode 4)]
+ (_.cover [/.pattern]
+ (case (format sample1 "-" sample2 "-" sample3)
+ (/.pattern "(.{3})-(.{3})-(.{4})"
+ [_ match1 match2 match3])
+ (and (text#= sample1 match1)
+ (text#= sample2 match2)
+ (text#= sample3 match3))
+
+ _
+ false)))
+ (_.cover [/.incorrect_quantification]
+ (and (expands? (/.regex "a{1,2}"))
+ (not (expands? (/.regex "a{2,1}")))))
+ )))