Debian Codegraph @

lib/srfi/252.scm

raw
1 ;;;
2 ;;; SRFI-252 - Property testing
3 ;;;
4 ;;; Copyright (c) 2024 Shiro Kawai <[email protected]>
5 ;;;
6 ;;; Redistribution and use in source and binary forms, with or without
7 ;;; modification, are permitted provided that the following conditions
8 ;;; are met:
9 ;;;
10 ;;; 1. Redistributions of source code must retain the above copyright
11 ;;; notice, this list of conditions and the following disclaimer.
12 ;;;
13 ;;; 2. Redistributions in binary form must reproduce the above copyright
14 ;;; notice, this list of conditions and the following disclaimer in the
15 ;;; documentation and/or other materials provided with the distribution.
16 ;;;
17 ;;; 3. Neither the name of the authors nor the names of its contributors
18 ;;; may be used to endorse or promote products derived from this
19 ;;; software without specific prior written permission.
20 ;;;
21 ;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 ;;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 ;;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 ;;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 ;;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 ;;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
27 ;;; TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
28 ;;; PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
29 ;;; LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
30 ;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
31 ;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 ;;;
33
34 (define-module srfi.252
35 (use gauche.test)
36 (use srfi.64 :prefix srfi-64:)
37 (use gauche.generator)
38 (use data.random)
39 (export boolean-generator bytevector-generator
40 char-generator string-generator symbol-generator
41
42 complex-generator integer-generator number-generator
43 rational-generator real-generator
44
45 exact-complex-generator exact-integer-generator
46 exact-integer-complex-generator exact-number-generator
47 exact-rational-generator exact-real-generator
48
49 inexact-complex-generator inexact-integer-generator
50 inexact-number-generator inexact-rational-generator
51 inexact-real-generator
52
53 list-generator-of pair-generator-of
54 procedure-generator-of vector-generator-of
55
56 test-property test-property-expect-fail test-property-skip
57 test-property-error test-property-error-type
58 property-test-runner
59 )
60 )
61 (select-module srfi.252)
62
63 ;;
64 ;; Some constants
65 ;;
66
67 (define-constant default-runs 30)
68
69
70 ;;
71 ;; Test runner a la srfi-64
72 ;;
73
74 (define (property-test-runner)
75 (srfi-64:test-runner-simple))
76
77 ;;
78 ;; Test procedures
79 ;;
80
81 (define (%prop-test pred generators expr runs expected hook)
82 (dotimes [n runs]
83 (let1 args (map (^g (g)) generators)
84 (test* (format "Property test ~s [~d] with args ~s" expr n args)
85 expected
86 (boolean (apply pred (map (^g (g)) generators)))
87 test-check
88 (^[name expected actual]
89 (format #t "Failed (~s) with arguments: ~s" actual args))
90 (^[pass/fail name expected actual]
91 (and-let* ([ hook ]
92 [runner (srfi-64:test-runner-current)])
93 (hook runner pass/fail)))))))
94
95 (define (%test-property pred generators expr runs)
96 (%prop-test pred generators expr runs #t
97 (^[runner pass/fail]
98 (ecase pass/fail
99 [(pass) (inc! (srfi-64:test-runner-pass-count runner))]
100 [(fail) (inc! (srfi-64:test-runner-fail-count runner))]))))
101
102 (define-syntax test-property
103 (syntax-rules ()
104 [(_ pred generators)
105 (%test-property pred generators 'pred default-runs)]
106 [(_ pred generators runs)
107 (%test-property pred generators 'pred runs)]))
108
109 (define (%test-property-expect-fail pred generators expr runs)
110 (%prop-test pred generators expr runs #f
111 (^[runner pass/fail]
112 (ecase pass/fail
113 [(pass) (inc! (srfi-64:test-runner-xfail-count runner))]
114 [(fail) (inc! (srfi-64:test-runner-xpass-count runner))]))))
115
116 (define-syntax test-property-expect-fail
117 (syntax-rules ()
118 [(_ pred generators)
119 (%test-property-expect-fail pred generators 'pred default-runs)]
120 [(_ pred generators runs)
121 (%test-property-expect-fail pred generators 'pred runs)]))
122
123 (define (%test-property-skip pred generators expr runs)
124 (and-let1 runner (srfi-64:test-runner-current)
125 (inc! (srfi-64:test-runner-skip-count runner)))
126 #f)
127
128 (define-syntax test-property-skip
129 (syntax-rules ()
130 [(_ pred generators)
131 (%test-property-skip pred generators 'pred default-runs)]
132 [(_ pred generators runs)
133 (%test-property-skip pred generators 'pred runs)]))
134
135 (define (%test-property-error pred generators expr runs)
136 (%prop-test pred generators expr runs (test-error)
137 (^[runner pass/fail]
138 (ecase pass/fail
139 [(pass) (inc! (srfi-64:test-runner-pass-count runner))]
140 [(fail) (inc! (srfi-64:test-runner-fail-count runner))]))))
141
142 (define-syntax test-property-error
143 (syntax-rules ()
144 [(_ pred generators)
145 (%test-property-error pred generators 'pred default-runs)]
146 [(_ pred generators runs)
147 (%test-property-error pred generators 'pred runs)]))
148
149 (define (%test-property-error-type pred generators expr etype runs)
150 (%prop-test pred generators expr runs (test-error etype)
151 (^[runner pass/fail]
152 (ecase pass/fail
153 [(pass) (inc! (srfi-64:test-runner-pass-count runner))]
154 [(fail) (inc! (srfi-64:test-runner-fail-count runner))]))))
155
156 (define-syntax test-property-error-type
157 (syntax-rules ()
158 [(_ etype pred generators)
159 (%test-property-error-type pred generators 'pred etype default-runs)]
160 [(_ etype pred generators runs)
161 (%test-property-error-type pred generators 'pred etype runs)]))
162
163 ;; Generators
164
165 (define-constant sequence-max-size 33)
166
167 (define (boolean-generator) (gcons* #t #f (booleans$)))
168
169 (define (bytevector-generator)
170 (gcons* '#u8()
171 (sequences-of <u8vector>
172 (integers$ sequence-max-size)
173 (integers$ 256))))
174
175 (define (char-generator) (gcons* #\null (chars$ char-set:full)))
176
177 (define (string-generator)
178 ($ gcons* ""
179 $ strings-of (integers$ sequence-max-size) (chars$ char-set:full)))
180
181 (define (symbol-generator)
182 ($ gcons* '||
183 $ gmap string->symbol
184 $ strings-of (integers$ sequence-max-size) (chars$ char-set:full)))
185
186 (define (complex-generator) (inexact-complex-generator))
187
188 (define (integer-generator)
189 (samples-from (list (exact-integer-generator) (inexact-integer-generator))))
190
191 (define (number-generator)
192 (samples-from (list (exact-number-generator) (inexact-number-generator))))
193
194 (define (rational-generator)
195 (samples-from (list (exact-rational-generator) (inexact-rational-generator))))
196
197 (define (real-generator)
198 (samples-from (list (exact-real-generator) (inexact-real-generator))))
199
200 (define (exact-complex-generator) (error "Exact complex isn't supported."))
201
202 ;; Since our integers are unbounded, we can't uniformly sample from the
203 ;; entire space. Besides, real programs tend to meet a lots of short
204 ;; integers but relatively few bigger ones.
205 ;;
206 ;; So, heuristically, we prepare three generators - samples from 16bit integers,
207 ;; samples from entire fixnum range, and a long-tail distribution of bignums.
208 (define (%heuristic-uints)
209 (let ([smalls (uint16s$)]
210 [mids (gmap abs (fixnums$))]
211 [bigs (reals-power-law$ (+ (greatest-fixnum) 1) 1.1)])
212 (samples-from (list smalls mids (^[] (round->exact (bigs)))))))
213
214 (define (%heuristic-sints)
215 (let ([sign (samples$ '(-1 1))]
216 [uints (%heuristic-uints)])
217 (^[] (* (sign) (uints)))))
218
219 (define (exact-integer-generator)
220 (gcons* 0 1 -1 (%heuristic-sints)))
221
222 (define (exact-integer-complex-generator)
223 (error "Exact complex isn't supported."))
224
225 (define (exact-number-generator)
226 ;; we don't have exact complex, so this is the same as...
227 (exact-rational-generator))
228
229 (define (%nonzero-uints) (gdelete 0 (%heuristic-uints)))
230
231 (define (%ratios)
232 (gmap / (%heuristic-sints) (%nonzero-uints)))
233
234 (define (exact-rational-generator)
235 (gcons* 0 1 -1 1/2 -1/2 (%ratios)))
236
237 (define (exact-real-generator) (exact-rational-generator))
238
239 (define (inexact-complex-generator)
240 (let ([re (finite-flonums$)]
241 [im (finite-flonums$)])
242 (gcons* 0.0 -0.0 0.5 -0.5 1.0 -1.0
243 0.0+1.0i 0.0-1.0i -0.0+1.0i -0.0-1.0i
244 0.5+0.5i 0.5-0.5i -0.5+0.5i -0.5-0.5i
245 1.0+1.0i 1.0-1.0i -1.0+1.0i -1.0-1.0i
246 +inf.0+inf.0i +inf.0-inf.0i -inf.0+inf.0i -inf.0-inf.0i
247 +nan.0+nan.0i
248 +inf.0 -inf.0 +nan.0
249 (^[] (make-rectangular (re) (im))))))
250
251 (define (inexact-integer-generator)
252 (gcons* 0.0 -0.0 1.0 -1.0
253 (gfilter finite? (gmap inexact (%heuristic-sints)))))
254
255 (define (inexact-number-generator) (inexact-complex-generator))
256
257 (define (inexact-rational-generator)
258 (gfilter finite? (inexact-real-generator)))
259
260 (define (inexact-real-generator)
261 (gcons* 0.0 -0.0 0.5 -0.5 1.0 -1.0 +inf.0 -inf.0 +nan.0
262 (finite-flonums$)))
263
264 ;; Generator combiners
265
266 (define (list-generator-of gen :optional (max-length #f))
267 (if max-length
268 (lists-of (integers$ max-length) gen)
269 (lists-of gen)))
270
271 (define (pair-generator-of car-gen :optional (cdr-gen #f))
272 (pairs-of car-gen (or cdr-gen car-gen)))
273
274 (define (procedure-generator-of gen)
275 (gmap (^v (^ _ v)) gen))
276
277 (define (vector-generator-of gen :optional (max-length #f))
278 (if max-length
279 (vectors-of (integers$ max-length) gen)
280 (vectors-of gen)))