aboutsummaryrefslogtreecommitdiff
path: root/stdlib/source/test/lux/data/collection/stack.lux
blob: 80b7fce637f3ecc4d4f2a9ac885e5a2510d8d1d2 (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
(.module:
  [lux #*
   ["_" test (#+ Test)]
   [abstract
    [monad (#+ do)]
    {[0 #spec]
     [/
      ["$." equivalence]
      ["$." functor (#+ Injection)]]}]
   [data
    ["." maybe]
    ["." bit ("#@." equivalence)]
    [number
     ["n" nat]]]
   [math
    ["." random]]]
  {1
   ["." /]})

(def: (injection value)
  (Injection /.Stack)
  (/.push value /.empty))

(def: #export test
  Test
  (<| (_.covering /._)
      (_.with-cover [/.Stack])
      (do random.monad
        [size (:: random.monad map (n.% 100) random.nat)
         sample (random.stack size random.nat)
         expected-top random.nat]
        ($_ _.and
            (_.with-cover [/.equivalence]
              ($equivalence.spec (/.equivalence n.equivalence) (random.stack size random.nat)))
            (_.with-cover [/.functor]
              ($functor.spec ..injection /.equivalence /.functor))
            
            (_.cover [/.size]
                     (n.= size (/.size sample)))
            (_.cover [/.empty?]
                     (bit@= (n.= 0 (/.size sample))
                            (/.empty? sample)))
            (_.cover [/.empty]
                     (/.empty? /.empty))
            (_.cover [/.peek]
                     (case (/.peek sample)
                       #.None
                       (/.empty? sample)
                       
                       (#.Some _)
                       (not (/.empty? sample))))
            (_.cover [/.pop]
                     (case (/.pop sample)
                       #.None
                       (/.empty? sample)
                       
                       (#.Some [top remaining])
                       (:: (/.equivalence n.equivalence) =
                           sample
                           (/.push top remaining))))
            (_.cover [/.push]
                     (case (/.pop (/.push expected-top sample))
                       (#.Some [actual-top actual-sample])
                       (and (is? expected-top actual-top)
                            (is? sample actual-sample))
                       
                       #.None
                       false))
            ))))