1 |
|
2 | "use strict";
|
3 |
|
4 | var arbitraryAssert = require("./arbitraryAssert.js");
|
5 | var arbitraryBless = require("./arbitraryBless.js");
|
6 | var array = require("./array.js");
|
7 | var assert = require("assert");
|
8 | var dict = require("./dict.js");
|
9 | var generator = require("./generator.js");
|
10 | var json = require("./json.js");
|
11 | var pair = require("./pair.js");
|
12 | var show = require("./show.js");
|
13 | var shrink = require("./shrink.js");
|
14 | var utils = require("./utils.js");
|
15 |
|
16 |
|
17 |
|
18 |
|
19 |
|
20 |
|
21 |
|
22 |
|
23 |
|
24 |
|
25 | function nonshrink(arb) {
|
26 | arb = utils.force(arb);
|
27 |
|
28 | return arbitraryBless({
|
29 | generator: arb.generator,
|
30 | shrink: shrink.noop,
|
31 | show: arb.show,
|
32 | });
|
33 | }
|
34 |
|
35 |
|
36 |
|
37 |
|
38 | var unit = arbitraryBless({
|
39 | generator: generator.unit,
|
40 | shrink: shrink.noop,
|
41 | show: show.def,
|
42 | });
|
43 |
|
44 |
|
45 |
|
46 |
|
47 | function either(a, b) {
|
48 | a = utils.force(a || json.json);
|
49 | b = utils.force(b || json.json);
|
50 |
|
51 | arbitraryAssert(a);
|
52 | arbitraryAssert(b);
|
53 |
|
54 | return arbitraryBless({
|
55 | generator: generator.either(a.generator, b.generator),
|
56 | shrink: shrink.either(a.shrink, b.shrink),
|
57 | show: show.either(a.show, b.show),
|
58 | });
|
59 | }
|
60 |
|
61 |
|
62 |
|
63 |
|
64 |
|
65 |
|
66 | function pairArb(a, b) {
|
67 | return pair.pair(a || json.json, b || json.json);
|
68 | }
|
69 |
|
70 |
|
71 |
|
72 |
|
73 | function tuple(arbs) {
|
74 | arbs = arbs.map(utils.force);
|
75 | return arbitraryBless({
|
76 | generator: generator.tuple(utils.pluck(arbs, "generator")),
|
77 | shrink: shrink.tuple(utils.pluck(arbs, "shrink")),
|
78 | show: show.tuple(utils.pluck(arbs, "show")),
|
79 | });
|
80 | }
|
81 |
|
82 |
|
83 |
|
84 |
|
85 | function sum(arbs) {
|
86 | arbs = arbs.map(utils.force);
|
87 | return arbitraryBless({
|
88 | generator: generator.sum(utils.pluck(arbs, "generator")),
|
89 | shrink: shrink.sum(utils.pluck(arbs, "shrink")),
|
90 | show: show.sum(utils.pluck(arbs, "show")),
|
91 | });
|
92 | }
|
93 |
|
94 |
|
95 |
|
96 |
|
97 |
|
98 | function dictArb(arb) {
|
99 | return dict.arbitrary(arb || json.json);
|
100 | }
|
101 |
|
102 |
|
103 |
|
104 |
|
105 | function arrayArb(arb) {
|
106 | return array.array(arb || json.json);
|
107 | }
|
108 |
|
109 |
|
110 |
|
111 |
|
112 | function nearrayArb(arb) {
|
113 | return array.nearray(arb || json.json);
|
114 | }
|
115 |
|
116 |
|
117 |
|
118 |
|
119 |
|
120 |
|
121 | var jsonArb = json.json;
|
122 |
|
123 |
|
124 |
|
125 |
|
126 |
|
127 |
|
128 | function oneof() {
|
129 | assert(arguments.length !== 0, "oneof: at least one parameter expected");
|
130 |
|
131 |
|
132 | var generators = [];
|
133 | var append = function (a) {
|
134 | generators.push(utils.force(a).generator);
|
135 | };
|
136 | for (var i = 0; i < arguments.length; i++) {
|
137 | var arg = arguments[i];
|
138 | if (utils.isArray(arg)) {
|
139 | arg.forEach(append);
|
140 | } else {
|
141 | append(arg);
|
142 | }
|
143 | }
|
144 |
|
145 | return arbitraryBless({
|
146 | generator: generator.oneof(generators),
|
147 |
|
148 | shrink: shrink.noop,
|
149 | show: show.def,
|
150 | });
|
151 | }
|
152 |
|
153 |
|
154 |
|
155 |
|
156 | function lazyArbitrary() {
|
157 | var arb = {};
|
158 |
|
159 |
|
160 | arb.generator = generator.bless(function (size) {
|
161 | return arb.strict.generator(size);
|
162 | });
|
163 | arb.shrink = shrink.noop;
|
164 | arb.show = show.def;
|
165 | arb = arbitraryBless(arb);
|
166 | return arb;
|
167 | }
|
168 |
|
169 |
|
170 |
|
171 |
|
172 |
|
173 |
|
174 |
|
175 |
|
176 |
|
177 |
|
178 |
|
179 |
|
180 |
|
181 |
|
182 |
|
183 |
|
184 |
|
185 |
|
186 |
|
187 |
|
188 |
|
189 | function letrec(definition) {
|
190 |
|
191 |
|
192 | var lazyArbs = {};
|
193 |
|
194 | function tie(name) {
|
195 | if (!lazyArbs.hasOwnProperty(name)) {
|
196 | lazyArbs[name] = lazyArbitrary();
|
197 | }
|
198 | return lazyArbs[name];
|
199 | }
|
200 |
|
201 | var strictArbs = definition(tie);
|
202 |
|
203 | Object.keys(lazyArbs).forEach(function (key) {
|
204 | var strictArb = strictArbs[key];
|
205 | if (!strictArb) {
|
206 | throw new Error("undefined lazy arbitrary: " + key);
|
207 | }
|
208 | lazyArbs[key].strict = strictArb;
|
209 | });
|
210 |
|
211 | return strictArbs;
|
212 | }
|
213 |
|
214 | function recursive(arbZ, arbS) {
|
215 | var genZ = arbZ.generator;
|
216 | var genS = function (recGen) {
|
217 | var recArb = arbitraryBless({
|
218 | generator: recGen,
|
219 | shrink: shrink.noop,
|
220 | show: show.def,
|
221 | });
|
222 | return arbS(recArb).generator;
|
223 | };
|
224 |
|
225 | var gen = generator.recursive(genZ, genS);
|
226 | return arbitraryBless({
|
227 | generator: gen,
|
228 | shrink: shrink.noop,
|
229 | show: show.def,
|
230 | });
|
231 | }
|
232 |
|
233 | module.exports = {
|
234 | nonshrink: nonshrink,
|
235 | pair: pairArb,
|
236 | either: either,
|
237 | unit: unit,
|
238 | dict: dictArb,
|
239 | json: jsonArb,
|
240 | nearray: nearrayArb,
|
241 | array: arrayArb,
|
242 | tuple: tuple,
|
243 | sum: sum,
|
244 | oneof: oneof,
|
245 | recursive: recursive,
|
246 | letrec: letrec,
|
247 | };
|