aboutsummaryrefslogtreecommitdiff
path: root/stdlib/source/test/lux/control/parser/cli.lux
blob: 812b23586d6ad0843d0225e968f9256d03f6649c (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
(.using
 [library
  [lux "*"
   ["_" test {"+" Test}]
   [abstract
    [monad {"+" do}]]
   [control
    ["[0]" try]
    ["<>" parser]]
   [data
    ["[0]" text ("[1]#[0]" equivalence)]
    [collection
     ["[0]" list]]]
   [macro
    ["^" pattern]]
   [math
    ["[0]" random]
    [number
     ["n" nat ("[1]#[0]" decimal)]]]]]
 [\\library
  ["[0]" /]])

(template: (!expect <pattern> <value>)
  [(case <value>
     <pattern>
     true
     
     _
     false)])

(def: .public test
  Test
  (<| (_.covering /._)
      (_.for [/.Parser])
      (do [! random.monad]
        [expected (# ! each n#encoded random.nat)
         .let [random_dummy (random.only (|>> (text#= expected) not)
                                         (random.unicode 5))]
         dummy random_dummy
         short (random.unicode 1)
         long (random.unicode 2)
         pre_ignore (random.list 5 random_dummy)
         post_ignore (random.list 5 random_dummy)]
        ($_ _.and
            (_.cover [/.result /.any]
                     (|> (/.result /.any (list expected))
                         (!expect (^.multi {try.#Success actual}
                                           (text#= expected actual)))))
            (_.cover [/.parse]
                     (|> (/.result (/.parse n#decoded) (list expected))
                         (!expect (^.multi {try.#Success actual}
                                           (text#= expected
                                                   (n#encoded actual))))))
            (_.cover [/.this]
                     (and (|> (/.result (/.this expected) (list expected))
                              (!expect {try.#Success _}))
                          (|> (/.result (/.this expected) (list dummy))
                              (!expect {try.#Failure _}))))
            (_.cover [/.somewhere]
                     (|> (/.result (|> (/.somewhere (/.this expected))
                                       (<>.before (<>.some /.any)))
                                   (list.together (list pre_ignore (list expected) post_ignore)))
                         (!expect {try.#Success _})))
            (_.cover [/.end]
                     (and (|> (/.result /.end (list))
                              (!expect {try.#Success _}))
                          (|> (/.result (<>.not /.end) (list expected))
                              (!expect {try.#Failure _}))))
            (_.cover [/.named]
                     (|> (/.result (/.named dummy /.any) (list dummy expected))
                         (!expect (^.multi {try.#Success actual}
                                           (text#= expected actual)))))
            (_.cover [/.parameter]
                     (and (|> (/.result (/.parameter [short long] /.any)
                                        (list short expected))
                              (!expect (^.multi {try.#Success actual}
                                                (text#= expected actual))))
                          (|> (/.result (/.parameter [short long] /.any)
                                        (list long expected))
                              (!expect (^.multi {try.#Success actual}
                                                (text#= expected actual))))
                          (|> (/.result (/.parameter [short long] /.any)
                                        (list dummy expected))
                              (!expect {try.#Failure _}))))
            ))))