projects/guix·blob python-team · refs

1236 lines · 46.4 KiB

1;;; GNU Guix --- Functional package management for GNU
2;;; Copyright © 2015 Paul van der Walt <[email protected]>
3;;; Copyright © 2015 Eric Bavier <[email protected]>
4;;; Copyright © 2015 Federico Beffa <[email protected]>
5;;; Copyright © 2015, 2016, 2017, 2018 Ricardo Wurmus <[email protected]>
6;;; Copyright © 2016 Nikita <[email protected]>
7;;; Copyright © 2016 David Craven <[email protected]>
8;;; Copyright © 2017 Danny Milosavljevic <[email protected]>
9;;; Copyright © 2017 rsiddharth <[email protected]>
10;;; Copyright © 2017, 2018, 2021 Tobias Geerinckx-Rice <[email protected]>
11;;; Copyright © 2018 Tonton <[email protected]>
12;;; Copyright © 2018 Arun Isaac <[email protected]>
13;;; Copyright © 2019 Timothy Sample <[email protected]>
14;;; Copyright © 2020 John Soo <[email protected]>
15;;; Copyright © 2020 Carlo Holl <[email protected]>
16;;; Copyright © 2021 John Kehayias <[email protected]>
17;;; Copyright © 2023 zamfofex <[email protected]>
18;;;
19;;; This file is part of GNU Guix.
20;;;
21;;; GNU Guix is free software; you can redistribute it and/or modify it
22;;; under the terms of the GNU General Public License as published by
23;;; the Free Software Foundation; either version 3 of the License, or (at
24;;; your option) any later version.
25;;;
26;;; GNU Guix is distributed in the hope that it will be useful, but
27;;; WITHOUT ANY WARRANTY; without even the implied warranty of
28;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
29;;; GNU General Public License for more details.
30;;;
31;;; You should have received a copy of the GNU General Public License
32;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
33
34(define-module (gnu packages haskell-check)
35 #:use-module (gnu packages)
36 #:use-module (gnu packages haskell-crypto)
37 #:use-module (gnu packages haskell-web)
38 #:use-module (gnu packages haskell-xyz)
39 #:use-module (guix build-system haskell)
40 #:use-module (guix download)
41 #:use-module ((guix licenses) #:prefix license:)
42 #:use-module (guix packages)
43 #:use-module (guix utils))
44
45(define-public ghc-tasty-ant-xml
46 (package
47 (name "ghc-tasty-ant-xml")
48 (version "1.1.9")
49 (source
50 (origin
51 (method url-fetch)
52 (uri (hackage-uri "tasty-ant-xml" version))
53 (sha256
54 (base32 "00zgsd6jjfwasr69d0y781vhjr7d8p1jbaaz4pn75ljf33akd92l"))))
55 (build-system haskell-build-system)
56 (properties '((upstream-name . "tasty-ant-xml")))
57 (inputs (list ghc-generic-deriving ghc-tagged ghc-tasty ghc-xml))
58 (home-page "http://github.com/ocharles/tasty-ant-xml")
59 (synopsis "Render tasty output to XML for Jenkins")
60 (description
61 "A tasty ingredient to output test results in XML, using the Ant
62schema. This XML can be consumed by the Jenkins continuous integration
63framework.")
64 (license license:bsd-3)))
65
66(define-public ghc-tasty-smallcheck
67 (package
68 (name "ghc-tasty-smallcheck")
69 (version "0.8.2")
70 (source
71 (origin
72 (method url-fetch)
73 (uri (hackage-uri "tasty-smallcheck" version))
74 (sha256
75 (base32 "0csgwn3vch0jnpqyyfnrfjq4z0dpl67imh5a7byll3hhlyidgjym"))))
76 (build-system haskell-build-system)
77 (properties '((upstream-name . "tasty-smallcheck")))
78 (inputs (list ghc-tasty ghc-smallcheck ghc-tagged ghc-optparse-applicative))
79 (arguments
80 `(#:cabal-revision ("1"
81 "0033ha2w9rzc1rxpzh1dkfdrn256i5lvb41pqbdh2i6kli0v5vmh")))
82 (home-page "https://github.com/feuerbach/tasty")
83 (synopsis "SmallCheck support for the Tasty test framework")
84 (description "This package provides SmallCheck support for the Tasty
85Haskell test framework.")
86 (license license:expat)))
87
88(define-public ghc-tasty-quickcheck
89 (package
90 (name "ghc-tasty-quickcheck")
91 (version "0.11.1")
92 (source
93 (origin
94 (method url-fetch)
95 (uri (hackage-uri "tasty-quickcheck" version))
96 (sha256
97 (base32 "0si4ccgqlv8h33d6310rrqba7f4pz3g8cinqfj42yd7damsdxm73"))))
98 (build-system haskell-build-system)
99 (properties '((upstream-name . "tasty-quickcheck")))
100 (inputs (list ghc-tagged ghc-tasty ghc-random ghc-quickcheck
101 ghc-optparse-applicative))
102 (native-inputs (list ghc-regex-tdfa ghc-tasty-hunit))
103 (arguments
104 `(#:cabal-revision ("3"
105 "1wzvha4xam8npx5mk33c056grmrqnjd6m38nnm6d7y99w2mn1a7w")))
106 (home-page "https://github.com/UnkindPartition/tasty")
107 (synopsis "QuickCheck support for the Tasty test framework")
108 (description "This package provides QuickCheck support for the Tasty
109Haskell test framework.")
110 (license license:expat)))
111
112(define-public ghc-tasty-golden
113 (package
114 (name "ghc-tasty-golden")
115 (version "2.3.5")
116 (source (origin
117 (method url-fetch)
118 (uri (hackage-uri "tasty-golden" version))
119 (sha256
120 (base32
121 "03klnxn9rcv0l7fl4w8q6s59fzl1328j1wzwi1za4gb0l90vadwb"))))
122 (build-system haskell-build-system)
123 (properties '((upstream-name . "tasty-golden")))
124 (inputs (list ghc-tasty
125 ghc-typed-process
126 ghc-optparse-applicative
127 ghc-temporary
128 ghc-tagged
129 ghc-async))
130 (native-inputs (list ghc-tasty-hunit))
131 (home-page "https://github.com/UnkindPartition/tasty-golden")
132 (synopsis "Golden tests support for tasty")
133 (description
134 "This package provides support for @code{golden testing}. A @dfn{golden
135test} is an IO action that writes its result to a file. To pass the test, this
136output file should be identical to the corresponding @code{golden} file, which
137contains the correct result for the test.")
138 (license license:expat)))
139
140(define-public ghc-tasty
141 (package
142 (name "ghc-tasty")
143 (version "1.5.3")
144 (source
145 (origin
146 (method url-fetch)
147 (uri (hackage-uri "tasty" version))
148 (sha256
149 (base32 "10076vlklbcyiz7plakrihava5sy3dvwhskjldqzhfl18jvcg82l"))))
150 (build-system haskell-build-system)
151 (properties '((upstream-name . "tasty")))
152 (inputs
153 (list ghc-tagged
154 ghc-optparse-applicative
155 ghc-ansi-terminal
156 ghc-unbounded-delays)) ; needed on 32-bit architectures
157 (arguments
158 `(#:cabal-revision ("2"
159 "04llcf1i3gawdik0bjhxdgls2wkiqlx0gi76nfh784nv2qzxlpbb")))
160 (home-page "https://github.com/UnkindPartition/tasty")
161 (synopsis "Modern and extensible testing framework")
162 (description
163 "Tasty is a modern testing framework for Haskell. It lets
164you combine your unit tests, golden tests, QuickCheck/SmallCheck properties,
165and any other types of tests into a single test suite.")
166 (license license:expat)))
167
168(define-public ghc-tasty-hedgehog
169 (package
170 (name "ghc-tasty-hedgehog")
171 (version "1.4.0.2")
172 (source
173 (origin
174 (method url-fetch)
175 (uri (hackage-uri "tasty-hedgehog" version))
176 (sha256
177 (base32 "0lki03z0p38x0dkqx5cqga30zy5m31gxn1saqylja9bi6bbq8d25"))))
178 (build-system haskell-build-system)
179 (properties '((upstream-name . "tasty-hedgehog")))
180 (inputs (list ghc-tagged ghc-tasty ghc-hedgehog))
181 (native-inputs (list ghc-tasty-expected-failure))
182 (arguments
183 `(#:cabal-revision ("6"
184 "1rb8ncp6xyy7jr6v0hyls9m529ba0djndsxgxmkgr52rk3qq8lrc")))
185 (home-page "https://github.com/qfpl/tasty-hedgehog")
186 (synopsis "Integration for tasty and hedgehog")
187 (description
188 "This package provides the means for integrating the
189@url{https://hackage.haskell.org/package/hedgehog, hedgehog testing library}
190with the @url{https://hackage.haskell.org/package/tasty, tasty testing
191framework}.")
192 (license license:bsd-3)))
193
194(define-public ghc-tasty-hspec
195 (package
196 (name "ghc-tasty-hspec")
197 (version "1.2.0.4")
198 (source
199 (origin
200 (method url-fetch)
201 (uri (hackage-uri "tasty-hspec" version))
202 (sha256
203 (base32 "1hk1nkjvhp89xxgzj6dhbgw0fknnghpng6afq4i39hjkwv5p78ni"))))
204 (build-system haskell-build-system)
205 (properties '((upstream-name . "tasty-hspec")))
206 (inputs (list ghc-hspec
207 ghc-hspec-api
208 ghc-hspec-core
209 ghc-quickcheck
210 ghc-tasty
211 ghc-tasty-smallcheck
212 ghc-tasty-quickcheck))
213 (arguments
214 `(#:cabal-revision ("7"
215 "0s1y34i8g7fva0z10ws3ipcy2jmlvqk0v4hdbx8rqnby5n0l5kay")))
216 (home-page "https://github.com/mitchellwrosen/tasty-hspec")
217 (synopsis "Hspec support for the Tasty test framework")
218 (description
219 "This package provides a Tasty provider for Hspec test suites.")
220 (license license:bsd-3)))
221
222(define-public ghc-tasty-hunit
223 (package
224 (name "ghc-tasty-hunit")
225 (version "0.10.2")
226 (source
227 (origin
228 (method url-fetch)
229 (uri (hackage-uri "tasty-hunit" version))
230 (sha256
231 (base32 "1xh33ss7dncm7zanzkzh7ywb3a46k7vkcbh6v8jb767gq6kizw2s"))))
232 (build-system haskell-build-system)
233 (properties '((upstream-name . "tasty-hunit")))
234 (inputs (list ghc-tasty ghc-call-stack-boot))
235 (home-page "https://github.com/UnkindPartition/tasty")
236 (synopsis "HUnit support for the Tasty test framework")
237 (description "This package provides HUnit support for the Tasty Haskell
238test framework.")
239 (license license:expat)))
240
241(define-public ghc-tasty-kat
242 (package
243 (name "ghc-tasty-kat")
244 (version "0.0.3")
245 (source (origin
246 (method url-fetch)
247 (uri (hackage-uri "tasty-kat" version))
248 (sha256
249 (base32
250 "14yvlpli6cv6bn3kh8mlfp4x1l6ns4fvmfv6hmj75cvxyzq029d7"))))
251 (build-system haskell-build-system)
252 (properties '((upstream-name . "tasty-kat")))
253 (inputs
254 (list ghc-tasty ghc-tasty-quickcheck ghc-tasty-hunit))
255 (home-page "https://github.com/vincenthz/tasty-kat")
256 (synopsis "Known Answer Tests (KAT) framework for tasty")
257 (description
258 "This package provides a @dfn{Known Answer Tests} (KAT) framework for
259tasty.")
260 (license license:expat)))
261
262(define-public ghc-tasty-lua
263 (package
264 (name "ghc-tasty-lua")
265 (version "1.1.1.1")
266 (source
267 (origin
268 (method url-fetch)
269 (uri (hackage-uri "tasty-lua" version))
270 (sha256
271 (base32 "03b2n3gw2w70cnl57w3sh3cv5ka270sf07jlxpb4zs0z5gh83p1r"))))
272 (build-system haskell-build-system)
273 (properties '((upstream-name . "tasty-lua")))
274 (inputs (list ghc-hslua-core
275 ghc-hslua-marshalling
276 ghc-lua-arbitrary
277 ghc-tasty
278 ghc-quickcheck
279 ghc-file-embed))
280 (native-inputs (list ghc-tasty-hunit))
281 (home-page "https://github.com/hslua/hslua")
282 (synopsis "Write tests in Lua, integrate into tasty")
283 (description "This package gives users the ability to define tasty tests
284from Lua.")
285 (license license:expat)))
286
287(define-public ghc-tasty-th
288 (package
289 (name "ghc-tasty-th")
290 (version "0.1.7")
291 (source
292 (origin
293 (method url-fetch)
294 (uri (hackage-uri "tasty-th" version))
295 (sha256
296 (base32 "0b2ivrw2257m4cy4rjnkwqlarh83j1y3zywnmaqqqbvy667sqnj3"))))
297 (build-system haskell-build-system)
298 (properties '((upstream-name . "tasty-th")))
299 (inputs (list ghc-haskell-src-exts ghc-tasty))
300 (native-inputs (list ghc-tasty-hunit))
301 (home-page "https://github.com/bennofs/tasty-th")
302 (synopsis "Automatically generate tasty TestTrees")
303 (description
304 "Tasty-th automatically generates tasty TestTrees from functions of the
305current module, using TemplateHaskell. This is a fork the original
306test-framework-th package, modified to work with tasty instead of
307test-framework.")
308 (license license:bsd-3)))
309
310(define-public ghc-tasty-rerun
311 (package
312 (name "ghc-tasty-rerun")
313 (version "1.1.20")
314 (source
315 (origin
316 (method url-fetch)
317 (uri (hackage-uri "tasty-rerun" version))
318 (sha256
319 (base32 "0px58jm1yqbg32qf2s0yk09d2qdjxkkz9df89f31q3nzw85jv2ky"))))
320 (build-system haskell-build-system)
321 (properties '((upstream-name . "tasty-rerun")))
322 (inputs (list ghc-optparse-applicative ghc-split ghc-tagged ghc-tasty))
323 (arguments
324 `(#:cabal-revision ("1"
325 "13xmx91hp7i0qzrhada9ckliqkynwlwa8x6pjbvxjcy1y0qsd7hk")))
326 (home-page "https://github.com/ocharles/tasty-rerun")
327 (synopsis "Run tests by filtering the test tree")
328 (description
329 "This package adds the ability to run tests by filtering the
330test tree based on the result of a previous test run. You can use this to run
331only those tests that failed in the last run, or to only run the tests that have
332been added since previous test run.")
333 (license license:bsd-3)))
334
335(define-public ghc-tasty-expected-failure
336 (package
337 (name "ghc-tasty-expected-failure")
338 (version "0.12.3")
339 (source
340 (origin
341 (method url-fetch)
342 (uri (hackage-uri "tasty-expected-failure" version))
343 (sha256
344 (base32
345 "0zlgxs24d54byfhvwdg85xk1572zpjs71bjlxxrxcvralrfcq1yb"))))
346 (build-system haskell-build-system)
347 (properties '((upstream-name . "tasty-expected-failure")))
348 (arguments `(#:tests? #f)) ; TODO: Loops.
349; (native-inputs
350; `(("ghc-tasty-hunit" ,ghc-tasty-hunit)
351; ("ghc-tasty-golden" ,ghc-tasty-golden)
352; ("ghc-hedgehog" ,ghc-hedgehog)
353; ("ghc-tasty-hedgehog" ,ghc-tasty-hedgehog)))
354 (inputs
355 (list ghc-tagged ghc-tasty ghc-unbounded-delays))
356 (home-page "https://github.com/nomeata/tasty-expected-failure")
357 (synopsis "Mark tasty tests as failure expected")
358 (description
359 "With the function @code{Test.Tasty.ExpectedFailure.expectFail} in the
360provided module @code{Test.Tasty.ExpectedFailure}, you can mark that you
361expect test cases to fail, and not to pass. This can be used for test-driven
362development.")
363 (license license:expat)))
364
365(define-public ghc-quickcheck-instances
366 (package
367 (name "ghc-quickcheck-instances")
368 (version "0.3.33")
369 (source
370 (origin
371 (method url-fetch)
372 (uri (hackage-uri "quickcheck-instances" version))
373 (sha256
374 (base32 "0rl8y3rb4fm4nqz122bp5f2aya4f8bc9m9i9n2vwlyq2gdacs0v8"))))
375 (build-system haskell-build-system)
376 (properties '((upstream-name . "quickcheck-instances")))
377 (inputs (list ghc-quickcheck
378 ghc-splitmix-bootstrap
379 ghc-case-insensitive
380 ghc-data-fix
381 ghc-hashable
382 ghc-integer-logarithms
383 ghc-old-time
384 ghc-onetuple
385 ghc-primitive
386 ghc-scientific
387 ghc-strict
388 ghc-tagged
389 ghc-text-short
390 ghc-these
391 ghc-time-compat
392 ghc-unordered-containers
393 ghc-uuid-types
394 ghc-vector))
395 (arguments
396 `(#:cabal-revision ("1"
397 "1xkc7rsfgya4rwiizh0yfincws3knpdnh08m280v1dgik4kv37vh")))
398 (home-page "https://github.com/haskellari/qc-instances")
399 (synopsis "Common quickcheck instances")
400 (description "This package provides QuickCheck instances for types
401provided by the Haskell Platform.")
402 (license license:bsd-3)))
403
404(define-public ghc-quickcheck-unicode
405 (package
406 (name "ghc-quickcheck-unicode")
407 (version "1.0.1.0")
408 (source
409 (origin
410 (method url-fetch)
411 (uri (hackage-uri "quickcheck-unicode" version))
412 (sha256
413 (base32 "0s43s1bzbg3gwsjgm7fpyksd1339f0m26dlw2famxwyzgvm0a80k"))))
414 (build-system haskell-build-system)
415 (properties '((upstream-name . "quickcheck-unicode")))
416 (inputs (list ghc-quickcheck))
417 (home-page "https://github.com/bos/quickcheck-unicode")
418 (synopsis "Generator functions Unicode-related tests")
419 (description "This package provides generator and shrink functions for
420testing Unicode-related software.")
421 (license license:bsd-2)))
422
423(define-public ghc-quickcheck-text
424 (package
425 (name "ghc-quickcheck-text")
426 (version "0.1.2.1")
427 (source
428 (origin
429 (method url-fetch)
430 (uri (hackage-uri "quickcheck-text" version))
431 (sha256
432 (base32 "02dbs0k6igmsa1hcw8yfvp09v7038vp4zlsp9706km3cmswgshj4"))))
433 (build-system haskell-build-system)
434 (properties '((upstream-name . "quickcheck-text")))
435 (inputs (list ghc-quickcheck))
436 (home-page "https://github.com/olorin/quickcheck-text")
437 (synopsis "Alternative arbitrary instance for Text")
438 (description
439 "The usual Arbitrary instance for Text (in
440<https://hackage.haskell.org/package/quickcheck-instances quickcheck-instances>)
441only has single-byte instances and so isn't an ideal representation of a valid
442UTF-8 character. This package has generators for one-, two- and three-byte
443UTF-8 characters (all that are currently in use).")
444 (license license:expat)))
445
446(define-public ghc-quickcheck-io
447 (package
448 (name "ghc-quickcheck-io")
449 (version "0.2.0")
450 (source
451 (origin
452 (method url-fetch)
453 (uri (hackage-uri "quickcheck-io" version))
454 (sha256
455 (base32
456 "08k4v7pkgjf30pv5j2dfv1gqv6hclxlniyq2sps8zq4zswcr2xzv"))))
457 (build-system haskell-build-system)
458 (properties '((upstream-name . "quickcheck-io")))
459 (inputs
460 (list ghc-quickcheck ghc-hunit))
461 (home-page
462 "https://github.com/hspec/quickcheck-io#readme")
463 (synopsis "Use HUnit assertions as QuickCheck properties")
464 (description "This package provides an orphan instance that allows you to
465use HUnit assertions as QuickCheck properties.")
466 (license license:expat)))
467
468(define-public ghc-quickcheck
469 (package
470 (name "ghc-quickcheck")
471 (version "2.15.0.1")
472 (source
473 (origin
474 (method url-fetch)
475 (uri (hackage-uri "QuickCheck" version))
476 (sha256
477 (base32 "0zvfydg44ibs1br522rzvdlxj9mpz0h62js1hay1sj5gvdnj3cm3"))))
478 (build-system haskell-build-system)
479 (properties '((upstream-name . "QuickCheck")))
480 (inputs (list ghc-random-bootstrap ghc-splitmix-bootstrap))
481 (arguments
482 `(#:cabal-revision ("1"
483 "0cgfp4s51cjphsn9cls6rndisvqmi94vn95xan9g1yz6p5xk7z8c")))
484 (home-page "https://github.com/nick8325/quickcheck")
485 (synopsis "Automatic testing of Haskell programs")
486 (description
487 "QuickCheck is a library for random testing of program properties. The
488programmer provides a specification of the program, in the form of properties
489which functions should satisfy, and QuickCheck then tests that the properties
490hold in a large number of randomly generated cases. Specifications are
491expressed in Haskell, using combinators defined in the QuickCheck library.")
492 (license license:bsd-3)))
493
494(define-public ghc-quickcheck-assertions
495 (package
496 (name "ghc-quickcheck-assertions")
497 (version "0.3.0")
498 (source
499 (origin
500 (method url-fetch)
501 (uri (hackage-uri "quickcheck-assertions" version))
502 (sha256
503 (base32 "1kyam4cy7qmnizjwjm8jamq43w7f0fs6ljfplwj0ib6wi2kjh0wv"))))
504 (build-system haskell-build-system)
505 (properties '((upstream-name . "quickcheck-assertions")))
506 (inputs (list ghc-quickcheck ghc-ieee754 ghc-pretty-show))
507 (native-inputs (list ghc-hspec))
508 (home-page "https://github.com/s9gf4ult/quickcheck-assertions")
509 (synopsis "HUnit-like assertions for QuickCheck")
510 (description
511 "This Haskell library provides convenient assertions with pretty-printed
512failure messages for QuickCheck properties, that are similar to those of
513HUnit.")
514 (license license:lgpl3)))
515
516(define-public ghc-test-framework
517 (package
518 (name "ghc-test-framework")
519 (version "0.8.2.2")
520 (source
521 (origin
522 (method url-fetch)
523 (uri (hackage-uri "test-framework" version))
524 (sha256
525 (base32 "04ijf5x6xx8i5lqv9ir33zs1rfzc4qkwwz8c1fdycnzvydcv4dnp"))))
526 (build-system haskell-build-system)
527 (properties '((upstream-name . "test-framework")))
528 (inputs (list ghc-ansi-terminal
529 ghc-ansi-wl-pprint
530 ghc-random
531 ghc-regex-posix
532 ghc-old-locale
533 ghc-xml
534 ghc-hostname))
535 (native-inputs (list ghc-hunit ghc-quickcheck ghc-semigroups-bootstrap))
536 (arguments
537 `(#:cabal-revision ("1"
538 "1yv1qsr6bxphxk9430id9bqhfmkffdqmfg0k017dp9pnn4pqj0zh")))
539 (home-page "https://github.com/haskell/test-framework#readme")
540 (synopsis "Framework for running and organising tests")
541 (description
542 "This package allows tests such as QuickCheck properties and HUnit test
543cases to be assembled into test groups, run in parallel (but reported in
544deterministic order, to aid diff interpretation) and filtered and controlled
545by command line options. All of this comes with colored test output, progress
546reporting and test statistics output.")
547 (license license:bsd-3)))
548
549(define-public ghc-test-framework-hunit
550 (package
551 (name "ghc-test-framework-hunit")
552 (version "0.3.0.2")
553 (source
554 (origin
555 (method url-fetch)
556 (uri (hackage-uri "test-framework-hunit" version))
557 (sha256
558 (base32
559 "1y0b6vg8nfm43v90lxxcydhi6qlxhfy4vpxbzm5ic2w55bh8xjwm"))))
560 (build-system haskell-build-system)
561 (properties '((upstream-name . "test-framework-hunit")))
562 (arguments
563 `(#:cabal-revision
564 ("3" "0i9mlalv7cl1iq43ld5myrnpszq5rxmd79hk495dcb08rglhgl3z")))
565 (inputs
566 (list ghc-extensible-exceptions ghc-hunit ghc-test-framework))
567 (home-page "https://batterseapower.github.io/test-framework/")
568 (synopsis "HUnit support for test-framework")
569 (description
570 "This package provides HUnit support for the test-framework package.")
571 (license license:bsd-3)))
572
573(define-public ghc-test-framework-quickcheck2
574 (package
575 (name "ghc-test-framework-quickcheck2")
576 (version "0.3.0.6")
577 (source
578 (origin
579 (method url-fetch)
580 (uri (hackage-uri "test-framework-quickcheck2" version))
581 (sha256
582 (base32 "1d0w2q9sm8aayk0aj1zr2irpnqwpzixn6pdfq1i904vs1kkb2xin"))))
583 (build-system haskell-build-system)
584 (properties '((upstream-name . "test-framework-quickcheck2")))
585 (inputs (list ghc-test-framework ghc-quickcheck ghc-extensible-exceptions
586 ghc-random))
587 (arguments
588 `(#:cabal-revision ("1"
589 "1af2gw9gvq143jdqmsnxj23cgss9ffdyr67951a5x151aps04y7z")))
590 (home-page "https://github.com/haskell/test-framework")
591 (synopsis "QuickCheck2 support for test-framework")
592 (description
593 "This package provides QuickCheck2 support for the test-framework
594package.")
595 (license license:bsd-3)))
596
597(define-public ghc-test-framework-smallcheck
598 (package
599 (name "ghc-test-framework-smallcheck")
600 (version "0.2")
601 (source
602 (origin
603 (method url-fetch)
604 (uri (hackage-uri "test-framework-smallcheck" version))
605 (sha256
606 (base32 "1xpgpk1gp4w7w46b4rhj80fa0bcyz8asj2dcjb5x1c37b7rw90b0"))))
607 (build-system haskell-build-system)
608 (properties '((upstream-name . "test-framework-smallcheck")))
609 (inputs (list ghc-test-framework ghc-smallcheck))
610 (home-page "https://github.com/feuerbach/smallcheck")
611 (synopsis "SmallCheck support for test-framework")
612 (description
613 "This package lets programmers use SmallCheck properties in Haskell's
614test-framework. New projects should use ghc-tasty-smallcheck instead.")
615 (license license:bsd-3)))
616
617(define-public ghc-test-framework-th
618 (package
619 (name "ghc-test-framework-th")
620 (version "0.2.4")
621 (source
622 (origin
623 (method url-fetch)
624 (uri (hackage-uri "test-framework-th" version))
625 (sha256
626 (base32
627 "12lw7yj02jb9s0i7rb98jjam43j2h0gzmnbj9zi933fx7sg0sy4b"))))
628 (build-system haskell-build-system)
629 (properties '((upstream-name . "test-framework-th")))
630 (inputs
631 (list ghc-test-framework ghc-language-haskell-extract
632 ghc-haskell-src-exts ghc-regex-posix))
633 (home-page "https://github.com/finnsson/test-generator")
634 (synopsis "Auto generate the HUnit- and Quickcheck-bulk-code
635using Template Haskell")
636 (description "This library contains two functions:
637@code{defaultMainGenerator} and @code{testGroupGenerator}.
638
639@code{defaultMainGenerator} will extract all functions beginning with
640@code{case_}, @code{prop_}, or @code{test_} in the module and put them in a
641@code{testGroup}.
642
643@code{testGroupGenerator} is like @code{defaultMainGenerator} but without
644@code{defaultMain}. It is useful if you need a function for the testgroup
645\(e.g. if you want to be able to call the testgroup from another module).")
646 (license license:bsd-3)))
647
648(define-public ghc-hunit
649 (package
650 (name "ghc-hunit")
651 (version "1.6.2.0")
652 (outputs '("out" "doc"))
653 (source
654 (origin
655 (method url-fetch)
656 (uri (hackage-uri "HUnit" version))
657 (sha256
658 (base32
659 "1as4sw5y39c3zrmr6sb8zbw74c9gdn4401y0dx45ih7zf6457dxh"))))
660 (build-system haskell-build-system)
661 (properties '((upstream-name . "HUnit")))
662 (inputs
663 ;; We cannot use ghc-call-stack there, because it depends on
664 ;; ghc-nanospec, which depends on ghc-hunit.
665 (list ghc-call-stack-boot))
666 (home-page "https://hunit.sourceforge.net/")
667 (synopsis "Unit testing framework for Haskell")
668 (description
669 "HUnit is a unit testing framework for Haskell, inspired by the
670JUnit tool for Java.")
671 (license license:bsd-3)))
672
673(define-public hspec-discover
674 (package
675 (name "hspec-discover")
676 (version "2.11.12")
677 (source
678 (origin
679 (method url-fetch)
680 (uri (hackage-uri "hspec-discover" version))
681 (sha256
682 (base32 "044vgsy45ff00h9z2k3jgn2m37npcjiacc4cifahrjlmwa7a7ylp"))))
683 (build-system haskell-build-system)
684 (properties '((upstream-name . "hspec-discover")))
685 (native-inputs (list ghc-quickcheck ghc-hspec-meta ghc-mockery-bootstrap))
686 (home-page "https://hspec.github.io/")
687 (synopsis "Automatically discover and run Hspec tests")
688 (description "hspec-discover is a tool which automatically discovers and
689runs Hspec tests.")
690 (license license:expat)))
691
692(define-public ghc-hspec-core
693 (package
694 (name "ghc-hspec-core")
695 (version "2.11.12")
696 (source
697 (origin
698 (method url-fetch)
699 (uri (hackage-uri "hspec-core" version))
700 (sha256
701 (base32 "030400w95775jrivbi7n1nnx6j5z717rqd3986ggklb8h9hjalfc"))))
702 (build-system haskell-build-system)
703 (properties '((upstream-name . "hspec-core")))
704 (inputs (list ghc-hunit
705 ghc-quickcheck
706 ghc-ansi-terminal
707 ghc-call-stack
708 ghc-haskell-lexer
709 ghc-hspec-expectations
710 ghc-quickcheck-io
711 ghc-random
712 ghc-tf-random))
713 (native-inputs (list ghc-base-orphans-bootstrap ghc-hspec-meta
714 ghc-silently-bootstrap ghc-temporary-bootstrap))
715 (arguments
716 `(#:cabal-revision ("1"
717 "0yq9nnawcgbgxiz4ymfa8k66jrvgrhmv8j7g880x8k6q8q4ncqlq")))
718 (home-page "https://hspec.github.io/")
719 (synopsis "Testing framework for Haskell")
720 (description "This library exposes internal types and functions that can
721be used to extend Hspec's functionality.")
722 (license license:expat)))
723
724(define-public ghc-hspec-meta
725 (package
726 (name "ghc-hspec-meta")
727 (version "2.11.12")
728 (source
729 (origin
730 (method url-fetch)
731 (uri (hackage-uri "hspec-meta" version))
732 (sha256
733 (base32 "1612pg5gihqjxrzqqvbbgckaqiwq3rmz3rg07lrjhzklg975nj69"))))
734 (build-system haskell-build-system)
735 (properties '((upstream-name . "hspec-meta")))
736 (inputs (list ghc-hunit
737 ghc-quickcheck
738 ghc-ansi-terminal
739 ghc-call-stack-boot
740 ghc-haskell-lexer
741 ghc-hspec-expectations
742 ghc-quickcheck-io
743 ghc-random
744 ghc-tf-random))
745 (arguments
746 `(#:cabal-revision ("2"
747 "1jrk14s51psb0zjici56220iyb98i3q06sd3rsyx594s3cddgn5d")))
748 (home-page "https://hspec.github.io/")
749 (synopsis "Version of Hspec to test Hspec itself")
750 (description "This library provides a stable version of Hspec which is
751used to test the in-development version of Hspec.")
752 (license license:expat)))
753
754(define-public ghc-hspec
755 (package
756 (name "ghc-hspec")
757 (version "2.11.12")
758 (source
759 (origin
760 (method url-fetch)
761 (uri (hackage-uri "hspec" version))
762 (sha256
763 (base32 "1zdgkn0gkcphcsfqcqwcfqiqvkz12ljks46v3czpaysndz8icfip"))))
764 (build-system haskell-build-system)
765 (properties '((upstream-name . "hspec")))
766 (inputs (list ghc-quickcheck ghc-hspec-core hspec-discover
767 ghc-hspec-expectations))
768 (home-page "https://hspec.github.io/")
769 (synopsis "Testing Framework for Haskell")
770 (description "This library provides the Hspec testing framework for
771Haskell, inspired by the Ruby library RSpec.")
772 (license license:expat)))
773
774(define-public ghc-hspec-api
775 (package
776 (name "ghc-hspec-api")
777 (version "2.11.12")
778 (source
779 (origin
780 (method url-fetch)
781 (uri (hackage-uri "hspec-api" version))
782 (sha256
783 (base32 "1xn2b2hafyq6qm3zaia9nw27ir4cg8v2qn499bz2zwnp2vkjra07"))))
784 (build-system haskell-build-system)
785 (properties '((upstream-name . "hspec-api")))
786 (inputs (list ghc-hspec-core))
787 (native-inputs (list hspec-discover ghc-hspec))
788 (home-page "https://hspec.github.io/")
789 (synopsis "A Testing Framework for Haskell")
790 (description
791 "This package provides a stable API that can be used to extend Hspec's
792functionality.")
793 (license license:expat)))
794
795(define-public ghc-hspec-contrib
796 (package
797 (name "ghc-hspec-contrib")
798 (version "0.5.2")
799 (source
800 (origin
801 (method url-fetch)
802 (uri (hackage-uri "hspec-contrib" version))
803 (sha256
804 (base32 "0002xzvyh790iwf1y33d4nflrbp5sxvpsp010srcfryf1n3qx2b0"))))
805 (build-system haskell-build-system)
806 (properties '((upstream-name . "hspec-contrib")))
807 (inputs (list ghc-hunit ghc-call-stack ghc-hspec-core))
808 (native-inputs (list ghc-quickcheck ghc-hspec hspec-discover))
809 (home-page "https://hspec.github.io/")
810 (synopsis "Contributed functionality for Hspec")
811 (description "This package provides contributed Hspec extensions.")
812 (license license:expat)))
813
814(define-public ghc-hspec-expectations
815 (package
816 (name "ghc-hspec-expectations")
817 (version "0.8.4")
818 (source
819 (origin
820 (method url-fetch)
821 (uri (hackage-uri "hspec-expectations" version))
822 (sha256
823 (base32 "1zr1pqchcwglfr5dvcrgc1l5x924n9w09n2zr68dmkqf4dzdx3bv"))))
824 (build-system haskell-build-system)
825 (properties '((upstream-name . "hspec-expectations")))
826 (inputs (list ghc-hunit ghc-call-stack))
827 (arguments
828 ;; Tests depend on ghc-nanospec.
829 `(#:tests? #f
830 #:cabal-revision ("2"
831 "14zzsjqcz1zbnvi50i82lx84nc8b5da7ar5cazzh44lklyag0ds2")))
832 (home-page "https://github.com/hspec/hspec-expectations#readme")
833 (synopsis "Catchy combinators for HUnit")
834 (description
835 "This library provides catchy combinators for HUnit, see
836@uref{https://github.com/sol/hspec-expectations#readme, the README}.")
837 (license license:expat)))
838
839(define-public ghc-nanospec
840 (package
841 (name "ghc-nanospec")
842 (version "0.2.2")
843 (source
844 (origin
845 (method url-fetch)
846 (uri (hackage-uri "nanospec" version))
847 (sha256
848 (base32
849 "1rcmhl9bhyfvanalnf1r86wkx6rq6wdvagnw1h011jcnnb1cq56g"))))
850 (build-system haskell-build-system)
851 (properties '((upstream-name . "nanospec")))
852 (inputs (list ghc-silently-bootstrap))
853 (native-inputs (list ghc-hspec))
854 (home-page "https://github.com/hspec/nanospec#readme")
855 (synopsis "Lightweight implementation of a subset of Hspec's API")
856 (description
857 "Nanospec is a lightweight implementation of a subset of Hspec's API with
858minimal dependencies.")
859 (license license:expat)))
860
861(define-public ghc-nanospec-bootstrap
862 (package
863 (inherit ghc-nanospec)
864 (name "ghc-nanospec-bootstrap")
865 (arguments '(#:tests? #f))
866 (native-inputs '())
867 (properties '((hidden? #t)))))
868
869(define-public ghc-crypto-cipher-tests
870 (package
871 (name "ghc-crypto-cipher-tests")
872 (version "0.0.11")
873 (source
874 (origin
875 (method url-fetch)
876 (uri (hackage-uri "crypto-cipher-tests" version))
877 (sha256
878 (base32
879 "19wqignlq90qwpam01hnmmrxaxh5lkax9l1l6rlbi4a07nvp1dnz"))))
880 (build-system haskell-build-system)
881 (properties '((upstream-name . "crypto-cipher-tests")))
882 (inputs (list ghc-quickcheck
883 ghc-hunit
884 ghc-test-framework
885 ghc-test-framework-quickcheck2
886 ghc-test-framework-hunit
887 ghc-byteable
888 ghc-securemem
889 ghc-crypto-cipher-types))
890 (home-page "https://github.com/vincenthz/hs-crypto-cipher")
891 (synopsis "Generic cryptography cipher tests for Haskell")
892 (description "This Haskell package contains generic tests for
893cryptographic ciphers, and is used by the test runners of various Haskell
894implementations of cryptographic ciphers.")
895 (license license:bsd-3)))
896
897(define-public ghc-hedgehog
898 (package
899 (name "ghc-hedgehog")
900 (version "1.5")
901 (source
902 (origin
903 (method url-fetch)
904 (uri (hackage-uri "hedgehog" version))
905 (sha256
906 (base32 "0sl6x9q9kyrpv73565w9na9dm10wzxdl0qgiraqarffynfgn0hg9"))))
907 (build-system haskell-build-system)
908 (properties '((upstream-name . "hedgehog")))
909 (inputs (list ghc-ansi-terminal
910 ghc-async
911 ghc-barbies
912 ghc-concurrent-output
913 ghc-erf
914 ghc-lifted-async
915 ghc-mmorph
916 ghc-monad-control
917 ghc-pretty-show
918 ghc-primitive
919 ghc-random
920 ghc-resourcet
921 ghc-safe-exceptions
922 ghc-transformers-base
923 ghc-wl-pprint-annotated))
924 (arguments
925 `(#:cabal-revision ("2"
926 "1m0b9m8dw5nw4b3w1jbp5fd0b0kqlyvvy3qsfxc7md77iafxq169")))
927 (home-page "https://hedgehog.qa")
928 (synopsis "Property-based testing in the spirt of QuickCheck")
929 (description
930 "Hedgehog is a property-based testing system, in the spirit of
931QuickCheck. Hedgehog uses integrated shrinking, so shrinks obey the invariants
932of generated values by construction.
933
934To get started quickly, see the examples:
935@uref{https://github.com/hedgehogqa/haskell-hedgehog/tree/master/hedgehog-example}")
936 (license license:bsd-3)))
937
938;; Deprecated. Don’t use.
939(define-public cabal-doctest
940 (package
941 (name "cabal-doctest")
942 (version "1.0.11")
943 (source
944 (origin
945 (method url-fetch)
946 (uri (hackage-uri "cabal-doctest" version))
947 (sha256
948 (base32 "0gwjpwv2v7c7gs2dvf7ixsxx6likmgw5yi0fy4bqc0i7nkqg4bfw"))))
949 (build-system haskell-build-system)
950 (properties '((upstream-name . "cabal-doctest")))
951 (home-page "https://github.com/ulidtko/cabal-doctest")
952 (synopsis "Setup.hs helper for running doctests")
953 (description
954 "To properly work, the @code{doctest} package needs plenty of
955configuration. This library provides the common bits for writing custom
956@file{Setup.hs} files.")
957 (license license:bsd-3)))
958
959(define-public ghc-testing-type-modifiers
960 (package
961 (name "ghc-testing-type-modifiers")
962 (version "0.1.0.1")
963 (source
964 (origin
965 (method url-fetch)
966 (uri (hackage-uri "testing-type-modifiers" version))
967 (sha256
968 (base32
969 "1wh2n95n39ivv6kbqn42vbzrj8zagsmk6f2al2qj40bg5kgdl2q5"))))
970 (build-system haskell-build-system)
971 (properties '((upstream-name . "testing-type-modifiers")))
972 (home-page "https://hackage.haskell.org/package/testing-type-modifiers")
973 (synopsis "Data type modifiers for property based testing")
974 (description "Property based testing libraries such as QuickCheck tend to
975include type modifiers. Most of them are used to quantify over subsets of a
976type. This library is intended to supply these modifiers to be used by
977testing libraries, in an effort to make properties more portable between
978testing frameworks.")
979 (license license:unlicense)))
980
981(define-public ghc-testing-feat
982 (package
983 (name "ghc-testing-feat")
984 (version "1.1.1.1")
985 (source (origin
986 (method url-fetch)
987 (uri (hackage-uri "testing-feat" version))
988 (sha256
989 (base32
990 "14d6licgrkiw36xj1cshnqxcbx5iwzxwq731xlb1wb5n2sw8ijf2"))))
991 (build-system haskell-build-system)
992 (properties '((upstream-name . "testing-feat")))
993 (inputs (list ghc-quickcheck ghc-size-based ghc-testing-type-modifiers))
994 (home-page "https://github.com/size-based/testing-feat")
995 (synopsis "Functional Enumeration of Algebraic Types")
996 (description
997 "Feat (Functional Enumeration of Algebraic Types)
998provides enumerations as functions from natural numbers to
999values (similar to @code{toEnum} but for any algebraic data type). This
1000can be used for SmallCheck-style systematic testing, QuickCheck-style
1001random testing, and hybrids of the two.")
1002 (license license:bsd-3)))
1003
1004(define-public ghc-inspection-testing
1005 (package
1006 (name "ghc-inspection-testing")
1007 (version "0.6.2")
1008 (source
1009 (origin
1010 (method url-fetch)
1011 (uri (hackage-uri "inspection-testing" version))
1012 (sha256
1013 (base32 "0zi1q86sd9jy5dpqfs2j71acdl7kvik0ps78xirpdhyldhwwyqws"))))
1014 (build-system haskell-build-system)
1015 (properties '((upstream-name . "inspection-testing")))
1016 (home-page "https://github.com/nomeata/inspection-testing")
1017 (synopsis "GHC plugin to do inspection testing")
1018 (description
1019 "Some carefully crafted libraries make promises to their users beyond
1020functionality and performance.
1021
1022Examples are: Fusion libraries promise intermediate data structures to be
1023eliminated. Generic programming libraries promise that the generic
1024implementation is identical to the hand-written one. Some libraries may
1025promise allocation-free or branch-free code.
1026
1027Conventionally, the modus operandi in all these cases is that the library
1028author manually inspects the (intermediate or final) code produced by the
1029compiler. This is not only tedious, but makes it very likely that some change,
1030either in the library itself or the surrounding eco-system, breaks the
1031library's promised without anyone noticing.
1032
1033This package provides a disciplined way of specifying such properties, and
1034have them checked by the compiler. This way, this checking can be part of the
1035regular development cycle and regressions caught early.
1036
1037See the documentation in \"Test.Inspection\" or the project webpage for more
1038examples and more information.")
1039 (license license:expat)))
1040
1041(define-public ghc-quickcheck-classes
1042 (package
1043 (name "ghc-quickcheck-classes")
1044 (version "0.6.5.0")
1045 (source
1046 (origin
1047 (method url-fetch)
1048 (uri (hackage-uri "quickcheck-classes" version))
1049 (sha256
1050 (base32 "19iw15mvb7gws3ljdxqwsbb4pmfc0sfflf8szgmrhiqr3k82mqv2"))))
1051 (build-system haskell-build-system)
1052 (properties '((upstream-name . "quickcheck-classes")))
1053 (inputs (list ghc-quickcheck
1054 ghc-primitive
1055 ghc-primitive-addr
1056 ghc-quickcheck-classes-base
1057 ghc-semigroups-bootstrap
1058 ghc-fail
1059 ghc-tagged
1060 ghc-aeson
1061 ghc-semigroupoids
1062 ghc-semirings
1063 ghc-vector))
1064 (native-inputs (list ghc-base-orphans ghc-base-orphans ghc-tasty
1065 ghc-tasty-quickcheck))
1066 (arguments
1067 `(#:cabal-revision ("3"
1068 "1pawam5rsdcdv21fqc87khzqjm0ixwzklfxd6gk3b2qrr5q66bn5")))
1069 (home-page "https://github.com/andrewthad/quickcheck-classes#readme")
1070 (synopsis "QuickCheck common typeclasses")
1071 (description
1072 "This library provides QuickCheck properties to ensure that typeclass
1073instances adhere to the set of laws that they are supposed to. There are
1074other libraries that do similar things, such as @code{genvalidity-hspec} and
1075@code{checkers}. This library differs from other solutions by not introducing
1076any new typeclasses that the user needs to learn. /Note:/ on GHC < 8.5, this
1077library uses the higher-kinded typeclasses (@code{Data.Functor.Classes.Show1},
1078@code{Data.Functor.Classes.Eq1}, @code{Data.Functor.Classes.Ord1}, etc.), but
1079on GHC >= 8.5, it uses @code{-XQuantifiedConstraints} to express these
1080constraints more cleanly.")
1081 (license license:bsd-3)))
1082
1083(define-public ghc-quickcheck-classes-base
1084 (package
1085 (name "ghc-quickcheck-classes-base")
1086 (version "0.6.2.0")
1087 (source
1088 (origin
1089 (method url-fetch)
1090 (uri (hackage-uri "quickcheck-classes-base" version))
1091 (sha256
1092 (base32 "16c6gq4cqpkwnq1pzkhm6r7mrwk4an50ha5w77bmiia2qkhla6ch"))))
1093 (build-system haskell-build-system)
1094 (properties '((upstream-name . "quickcheck-classes-base")))
1095 (inputs (list ghc-quickcheck
1096 ghc-contravariant
1097 ghc-bifunctors
1098 ghc-semigroups-bootstrap
1099 ghc-fail
1100 ghc-tagged))
1101 (arguments
1102 `(#:cabal-revision ("1"
1103 "1p3v38jhpx0r6rnvaspkkivl8xyq2mq4xnmycgmkj1gr77vplkdr")))
1104 (home-page "https://github.com/andrewthad/quickcheck-classes#readme")
1105 (synopsis "QuickCheck common typeclasses from `base`")
1106 (description
1107 "This library is a minimal variant of `quickcheck-classes` that only
1108provides laws for typeclasses from `base`. The main purpose of splitting this
1109out is so that `primitive` can depend on `quickcheck-classes-base` in its test
1110suite, avoiding the circular dependency that arises if `quickcheck-classes` is
1111used instead. This library provides QuickCheck properties to ensure that
1112typeclass instances adhere to the set of laws that they are supposed to.
1113There are other libraries that do similar things, such as `genvalidity-hspec`
1114and `checkers`. This library differs from other solutions by not introducing
1115any new typeclasses that the user needs to learn. @emph{Note:} on GHC < 8.5,
1116this library uses the higher-kinded typeclasses
1117(@code{Data.Functor.Classes.Show1}, @code{Data.Functor.Classes.Eq1},
1118@code{Data.Functor.Classes.Ord1}, etc.), but on GHC >= 8.5, it uses
1119`-XQuantifiedConstraints` to express these constraints more cleanly.")
1120 (license license:bsd-3)))
1121
1122(define-public ghc-doctest-lib
1123 (package
1124 (name "ghc-doctest-lib")
1125 (version "0.1.1.1")
1126 (source
1127 (origin
1128 (method url-fetch)
1129 (uri (hackage-uri "doctest-lib" version))
1130 (sha256
1131 (base32 "1hb3zx1xzib3v41blnwcbhc2v0rzwdzq7gm4sajqndimwjkkxc67"))))
1132 (build-system haskell-build-system)
1133 (properties '((upstream-name . "doctest-lib")))
1134 (home-page "https://hub.darcs.net/thielema/doctest-lib/")
1135 (synopsis "Parts of doctest exposed as library")
1136 (description
1137 "Parts of doctest exposed as library. For use with the doctest-extract utility.")
1138 (license license:expat)))
1139
1140(define-public ghc-doctest-exitcode-stdio
1141 (package
1142 (name "ghc-doctest-exitcode-stdio")
1143 (version "0.0.0.1")
1144 (source
1145 (origin
1146 (method url-fetch)
1147 (uri (hackage-uri "doctest-exitcode-stdio" version))
1148 (sha256
1149 (base32 "0kg5xiw4giyvqpcj6cxqqnysvixhxlwm0pbg3qks8dzwb5w79dvk"))))
1150 (build-system haskell-build-system)
1151 (properties '((upstream-name . "doctest-exitcode-stdio")))
1152 (inputs (list ghc-doctest-lib ghc-quickcheck ghc-semigroups))
1153 (home-page "https://hub.darcs.net/thielema/doctest-exitcode-stdio/")
1154 (synopsis "Run Doctests in a @code{Cabal.Test.exitcode-stdio} environment")
1155 (description
1156 "This package allows on to run Doctests in a Cabal.Test.exitcode-stdio
1157environment.")
1158 (license license:bsd-3)))
1159
1160(define-public ghc-tasty-silver
1161 (package
1162 (name "ghc-tasty-silver")
1163 (version "3.3.2.1")
1164 (source
1165 (origin
1166 (method url-fetch)
1167 (uri (hackage-uri "tasty-silver" version))
1168 (sha256
1169 (base32 "01w3576kymglcddinh10m1wgy71dia49k2pnw5y1c97jjrhanf17"))))
1170 (build-system haskell-build-system)
1171 (properties '((upstream-name . "tasty-silver")))
1172 (inputs (list ghc-ansi-terminal
1173 ghc-optparse-applicative
1174 ghc-process-extras
1175 ghc-regex-tdfa
1176 ghc-silently
1177 ghc-tagged
1178 ghc-tasty
1179 ghc-temporary))
1180 (native-inputs (list ghc-tasty-hunit))
1181 (home-page "https://github.com/phile314/tasty-silver")
1182 (synopsis "Fancy test runner, including support for golden tests")
1183 (description
1184 "This package provides a fancy test runner and support for @dfn{golden
1185testing}. A golden test is an IO action that writes its result to a file. To
1186pass the test, this output file should be identical to the corresponding
1187``golden'' file, which contains the correct result for the test. The test
1188runner allows filtering tests using regexes, and to interactively inspect the
1189result of golden tests.")
1190 (license license:expat)))
1191
1192(define-public ghc-tasty-inspection-testing
1193 (package
1194 (name "ghc-tasty-inspection-testing")
1195 (version "0.2.1")
1196 (source
1197 (origin
1198 (method url-fetch)
1199 (uri (hackage-uri "tasty-inspection-testing" version))
1200 (sha256
1201 (base32 "0wl2xlnbmqdkwhi4ic6a4q4lxf9qg433lidi8d0hlp3ykrjpbcay"))))
1202 (build-system haskell-build-system)
1203 (properties '((upstream-name . "tasty-inspection-testing")))
1204 (inputs (list ghc-inspection-testing ghc-tasty))
1205 (arguments
1206 `(#:cabal-revision ("2"
1207 "0z9al0hyq381fw146agbpz7rf24rwms1w91m7s0k1w3xbfw16l9n")))
1208 (home-page "https://github.com/Bodigrim/tasty-inspection-testing")
1209 (synopsis "Inspection testing support for tasty")
1210 (description
1211 "Integrate @@inspection-testing@@ into @@tasty@@ test suites.")
1212 (license license:expat)))
1213
1214(define-public ghc-proctest
1215 (package
1216 (name "ghc-proctest")
1217 (version "0.1.3.1")
1218 (source (origin
1219 (method url-fetch)
1220 (uri (hackage-uri "proctest" version))
1221 (sha256
1222 (base32
1223 "0yvhc0l5aj170ymhjx4ig0im0yd7wfa150m5lqhabr8j7cf16l7y"))))
1224 (build-system haskell-build-system)
1225 (properties '((upstream-name . "proctest")))
1226 (inputs (list ghc-hunit ghc-hspec ghc-quickcheck))
1227 (home-page "https://github.com/nh2/proctest")
1228 (synopsis "IO library for testing interactive command line programs")
1229 (description
1230 "This package provides an IO library for testing interactive command line
1231programs. Proctest aims to simplify interacting with and testing terminal
1232programs, providing convenience functions for starting programs and reading
1233their output. All blocking operations support timeouts so that misbehaving
1234programs cannot block your test pipeline. Find more examples and contribute
1235at @url{https://github.com/nh2/proctest}.")
1236 (license license:expat)))