aboutsummaryrefslogtreecommitdiff
path: root/stdlib/source/test/aedifex/parser.lux
blob: 0a13acb326d12c4afc3743f8679fdb8b6f7cad67 (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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
(.module:
  [lux #*
   ["_" test (#+ Test)]
   [abstract
    [monad (#+ do)]
    [hash (#+ Hash)]]
   [control
    [pipe (#+ case>)]
    ["." try]
    [parser
     ["<c>" code]]]
   [data
    ["." text]
    [collection
     ["." set (#+ Set)]
     ["." dictionary (#+ Dictionary)]
     ["." list ("#\." functor)]]]
   [math
    ["." random (#+ Random)]
    [number
     ["n" nat]]]
   [macro
    ["." code]]]
  [//
   ["@." profile]]
  {#program
   ["." /
    ["/#" // #_
     ["#" profile]
     ["#." project (#+ Project)]
     ["#." artifact (#+ Artifact)]
     ["#." dependency (#+ Dependency)]
     ["#." format]]]})

(def: name
  (Random //.Name)
  (random.ascii/alpha 1))

(def: (list_of random)
  (All [a] (-> (Random a) (Random (List a))))
  (do {! random.monad}
    [size (\ ! map (n.% 5) random.nat)]
    (random.list size random)))

(def: (dictionary_of key_hash key_random value_random)
  (All [k v] (-> (Hash k) (Random k) (Random v) (Random (Dictionary k v))))
  (\ random.functor map
     (dictionary.from_list key_hash)
     (..list_of (random.and key_random value_random))))

(def: random
  (Random Project)
  (..dictionary_of text.hash ..name @profile.random))

(def: with_default_sources
  (-> //.Profile //.Profile)
  (update@ #//.sources
           (: (-> (Set //.Source) (Set //.Source))
              (function (_ sources)
                (if (set.empty? sources)
                  (set.from_list text.hash (list //.default_source))
                  sources)))))

(def: single_profile
  Test
  (do random.monad
    [expected @profile.random]
    (_.test "Single profile."
            (|> expected
                //format.profile
                list
                (<c>.run /.project)
                (case> (#try.Success actual)
                       (|> expected
                           ..with_default_sources
                           (//project.project //.default)
                           (\ //project.equivalence = actual))
                       
                       (#try.Failure error)
                       false)))))

(def: (with_empty_profile project)
  (-> Project Project)
  (if (dictionary.empty? project)
    (//project.project //.default (\ //.monoid identity))
    project))

(def: multiple_profiles
  Test
  (do random.monad
    [expected ..random]
    (_.test "Multiple profiles."
            (|> expected
                //format.project
                list
                (<c>.run /.project)
                (case> (#try.Success actual)
                       (|> expected
                           ..with_empty_profile
                           dictionary.entries
                           (list\map (function (_ [name profile])
                                       [name (..with_default_sources profile)]))
                           (dictionary.from_list text.hash)
                           (\ //project.equivalence = actual))
                       
                       (#try.Failure error)
                       false)))))

(def: #export test
  Test
  (<| (_.covering /._)
      (_.covering //format._)
      (_.for [/.project
              //format.Format //format.profile //format.project]
             ($_ _.and
                 ..single_profile
                 ..multiple_profiles
                 ))))