aboutsummaryrefslogtreecommitdiff
path: root/stdlib/source/test/lux/control/parser/cli.lux
blob: 9e12a51aa3b2353dee1de2c25671011cb80fd785 (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 (.except)
   ["_" test (.only Test)]
   [abstract
    [monad (.only do)]]
   [control
    ["[0]" try]
    ["<>" parser]]
   [data
    ["[0]" text (.open: "[1]#[0]" equivalence)]
    [collection
     ["[0]" list]]]
   [macro
    ["^" pattern]]
   [math
    ["[0]" random]
    [number
     ["n" nat (.open: "[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 (at ! 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)]
        (all _.and
             (_.coverage [/.result /.any]
               (|> (/.result /.any (list expected))
                   (!expect (^.multi {try.#Success actual}
                                     (text#= expected actual)))))
             (_.coverage [/.parse]
               (|> (/.result (/.parse n#decoded) (list expected))
                   (!expect (^.multi {try.#Success actual}
                                     (text#= expected
                                             (n#encoded actual))))))
             (_.coverage [/.this]
               (and (|> (/.result (/.this expected) (list expected))
                        (!expect {try.#Success _}))
                    (|> (/.result (/.this expected) (list dummy))
                        (!expect {try.#Failure _}))))
             (_.coverage [/.somewhere]
               (|> (/.result (|> (/.somewhere (/.this expected))
                                 (<>.before (<>.some /.any)))
                             (list.together (list pre_ignore (list expected) post_ignore)))
                   (!expect {try.#Success _})))
             (_.coverage [/.end]
               (and (|> (/.result /.end (list))
                        (!expect {try.#Success _}))
                    (|> (/.result (<>.not /.end) (list expected))
                        (!expect {try.#Failure _}))))
             (_.coverage [/.named]
               (|> (/.result (/.named dummy /.any) (list dummy expected))
                   (!expect (^.multi {try.#Success actual}
                                     (text#= expected actual)))))
             (_.coverage [/.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 _}))))
             ))))