(.using
 [library
  [lux "*"
   ["_" test {"+" Test}]
   ["@" target]
   ["[0]" meta]
   [data
    ["[0]" text ("[1]#[0]" equivalence)
     ["%" format {"+" format}]]
    [collection
     ["[0]" list ("[1]#[0]" mix)]]]
   [macro
    ["[0]" code]]
   [math
    ["[0]" random ("[1]#[0]" functor)]
    [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 [/.randoms]
                       (with_expansions [<amount> (/.random code.nat
                                                            (random#each (|>> (n.% 10) ++) random.nat))
                                         l/* (/.randoms code.nat (random.list <amount> random.nat))]
                         (and (n.= <amount> (list.size (list l/*)))
                              (n.= (list#mix n.+ 0 (list l/*))
                                   ($_ n.+ l/*)))))
              (_.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)))
              (_.cover [/.literals]
                       (with_expansions [l/0 (/.random_nat)
                                         l/1 (/.random_nat)
                                         l/2 (/.random_nat)
                                         l/* (/.literals code.nat (list l/0 l/1 l/2))]
                         (n.= ($_ n.+ l/0 l/1 l/2)
                              ($_ n.+ l/*))))
              ))))