aboutsummaryrefslogtreecommitdiff
path: root/stdlib/source/test/lux/data/collection/dictionary/plist.lux
blob: 83b733a7c93d501f7f0106bb14179ac3fdefcb49 (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
(.using
 [library
  [lux (.full)
   ["_" test (.only Test)]
   [abstract
    [monad (.only do)]
    [\\specification
     ["$[0]" equivalence]
     ["$[0]" monoid]]]
   [control
    ["[0]" maybe ("[1]#[0]" monad)]]
   [data
    ["[0]" bit ("[1]#[0]" equivalence)]
    ["[0]" text]
    [collection
     ["[0]" set]
     ["[0]" list]]]
   [math
    ["[0]" random (.only Random)]
    [number
     ["n" nat]]]]]
 [\\library
  ["[0]" /]])

(def: .public (random size gen_key gen_value)
  (All (_ v)
    (-> Nat (Random Text) (Random v) (Random (/.PList v))))
  (do random.monad
    [keys (random.set text.hash size gen_key)
     values (random.list size gen_value)]
    (in (list.zipped_2 (set.list keys) values))))

(def: .public test
  Test
  (<| (_.covering /._)
      (_.for [/.PList])
      (do [! random.monad]
        [.let [gen_key (random.alphabetic 10)]
         size (# ! each (n.% 100) random.nat)
         sample (..random size gen_key random.nat)

         .let [keys (|> sample /.keys (set.of_list text.hash))]
         extra_key (random.only (|>> (set.member? keys) not)
                                gen_key)
         extra_value random.nat
         shift random.nat]
        (all _.and
             (_.for [/.equivalence]
                    ($equivalence.spec (/.equivalence n.equivalence)
                                       (..random size gen_key random.nat)))
             (_.for [/.monoid]
                    ($monoid.spec (/.equivalence n.equivalence)
                                  /.monoid
                                  (..random 10 (random.lower_case 1) random.nat)))
             
             (_.coverage [/.size]
               (n.= size (/.size sample)))
             (_.coverage [/.empty?]
               (bit#= (n.= 0 (/.size sample))
                      (/.empty? sample)))
             (_.coverage [/.empty]
               (/.empty? /.empty))
             (_.coverage [/.keys /.values]
               (# (/.equivalence n.equivalence) =
                  sample
                  (list.zipped_2 (/.keys sample)
                                 (/.values sample))))
             (_.coverage [/.contains?]
               (and (list.every? (function (_ key)
                                   (/.contains? key sample))
                                 (/.keys sample))
                    (not (/.contains? extra_key sample))))
             (_.coverage [/.has]
               (let [sample+ (/.has extra_key extra_value sample)]
                 (and (not (/.contains? extra_key sample))
                      (/.contains? extra_key sample+)
                      (n.= (++ (/.size sample))
                           (/.size sample+)))))
             (_.coverage [/.value]
               (|> sample
                   (/.has extra_key extra_value)
                   (/.value extra_key)
                   (maybe#each (n.= extra_value))
                   (maybe.else false)))
             (_.coverage [/.revised]
               (|> sample
                   (/.has extra_key extra_value)
                   (/.revised extra_key (n.+ shift))
                   (/.value extra_key)
                   (maybe#each (n.= (n.+ shift extra_value)))
                   (maybe.else false)))
             (_.coverage [/.lacks]
               (|> sample
                   (/.has extra_key extra_value)
                   (/.lacks extra_key)
                   (# (/.equivalence n.equivalence) = sample)))
             ))))