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
|
import Prando from "prando";
type Result = 'OK' | 'Falsified' | 'Exception';
type ShrinkResult<A> = { counterexample: A, shrinks: number };
type TestResult<A> = {
seed: number | null,
result: Result,
counterexample: ShrinkResult<A> | null
};
type Predicate<A> = (a: A) => boolean;
export type Gen<A> = (rng: Prando) => ((size: number) => A);
type Shrinker<A> = (a: A) => A[];
type Property<A> = (seed: number,
size: number) => TestResult<A>;
const MAX_SUCCESS = 100;
function findMinimalCounterExample<A>(x: A,
predicate: Predicate<A>,
shrinker: Shrinker<A>,
depth: number = 0): ShrinkResult<A> {
let xs = shrinker(x);
let counterexample = x;
let shrinks = depth;
for (let y of xs) {
if (!predicate(y)) {
let shrink = findMinimalCounterExample(y, predicate, shrinker, depth + 1);
if (shrink.shrinks > depth) {
counterexample = shrink.counterexample;
shrinks = shrink.shrinks;
}
}
}
return { counterexample, shrinks };
}
export function generate<A>(gen: Gen<A>): A {
let rng = new Prando(Math.random() * 1000);
return gen(rng)(100);
}
export function property<A>(
predicate: Predicate<A>,
generator: Gen<A>,
shrinker: Shrinker<A>): Property<A> {
return (seed: number,
size: number) => {
let rng = new Prando(seed);
let gen = generator(rng);
let i = 0;
for (; i < MAX_SUCCESS; i++) {
let x = gen(size);
if (!predicate(x)) {
let counterexample = findMinimalCounterExample(x, predicate, shrinker);
return { seed, result: 'Falsified', tests: i + 1, counterexample };
}
size++;
}
return { seed, result: 'OK', tests: i, counterexample: null };
};
}
// basic generators
export function listOf<A>(gen: Gen<A>): Gen<A[]> {
return (rng: Prando) => {
let g = gen(rng);
return (size: number) => {
let result = [];
for (let i = 0; i < size; i++) {
result.push(g(size));
}
return result;
};
};
}
export function shrinklist<A>(arr: A[]): A[][] {
let result = [];
let tail = arr.slice(1);
let keep1 = arr.slice();
keep1.splice(1, 1);
result.push(tail, keep1);
if (arr.length > 3) {
let half = Math.floor(arr.length / 2);
let copy = arr.slice();
let secondHalf = copy.slice(half);
result.push(secondHalf);
}
return result;
}
export let someInt: Gen<number> = (rng: Prando) =>
(size: number) =>
rng.nextInt(-size, size);
export const Property = {
run<A>(prop: Property<A>): TestResult<A> {
let seed = Math.floor(Math.random() * 1000000);
return prop(seed, 0);
}
};
|
