stdlib/source/test/lux/static.lux


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

(.module:
  [library
   [lux "*"
    ["_" test {"+" Test}]
    ["@" target]
    ["[0]" meta]
    [data
     ["[0]" text ("[1]#[0]" equivalence)
      ["%" format {"+" format}]]]
    [macro
     ["[0]" code]]
    [math
     ["[0]" random]
     [number
      ["n" nat]
      ["i" int]
      ["r" rev]
      ["f" frac]]]]]
  [\\library
   ["[0]" /]])

(def: .public test
  Test
  (<| (_.covering /._)
      (for [@.old (_.test "PLACEHOLDER" true)]
           (_.for [meta.eval]
                  (`` ($_ _.and
                          (~~ (template [<static> <random> <=> <+> <tag>]
                                [(_.cover [<static> <random>]
                                          (with_expansions [<left> (<random>)
                                                            <right> (<random>)
                                                            <l+r> (<static> (<+> <left> <right>))]
                                            (case (' <l+r>)
                                              [_ {<tag> l+r}]
                                              (<=> l+r (<+> <left> <right>))

                                              _
                                              false)))]

                                [/.nat /.random_nat n.= n.+ .#Nat]
                                [/.int /.random_int i.= i.+ .#Int]
                                [/.rev /.random_rev r.= r.+ .#Rev]
                                ))
                          (_.cover [/.frac /.random_frac]
                                   (with_expansions [<left> (/.random_frac)
                                                     <right> (/.random_frac)
                                                     <l+r> (/.frac (f.+ <left> <right>))]
                                     (case (' <l+r>)
                                       [_ {.#Frac l+r}]
                                       (or (f.= l+r (f.+ <left> <right>))
                                           (and (f.not_a_number? l+r)
                                                (f.not_a_number? (f.+ <left> <right>))
                                                (or (f.not_a_number? <left>)
                                                    (f.not_a_number? <right>))))

                                       _
                                       false)))
                          (_.cover [/.text /.random]
                                   (with_expansions [<left> (/.random code.text (random.ascii/alpha_num 1))
                                                     <right> (/.random code.text (random.ascii/alpha_num 1))
                                                     <l+r> (/.text (format <left> <right>))]
                                     (case (' <l+r>)
                                       [_ {.#Text l+r}]
                                       (text#= l+r (format <left> <right>))

                                       _
                                       false)))
                          (_.cover [/.literal]
                                   (with_expansions [<left> (/.random code.text (random.ascii/alpha_num 1))
                                                     <right> (/.random code.text (random.ascii/alpha_num 1))
                                                     <l+r> (/.literal code.text (format <left> <right>))]
                                     (case (' <l+r>)
                                       [_ {.#Text l+r}]
                                       (text#= l+r (format <left> <right>))

                                       _
                                       false)))
                          ))))))