(.using [library [lux "*" ["_" test {"+" Test}] [abstract [monad {"+" do}]] [control ["[0]" io] ["[0]" try] ["<>" parser ["<[0]>" code] ["<[0]>" cli]]] [data ["[0]" text] [collection ["[0]" list]]] [macro [syntax {"+" syntax:}]] [math ["[0]" random]]]] [\\library ["[0]" /]]) (syntax: (actual_program [actual_program (<|

.form
                                             (<>.after (.this_text "lux def program"))
                                             .any)])
  (in (list actual_program)))

(def: .public test
  Test
  (<| (_.covering /._)
      (do random.monad
        [inputs (random.list 5 (random.ascii/upper 5))]
        (_.cover [/.program:]
                 (let [(open "list#[0]") (list.equivalence text.equivalence)]
                   (and (with_expansions [ (/.program: all_arguments
                                                      (io.io all_arguments))]
                          (let [outcome ((is (-> (List Text) (io.IO Any))
                                             (..actual_program ))
                                         inputs)]
                            (same? (is Any inputs)
                                   (io.run! outcome))))
                        (with_expansions [ (/.program: [arg/0 .any
                                                                 arg/1 .any
                                                                 arg/2 .any
                                                                 arg/3 .any
                                                                 arg/4 .any]
                                                      (io.io (list arg/4 arg/3 arg/2 arg/1 arg/0)))]
                          (let [outcome ((is (-> (List Text) (io.IO Any))
                                             (..actual_program ))
                                         inputs)]
                            (list#= (list.reversed inputs)
                                    (as (List Text) (io.run! outcome)))))
                        (with_expansions [ (/.program: [all_arguments (<>.many .any)]
                                                      (io.io all_arguments))]
                          (let [outcome ((is (-> (List Text) (io.IO Any))
                                             (..actual_program ))
                                         inputs)]
                            (list#= inputs
                                    (as (List Text) (io.run! outcome)))))
                        (with_expansions [ (/.program: [arg/0 .any
                                                                 arg/1 .any
                                                                 arg/2 .any
                                                                 arg/3 .any]
                                                      (io.io []))]
                          (case (try ((is (-> (List Text) (io.IO Any))
                                          (..actual_program ))
                                      inputs))
                            {try.#Success _}
                            false
                            
                            {try.#Failure _}
                            true))))))))