blob: ed26027df1213630003d86f81c70ba40dd9d3bdf (
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
119
120
121
122
123
124
125
126
127
128
|
(.require
[library
[lux (.except global)
[abstract
[equivalence (.only Equivalence)]
[monad (.only do)]]
[control
["[0]" try (.use "[1]#[0]" functor)]]
[data
["[0]" sum]
["[0]" product]
["[0]" bit]
["[0]" text (.use "[1]#[0]" equivalence)]
["[0]" binary
["![1]" \\format]
["?[1]" \\parser]]
[collection
["[0]" list]]]
[math
["[0]" random (.only Random) (.use "[1]#[0]" monad)]
[number
["[0]" nat]]]
[meta
["[0]" version]
["[0]" type (.only)
["[1]T" \\test]]
["[0]" symbol (.only)
["[1]T" \\test]]
[compiler
[meta
[archive
["[0]" key]
["[0]" signature]]]]]
[test
["_" property (.only Test)]]]]
[\\library
["[0]" /]])
(def any_equivalence
(Equivalence Any)
(implementation
(def (= _ _)
true)))
(def definition_equivalence
(Equivalence Definition)
(all product.equivalence
type.equivalence
..any_equivalence
))
(def definition
(Random Definition)
(do random.monad
[type (typeT.random 1)]
(in [type []])))
(def global_equivalence
(Equivalence Global)
(all sum.equivalence
..definition_equivalence
symbol.equivalence
..definition_equivalence
))
(def global
(Random Global)
(all random.or
..definition
(symbolT.random 1 1)
..definition
))
(def module_state_equivalence
(Equivalence Module_State)
(all sum.equivalence
..any_equivalence
..any_equivalence
..any_equivalence
))
(def module_state
(Random Module_State)
(all random.or
(random#in [])
(random#in [])
(random#in [])
))
(def module_equivalence
(Equivalence Module)
(all product.equivalence
nat.equivalence
(list.equivalence (product.equivalence text.equivalence text.equivalence))
(list.equivalence (all product.equivalence text.equivalence bit.equivalence global_equivalence))
(list.equivalence text.equivalence)
..module_state_equivalence
))
(def module
(Random Module)
(all random.and
random.nat
(random.list 1 (random.and (random.upper_cased 2) (random.upper_cased 3)))
(random.list 4 (all random.and (random.upper_cased 5) random.bit ..global))
(random.list 6 (random.upper_cased 7))
..module_state
))
(def .public test
Test
(<| (_.covering /._)
(do [! random.monad]
[expected ..module])
(all _.and
(_.coverage [/.format /.parser]
(|> expected
(!binary.result /.format)
(?binary.result /.parser)
(try#each (of module_equivalence = (has .#module_state {.#Cached} expected)))
(try.else false)))
(_.coverage [/.key]
(let [it (key.signature /.key)]
(and (let [[expected_module _] (symbol /._)
[actual_module actual_short] (the signature.#name it)]
(and (text#= expected_module actual_module)))
(same? version.latest (the signature.#version it)))))
)))
|
