aboutsummaryrefslogtreecommitdiff
path: root/stdlib/source/test/lux/control/parser/cli.lux
blob: fb1f485c02e26f7bb3b122d1a088e7c7ee846e02 (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
(.module:
  [library
   [lux #*
    ["_" test (#+ Test)]
    [abstract
     [monad (#+ do)]]
    [control
     ["." try]
     ["<>" parser]]
    [data
     ["." text ("#\." equivalence)]
     [collection
      ["." list]]]
    [math
     ["." random]
     [number
      ["n" nat ("#\." decimal)]]]]]
  [\\library
   ["." /]])

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

(def: .public test
  Test
  (<| (_.covering /._)
      (_.for [/.Parser])
      (do {! random.monad}
        [expected (\ ! map n\encode 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\decode) (list expected))
                         (!expect (^multi (#try.Success actual)
                                          (text\= expected
                                                  (n\encode 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.joined (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 _)))))
            ))))