| 1 | ;;; GNU Guix --- Functional package management for GNU |
| 2 | ;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org> |
| 3 | ;;; Copyright © 2015 Eric Bavier <bavier@member.fsf.org> |
| 4 | ;;; Copyright © 2015 Federico Beffa <beffa@fbengineering.ch> |
| 5 | ;;; Copyright © 2015, 2016, 2017, 2018 Ricardo Wurmus <rekado@elephly.net> |
| 6 | ;;; Copyright © 2016 ng0 <ng0@n0.is> |
| 7 | ;;; Copyright © 2016 David Craven <david@craven.ch> |
| 8 | ;;; Copyright © 2017 Danny Milosavljevic <dannym@scratchpost.org> |
| 9 | ;;; Copyright © 2017 rsiddharth <s@ricketyspace.net> |
| 10 | ;;; Copyright © 2017, 2018 Tobias Geerinckx-Rice <me@tobias.gr> |
| 11 | ;;; Copyright © 2018 Tonton <tonton@riseup.net> |
| 12 | ;;; Copyright © 2018 Arun Isaac <arunisaac@systemreboot.net> |
| 13 | ;;; Copyright © 2019 Timothy Sample <samplet@ngyro.com> |
| 14 | ;;; |
| 15 | ;;; This file is part of GNU Guix. |
| 16 | ;;; |
| 17 | ;;; GNU Guix is free software; you can redistribute it and/or modify it |
| 18 | ;;; under the terms of the GNU General Public License as published by |
| 19 | ;;; the Free Software Foundation; either version 3 of the License, or (at |
| 20 | ;;; your option) any later version. |
| 21 | ;;; |
| 22 | ;;; GNU Guix is distributed in the hope that it will be useful, but |
| 23 | ;;; WITHOUT ANY WARRANTY; without even the implied warranty of |
| 24 | ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 25 | ;;; GNU General Public License for more details. |
| 26 | ;;; |
| 27 | ;;; You should have received a copy of the GNU General Public License |
| 28 | ;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>. |
| 29 | |
| 30 | (define-module (gnu packages haskell-check) |
| 31 | #:use-module (gnu packages) |
| 32 | #:use-module (gnu packages haskell-crypto) |
| 33 | #:use-module (gnu packages haskell-xyz) |
| 34 | #:use-module (guix build-system haskell) |
| 35 | #:use-module (guix download) |
| 36 | #:use-module ((guix licenses) #:prefix license:) |
| 37 | #:use-module (guix packages) |
| 38 | #:use-module (guix utils)) |
| 39 | |
| 40 | (define-public ghc-tasty-ant-xml |
| 41 | (package |
| 42 | (name "ghc-tasty-ant-xml") |
| 43 | (version "1.1.6") |
| 44 | (source |
| 45 | (origin |
| 46 | (method url-fetch) |
| 47 | (uri (string-append |
| 48 | "https://hackage.haskell.org/package/tasty-ant-xml/tasty-ant-xml-" |
| 49 | version |
| 50 | ".tar.gz")) |
| 51 | (sha256 |
| 52 | (base32 |
| 53 | "13qqpl1prr9dda87dp45mqybay24n8rhxxgvpc9j34kh72g8j5qw")))) |
| 54 | (build-system haskell-build-system) |
| 55 | (inputs |
| 56 | `(("ghc-generic-deriving" ,ghc-generic-deriving) |
| 57 | ("ghc-xml" ,ghc-xml) |
| 58 | ("ghc-tagged" ,ghc-tagged) |
| 59 | ("ghc-tasty" ,ghc-tasty))) |
| 60 | (home-page |
| 61 | "https://github.com/ocharles/tasty-ant-xml") |
| 62 | (synopsis |
| 63 | "Render tasty output to XML for Jenkins") |
| 64 | (description |
| 65 | "A tasty ingredient to output test results in XML, using the Ant |
| 66 | schema. This XML can be consumed by the Jenkins continuous integration |
| 67 | framework.") |
| 68 | (license license:bsd-3))) |
| 69 | |
| 70 | (define-public ghc-tasty-smallcheck |
| 71 | (package |
| 72 | (name "ghc-tasty-smallcheck") |
| 73 | (version "0.8.1") |
| 74 | (source |
| 75 | (origin |
| 76 | (method url-fetch) |
| 77 | (uri (string-append |
| 78 | "https://hackage.haskell.org/package/tasty-smallcheck/tasty-smallcheck-" |
| 79 | version |
| 80 | ".tar.gz")) |
| 81 | (sha256 |
| 82 | (base32 |
| 83 | "1n66ngzllf3xrlqykwszlkwsi96n5nkm7xbpfq7774vpvfnafjri")))) |
| 84 | (build-system haskell-build-system) |
| 85 | (inputs |
| 86 | `(("ghc-tasty" ,ghc-tasty) |
| 87 | ("ghc-smallcheck" ,ghc-smallcheck) |
| 88 | ("ghc-async" ,ghc-async) |
| 89 | ("ghc-tagged" ,ghc-tagged))) |
| 90 | (home-page "https://documentup.com/feuerbach/tasty") |
| 91 | (synopsis "SmallCheck support for the Tasty test framework") |
| 92 | (description "This package provides SmallCheck support for the Tasty |
| 93 | Haskell test framework.") |
| 94 | (license license:bsd-3))) |
| 95 | |
| 96 | (define-public ghc-tasty-quickcheck |
| 97 | (package |
| 98 | (name "ghc-tasty-quickcheck") |
| 99 | (version "0.10.1") |
| 100 | (source |
| 101 | (origin |
| 102 | (method url-fetch) |
| 103 | (uri (string-append |
| 104 | "https://hackage.haskell.org/package/tasty-quickcheck/" |
| 105 | "tasty-quickcheck-" version ".tar.gz")) |
| 106 | (sha256 |
| 107 | (base32 |
| 108 | "0k4vvd5vmrncv1s6gdf03l4xijwlk428sb9jfx8n1zaz02971msh")))) |
| 109 | (build-system haskell-build-system) |
| 110 | (inputs |
| 111 | `(("ghc-quickcheck" ,ghc-quickcheck) |
| 112 | ("ghc-tagged" ,ghc-tagged) |
| 113 | ("ghc-tasty" ,ghc-tasty) |
| 114 | ("ghc-random" ,ghc-random) |
| 115 | ("ghc-ansi-terminal" ,ghc-ansi-terminal) |
| 116 | ("ghc-tasty-hunit" ,ghc-tasty-hunit) |
| 117 | ("ghc-pcre-light" ,ghc-pcre-light))) |
| 118 | (home-page "http://documentup.com/feuerbach/tasty") |
| 119 | (synopsis "QuickCheck support for the Tasty test framework") |
| 120 | (description "This package provides QuickCheck support for the Tasty |
| 121 | Haskell test framework.") |
| 122 | (license license:expat))) |
| 123 | |
| 124 | (define-public ghc-tasty-golden |
| 125 | (package |
| 126 | (name "ghc-tasty-golden") |
| 127 | (version "2.3.2") |
| 128 | (source |
| 129 | (origin |
| 130 | (method url-fetch) |
| 131 | (uri (string-append |
| 132 | "https://hackage.haskell.org/package/tasty-golden/tasty-golden-" |
| 133 | version |
| 134 | ".tar.gz")) |
| 135 | (sha256 |
| 136 | (base32 |
| 137 | "0k3ibjhjc9vcwzrjnl4rnwvfm8l81q347nb7dgvcib6n5wm3s404")))) |
| 138 | (build-system haskell-build-system) |
| 139 | (inputs |
| 140 | `(("ghc-temporary" ,ghc-temporary) |
| 141 | ("ghc-tasty" ,ghc-tasty) |
| 142 | ("ghc-optparse-applicative" ,ghc-optparse-applicative) |
| 143 | ("ghc-tagged" ,ghc-tagged) |
| 144 | ("ghc-async" ,ghc-async) |
| 145 | ("ghc-tasty-hunit" ,ghc-tasty-hunit) |
| 146 | ("ghc-temporary-rc" ,ghc-temporary-rc))) |
| 147 | (home-page |
| 148 | "https://github.com/feuerbach/tasty-golden") |
| 149 | (synopsis "Golden tests support for tasty") |
| 150 | (description |
| 151 | "This package provides support for @code{golden testing}. A @dfn{golden |
| 152 | test} is an IO action that writes its result to a file. To pass the test, this |
| 153 | output file should be identical to the corresponding @code{golden} file, which |
| 154 | contains the correct result for the test.") |
| 155 | (license license:expat))) |
| 156 | |
| 157 | (define-public ghc-tasty |
| 158 | (package |
| 159 | (name "ghc-tasty") |
| 160 | (version "1.2.3") |
| 161 | (source |
| 162 | (origin |
| 163 | (method url-fetch) |
| 164 | (uri (string-append |
| 165 | "https://hackage.haskell.org/package/tasty/tasty-" |
| 166 | version |
| 167 | ".tar.gz")) |
| 168 | (sha256 |
| 169 | (base32 |
| 170 | "0qpn0avpw4w1qq5r2gwh2piipj0llqq6ylagr3xnqiraq6mhg8cc")))) |
| 171 | (build-system haskell-build-system) |
| 172 | (inputs |
| 173 | `(("ghc-tagged" ,ghc-tagged) |
| 174 | ("ghc-regex-tdfa" ,ghc-regex-tdfa) |
| 175 | ("ghc-optparse-applicative" ,ghc-optparse-applicative) |
| 176 | ("ghc-unbounded-delays" ,ghc-unbounded-delays) |
| 177 | ("ghc-async" ,ghc-async) |
| 178 | ("ghc-ansi-terminal" ,ghc-ansi-terminal) |
| 179 | ("ghc-clock-bootstrap" ,ghc-clock-bootstrap) |
| 180 | ("ghc-wcwidth" ,ghc-wcwidth-bootstrap))) |
| 181 | (home-page "http://documentup.com/feuerbach/tasty") |
| 182 | (synopsis "Modern and extensible testing framework") |
| 183 | (description "Tasty is a modern testing framework for Haskell. It lets |
| 184 | you combine your unit tests, golden tests, QuickCheck/SmallCheck properties, |
| 185 | and any other types of tests into a single test suite.") |
| 186 | (license license:expat))) |
| 187 | |
| 188 | (define-public ghc-tasty-hedgehog |
| 189 | (package |
| 190 | (name "ghc-tasty-hedgehog") |
| 191 | (version "1.0.0.1") |
| 192 | (source |
| 193 | (origin |
| 194 | (method url-fetch) |
| 195 | (uri (string-append "https://hackage.haskell.org/package/" |
| 196 | "tasty-hedgehog/tasty-hedgehog-" version ".tar.gz")) |
| 197 | (sha256 |
| 198 | (base32 |
| 199 | "1mbg5q0c0xfrk4npfj60pi693igb7r5l78x6xf9fk2jglw0nmxhz")))) |
| 200 | (build-system haskell-build-system) |
| 201 | (inputs |
| 202 | `(("ghc-tagged" ,ghc-tagged) |
| 203 | ("ghc-tasty" ,ghc-tasty) |
| 204 | ("ghc-hedgehog" ,ghc-hedgehog))) |
| 205 | (native-inputs |
| 206 | `(("ghc-tasty-expected-failure" ,ghc-tasty-expected-failure))) |
| 207 | (arguments |
| 208 | `(#:cabal-revision |
| 209 | ("1" "1n6797fm8swyrk8cw7zxz593gq82wx8dayvm204rmgcz75bslcpn"))) |
| 210 | (home-page "https://github.com/qfpl/tasty-hedgehog") |
| 211 | (synopsis "Integration for tasty and hedgehog") |
| 212 | (description "This package provides the means for integrating the |
| 213 | @url{https://hackage.haskell.org/package/hedgehog, hedgehog testing library} |
| 214 | with the @url{https://hackage.haskell.org/package/tasty, tasty testing |
| 215 | framework}.") |
| 216 | (license license:bsd-3))) |
| 217 | |
| 218 | (define-public ghc-tasty-hunit |
| 219 | (package |
| 220 | (name "ghc-tasty-hunit") |
| 221 | (version "0.10.0.2") |
| 222 | (source |
| 223 | (origin |
| 224 | (method url-fetch) |
| 225 | (uri (string-append |
| 226 | "https://hackage.haskell.org/package/tasty-hunit/tasty-hunit-" |
| 227 | version |
| 228 | ".tar.gz")) |
| 229 | (sha256 |
| 230 | (base32 |
| 231 | "1xvf5xs0r8xqkcg354klz4wyzwyzvinalyl6f4fnxwqmzrgch8s8")))) |
| 232 | (build-system haskell-build-system) |
| 233 | (inputs |
| 234 | `(("ghc-call-stack" ,ghc-call-stack-boot) |
| 235 | ("ghc-tasty" ,ghc-tasty))) |
| 236 | (home-page "http://documentup.com/feuerbach/tasty") |
| 237 | (synopsis "HUnit support for the Tasty test framework") |
| 238 | (description "This package provides HUnit support for the Tasty Haskell |
| 239 | test framework.") |
| 240 | (license license:expat))) |
| 241 | |
| 242 | (define-public ghc-tasty-kat |
| 243 | (package |
| 244 | (name "ghc-tasty-kat") |
| 245 | (version "0.0.3") |
| 246 | (source (origin |
| 247 | (method url-fetch) |
| 248 | (uri (string-append "https://hackage.haskell.org/package/" |
| 249 | "tasty-kat/tasty-kat-" version ".tar.gz")) |
| 250 | (sha256 |
| 251 | (base32 |
| 252 | "14yvlpli6cv6bn3kh8mlfp4x1l6ns4fvmfv6hmj75cvxyzq029d7")))) |
| 253 | (build-system haskell-build-system) |
| 254 | (inputs |
| 255 | `(("ghc-tasty" ,ghc-tasty) |
| 256 | ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck) |
| 257 | ("ghc-tasty-hunit" ,ghc-tasty-hunit))) |
| 258 | (home-page "https://github.com/vincenthz/tasty-kat") |
| 259 | (synopsis "Known Answer Tests (KAT) framework for tasty") |
| 260 | (description |
| 261 | "This package provides a @dfn{Known Answer Tests} (KAT) framework for |
| 262 | tasty.") |
| 263 | (license license:expat))) |
| 264 | |
| 265 | (define-public ghc-tasty-lua |
| 266 | (package |
| 267 | (name "ghc-tasty-lua") |
| 268 | (version "0.2.0.1") |
| 269 | (source |
| 270 | (origin |
| 271 | (method url-fetch) |
| 272 | (uri (string-append "https://hackage.haskell.org/package/" |
| 273 | "tasty-lua/tasty-lua-" version ".tar.gz")) |
| 274 | (sha256 |
| 275 | (base32 |
| 276 | "0xlj36rrhkx312h7smx6ay20rhlhxvw2ma2ckdnzv1pvmdn6p5qx")))) |
| 277 | (build-system haskell-build-system) |
| 278 | (inputs |
| 279 | `(("ghc-file-embed" ,ghc-file-embed) |
| 280 | ("ghc-hslua" ,ghc-hslua) |
| 281 | ("ghc-tasty" ,ghc-tasty))) |
| 282 | (native-inputs |
| 283 | `(("ghc-tasty-hunit" ,ghc-tasty-hunit))) |
| 284 | (home-page "https://github.com/hslua/tasty-lua") |
| 285 | (synopsis "Write tests in Lua, integrate into tasty") |
| 286 | (description "This package gives users the ability to define tasty tests |
| 287 | from Lua.") |
| 288 | (license license:expat))) |
| 289 | |
| 290 | (define-public ghc-tasty-th |
| 291 | (package |
| 292 | (name "ghc-tasty-th") |
| 293 | (version "0.1.7") |
| 294 | (source |
| 295 | (origin |
| 296 | (method url-fetch) |
| 297 | (uri (string-append |
| 298 | "https://hackage.haskell.org/package/tasty-th/tasty-th-" |
| 299 | version ".tar.gz")) |
| 300 | (sha256 |
| 301 | (base32 |
| 302 | "0b2ivrw2257m4cy4rjnkwqlarh83j1y3zywnmaqqqbvy667sqnj3")))) |
| 303 | (build-system haskell-build-system) |
| 304 | (inputs |
| 305 | `(("ghc-haskell-src-exts" ,ghc-haskell-src-exts) |
| 306 | ("ghc-tasty" ,ghc-tasty) |
| 307 | ("ghc-tasty-hunit" ,ghc-tasty-hunit))) |
| 308 | (home-page "https://github.com/bennofs/tasty-th") |
| 309 | (synopsis "Automatically generate tasty TestTrees") |
| 310 | (description |
| 311 | "Tasty-th automatically generates tasty TestTrees from functions of the |
| 312 | current module, using TemplateHaskell. This is a fork the original |
| 313 | test-framework-th package, modified to work with tasty instead of |
| 314 | test-framework.") |
| 315 | (license license:bsd-3))) |
| 316 | |
| 317 | (define-public ghc-tasty-rerun |
| 318 | (package |
| 319 | (name "ghc-tasty-rerun") |
| 320 | (version "1.1.14") |
| 321 | (source (origin |
| 322 | (method url-fetch) |
| 323 | (uri (string-append |
| 324 | "https://hackage.haskell.org/package/tasty-rerun/" |
| 325 | "tasty-rerun-" version ".tar.gz")) |
| 326 | (sha256 |
| 327 | (base32 |
| 328 | "0s0zj8ds4g1w2cjzm2lh25ivg962jigqdrbj08v3dbz64lx4mlzr")))) |
| 329 | (build-system haskell-build-system) |
| 330 | (inputs |
| 331 | `(("ghc-optparse-applicative" ,ghc-optparse-applicative) |
| 332 | ("ghc-reducers" ,ghc-reducers) |
| 333 | ("ghc-split" ,ghc-split) |
| 334 | ("ghc-tagged" ,ghc-tagged) |
| 335 | ("ghc-tasty" ,ghc-tasty))) |
| 336 | (home-page "https://github.com/ocharles/tasty-rerun") |
| 337 | (synopsis "Run tests by filtering the test tree") |
| 338 | (description "This package adds the ability to run tests by filtering the |
| 339 | test tree based on the result of a previous test run. You can use this to run |
| 340 | only those tests that failed in the last run, or to only run the tests that have |
| 341 | been added since previous test run.") |
| 342 | (license license:bsd-3))) |
| 343 | |
| 344 | (define-public ghc-tasty-expected-failure |
| 345 | (package |
| 346 | (name "ghc-tasty-expected-failure") |
| 347 | (version "0.11.1.2") |
| 348 | (source |
| 349 | (origin |
| 350 | (method url-fetch) |
| 351 | (uri (string-append "https://hackage.haskell.org/package/" |
| 352 | "tasty-expected-failure/tasty-expected-failure-" |
| 353 | version ".tar.gz")) |
| 354 | (sha256 |
| 355 | (base32 |
| 356 | "175gdk1mkslcwjxajkbl4zmaigzf8h4svzd7va5qb519y0dxk28n")))) |
| 357 | (build-system haskell-build-system) |
| 358 | (inputs |
| 359 | `(("ghc-tagged" ,ghc-tagged) |
| 360 | ("ghc-tasty" ,ghc-tasty))) |
| 361 | (home-page "http://github.com/nomeata/tasty-expected-failure") |
| 362 | (synopsis "Mark tasty tests as failure expected") |
| 363 | (description |
| 364 | "With the function @code{Test.Tasty.ExpectedFailure.expectFail} in the |
| 365 | provided module @code{Test.Tasty.ExpectedFailure}, you can mark that you |
| 366 | expect test cases to fail, and not to pass. This can be used for test-driven |
| 367 | development.") |
| 368 | (license license:expat))) |
| 369 | |
| 370 | (define-public ghc-quickcheck-instances |
| 371 | (package |
| 372 | (name "ghc-quickcheck-instances") |
| 373 | (version "0.3.22") |
| 374 | (source |
| 375 | (origin |
| 376 | (method url-fetch) |
| 377 | (uri (string-append |
| 378 | "https://hackage.haskell.org/package/" |
| 379 | "quickcheck-instances/quickcheck-instances-" |
| 380 | version ".tar.gz")) |
| 381 | (sha256 |
| 382 | (base32 |
| 383 | "14asr9r7da3w7p4hjj51w2yb002nz8x0np8hdz9z4yjvi60vyrax")))) |
| 384 | (build-system haskell-build-system) |
| 385 | (arguments |
| 386 | `(#:cabal-revision |
| 387 | ("2" "1ia5fjhpg7rz793552v88gv2iqx7hl9mi2g09m0llasy1cpzc9jr"))) |
| 388 | (inputs |
| 389 | `(("ghc-quickcheck" ,ghc-quickcheck) |
| 390 | ("ghc-base-compat" ,ghc-base-compat) |
| 391 | ("ghc-case-insensitive" ,ghc-case-insensitive) |
| 392 | ("ghc-hashable" ,ghc-hashable) |
| 393 | ("ghc-old-time" ,ghc-old-time) |
| 394 | ("ghc-scientific" ,ghc-scientific) |
| 395 | ("ghc-tagged" ,ghc-tagged) |
| 396 | ("ghc-time-compat" ,ghc-time-compat) |
| 397 | ("ghc-transformers-compat" ,ghc-transformers-compat) |
| 398 | ("ghc-unordered-containers" ,ghc-unordered-containers) |
| 399 | ("ghc-uuid-types" ,ghc-uuid-types) |
| 400 | ("ghc-vector" ,ghc-vector))) |
| 401 | (home-page "https://github.com/aslatter/qc-instances") |
| 402 | (synopsis "Common quickcheck instances") |
| 403 | (description "This package provides QuickCheck instances for types |
| 404 | provided by the Haskell Platform.") |
| 405 | (license license:bsd-3))) |
| 406 | |
| 407 | (define-public ghc-quickcheck-unicode |
| 408 | (package |
| 409 | (name "ghc-quickcheck-unicode") |
| 410 | (version "1.0.1.0") |
| 411 | (source |
| 412 | (origin |
| 413 | (method url-fetch) |
| 414 | (uri (string-append |
| 415 | "https://hackage.haskell.org/package/quickcheck-unicode/" |
| 416 | "quickcheck-unicode-" version ".tar.gz")) |
| 417 | (sha256 |
| 418 | (base32 |
| 419 | "0s43s1bzbg3gwsjgm7fpyksd1339f0m26dlw2famxwyzgvm0a80k")))) |
| 420 | (build-system haskell-build-system) |
| 421 | (inputs `(("ghc-quickcheck" ,ghc-quickcheck))) |
| 422 | (home-page |
| 423 | "https://github.com/bos/quickcheck-unicode") |
| 424 | (synopsis "Generator functions Unicode-related tests") |
| 425 | (description "This package provides generator and shrink functions for |
| 426 | testing Unicode-related software.") |
| 427 | (license license:bsd-3))) |
| 428 | |
| 429 | (define-public ghc-quickcheck-io |
| 430 | (package |
| 431 | (name "ghc-quickcheck-io") |
| 432 | (version "0.2.0") |
| 433 | (source |
| 434 | (origin |
| 435 | (method url-fetch) |
| 436 | (uri (string-append |
| 437 | "https://hackage.haskell.org/package/quickcheck-io/quickcheck-io-" |
| 438 | version |
| 439 | ".tar.gz")) |
| 440 | (sha256 |
| 441 | (base32 |
| 442 | "08k4v7pkgjf30pv5j2dfv1gqv6hclxlniyq2sps8zq4zswcr2xzv")))) |
| 443 | (build-system haskell-build-system) |
| 444 | (inputs |
| 445 | `(("ghc-quickcheck" ,ghc-quickcheck) |
| 446 | ("ghc-hunit" ,ghc-hunit))) |
| 447 | (home-page |
| 448 | "https://github.com/hspec/quickcheck-io#readme") |
| 449 | (synopsis "Use HUnit assertions as QuickCheck properties") |
| 450 | (description "This package provides an orphan instance that allows you to |
| 451 | use HUnit assertions as QuickCheck properties.") |
| 452 | (license license:expat))) |
| 453 | |
| 454 | (define-public ghc-quickcheck |
| 455 | (package |
| 456 | (name "ghc-quickcheck") |
| 457 | (version "2.13.2") |
| 458 | (outputs '("out" "doc")) |
| 459 | (source |
| 460 | (origin |
| 461 | (method url-fetch) |
| 462 | (uri (string-append |
| 463 | "https://hackage.haskell.org/package/QuickCheck/QuickCheck-" |
| 464 | version |
| 465 | ".tar.gz")) |
| 466 | (sha256 |
| 467 | (base32 |
| 468 | "0426j43af8v3qmdjjqxivazsvr3a2brac8yw09vpgpjkb2m0nmkv")))) |
| 469 | (build-system haskell-build-system) |
| 470 | (arguments |
| 471 | `(#:tests? #f)) ; FIXME: currently missing libraries used for tests. |
| 472 | (inputs |
| 473 | `(("ghc-random" ,ghc-random) |
| 474 | ("ghc-splitmix" ,ghc-splitmix-bootstrap) |
| 475 | ("ghc-tf-random" ,ghc-tf-random))) |
| 476 | (home-page "https://github.com/nick8325/quickcheck") |
| 477 | (synopsis "Automatic testing of Haskell programs") |
| 478 | (description |
| 479 | "QuickCheck is a library for random testing of program properties. The |
| 480 | programmer provides a specification of the program, in the form of properties |
| 481 | which functions should satisfy, and QuickCheck then tests that the properties |
| 482 | hold in a large number of randomly generated cases. Specifications are |
| 483 | expressed in Haskell, using combinators defined in the QuickCheck library.") |
| 484 | (license license:bsd-3))) |
| 485 | |
| 486 | (define-public ghc-test-framework |
| 487 | (package |
| 488 | (name "ghc-test-framework") |
| 489 | (version "0.8.2.0") |
| 490 | (source |
| 491 | (origin |
| 492 | (method url-fetch) |
| 493 | (uri (string-append "https://hackage.haskell.org/package/test-framework/" |
| 494 | "test-framework-" version ".tar.gz")) |
| 495 | (sha256 |
| 496 | (base32 |
| 497 | "1hhacrzam6b8f10hyldmjw8pb7frdxh04rfg3farxcxwbnhwgbpm")))) |
| 498 | (build-system haskell-build-system) |
| 499 | (arguments |
| 500 | `(#:tests? #f ; FIXME: Tests do not build. |
| 501 | #:cabal-revision |
| 502 | ("5" "18g92ajx3ghznd6k3ihj22ln29n676ailzwx3k0f1kj3bmpilnh6"))) |
| 503 | (native-inputs |
| 504 | `(("ghc-hunit" ,ghc-hunit) |
| 505 | ("ghc-quickcheck" ,ghc-quickcheck))) |
| 506 | (inputs |
| 507 | `(("ghc-ansi-terminal" ,ghc-ansi-terminal) |
| 508 | ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint) |
| 509 | ("ghc-hostname" ,ghc-hostname) |
| 510 | ("ghc-old-locale" ,ghc-old-locale) |
| 511 | ("ghc-random" ,ghc-random) |
| 512 | ("ghc-regex-posix" ,ghc-regex-posix) |
| 513 | ("ghc-xml" ,ghc-xml) |
| 514 | ("ghc-libxml" ,ghc-libxml) |
| 515 | ("ghc-semigroups" ,ghc-semigroups-bootstrap))) |
| 516 | (home-page "https://batterseapower.github.io/test-framework/") |
| 517 | (synopsis "Framework for running and organising tests") |
| 518 | (description |
| 519 | "This package allows tests such as QuickCheck properties and HUnit test |
| 520 | cases to be assembled into test groups, run in parallel (but reported in |
| 521 | deterministic order, to aid diff interpretation) and filtered and controlled |
| 522 | by command line options. All of this comes with colored test output, progress |
| 523 | reporting and test statistics output.") |
| 524 | (license license:bsd-3))) |
| 525 | |
| 526 | (define-public ghc-test-framework-hunit |
| 527 | (package |
| 528 | (name "ghc-test-framework-hunit") |
| 529 | (version "0.3.0.2") |
| 530 | (source |
| 531 | (origin |
| 532 | (method url-fetch) |
| 533 | (uri (string-append "https://hackage.haskell.org/package/" |
| 534 | "test-framework-hunit/test-framework-hunit-" |
| 535 | version ".tar.gz")) |
| 536 | (sha256 |
| 537 | (base32 |
| 538 | "1y0b6vg8nfm43v90lxxcydhi6qlxhfy4vpxbzm5ic2w55bh8xjwm")))) |
| 539 | (build-system haskell-build-system) |
| 540 | (arguments |
| 541 | `(#:cabal-revision |
| 542 | ("3" "0i9mlalv7cl1iq43ld5myrnpszq5rxmd79hk495dcb08rglhgl3z"))) |
| 543 | (inputs |
| 544 | `(("ghc-extensible-exceptions" ,ghc-extensible-exceptions) |
| 545 | ("ghc-hunit" ,ghc-hunit) |
| 546 | ("ghc-test-framework" ,ghc-test-framework))) |
| 547 | (home-page "https://batterseapower.github.io/test-framework/") |
| 548 | (synopsis "HUnit support for test-framework") |
| 549 | (description |
| 550 | "This package provides HUnit support for the test-framework package.") |
| 551 | (license license:bsd-3))) |
| 552 | |
| 553 | (define-public ghc-test-framework-quickcheck2 |
| 554 | (package |
| 555 | (name "ghc-test-framework-quickcheck2") |
| 556 | (version "0.3.0.5") |
| 557 | (source |
| 558 | (origin |
| 559 | (method url-fetch) |
| 560 | (uri (string-append "https://hackage.haskell.org/package/" |
| 561 | "test-framework-quickcheck2/" |
| 562 | "test-framework-quickcheck2-" version ".tar.gz")) |
| 563 | (sha256 |
| 564 | (base32 |
| 565 | "0ngf9vvby4nrdf1i7dxf5m9jn0g2pkq32w48xdr92n9hxka7ixn9")))) |
| 566 | (build-system haskell-build-system) |
| 567 | (arguments |
| 568 | `(#:cabal-revision |
| 569 | ("1" "1vmpk70h1594h9s216d3ngkb399fpny1d3sh4gg0vrc75p4as68d"))) |
| 570 | (inputs |
| 571 | `(("ghc-extensible-exceptions" ,ghc-extensible-exceptions) |
| 572 | ("ghc-quickcheck" ,ghc-quickcheck) |
| 573 | ("ghc-random" ,ghc-random) |
| 574 | ("ghc-test-framework" ,ghc-test-framework))) |
| 575 | (home-page "https://batterseapower.github.io/test-framework/") |
| 576 | (synopsis "QuickCheck2 support for test-framework") |
| 577 | (description |
| 578 | "This package provides QuickCheck2 support for the test-framework |
| 579 | package.") |
| 580 | (license license:bsd-3))) |
| 581 | |
| 582 | (define-public ghc-test-framework-th |
| 583 | (package |
| 584 | (name "ghc-test-framework-th") |
| 585 | (version "0.2.4") |
| 586 | (source |
| 587 | (origin |
| 588 | (method url-fetch) |
| 589 | (uri (string-append "https://hackage.haskell.org/package/" |
| 590 | "test-framework-th-" version "/" |
| 591 | "test-framework-th-" version ".tar.gz")) |
| 592 | (sha256 |
| 593 | (base32 |
| 594 | "12lw7yj02jb9s0i7rb98jjam43j2h0gzmnbj9zi933fx7sg0sy4b")))) |
| 595 | (build-system haskell-build-system) |
| 596 | (inputs |
| 597 | `(("ghc-test-framework" ,ghc-test-framework) |
| 598 | ("ghc-language-haskell-extract" ,ghc-language-haskell-extract) |
| 599 | ("ghc-haskell-src-exts" ,ghc-haskell-src-exts) |
| 600 | ("ghc-regex-posix" ,ghc-regex-posix))) |
| 601 | (home-page "https://github.com/finnsson/test-generator") |
| 602 | (synopsis "Auto generate the HUnit- and Quickcheck-bulk-code |
| 603 | using Template Haskell") |
| 604 | (description "This library contains two functions: |
| 605 | @code{defaultMainGenerator} and @code{testGroupGenerator}. |
| 606 | |
| 607 | @code{defaultMainGenerator} will extract all functions beginning with |
| 608 | @code{case_}, @code{prop_}, or @code{test_} in the module and put them in a |
| 609 | @code{testGroup}. |
| 610 | |
| 611 | @code{testGroupGenerator} is like @code{defaultMainGenerator} but without |
| 612 | @code{defaultMain}. It is useful if you need a function for the testgroup |
| 613 | \(e.g. if you want to be able to call the testgroup from another module).") |
| 614 | (license license:bsd-3))) |
| 615 | |
| 616 | (define-public ghc-hunit |
| 617 | (package |
| 618 | (name "ghc-hunit") |
| 619 | (version "1.6.0.0") |
| 620 | (outputs '("out" "doc")) |
| 621 | (source |
| 622 | (origin |
| 623 | (method url-fetch) |
| 624 | (uri (string-append "https://hackage.haskell.org/package/HUnit/" |
| 625 | "HUnit-" version ".tar.gz")) |
| 626 | (sha256 |
| 627 | (base32 |
| 628 | "1pnhwqq5v8h48gbp3ibv3skfj25mf4zs5svxcavq93p9cswycj3l")))) |
| 629 | (build-system haskell-build-system) |
| 630 | (inputs |
| 631 | ;; We cannot use ghc-call-stack there, because it depends on |
| 632 | ;; ghc-nanospec, which depends on ghc-hunit. |
| 633 | `(("ghc-call-stack" ,ghc-call-stack-boot))) |
| 634 | (home-page "http://hunit.sourceforge.net/") |
| 635 | (synopsis "Unit testing framework for Haskell") |
| 636 | (description |
| 637 | "HUnit is a unit testing framework for Haskell, inspired by the |
| 638 | JUnit tool for Java.") |
| 639 | (license license:bsd-3))) |
| 640 | |
| 641 | (define-public hspec-discover |
| 642 | (package |
| 643 | (name "hspec-discover") |
| 644 | (version "2.7.1") |
| 645 | (source |
| 646 | (origin |
| 647 | (method url-fetch) |
| 648 | (uri (string-append "https://hackage.haskell.org/package/" |
| 649 | "hspec-discover/hspec-discover-" |
| 650 | version ".tar.gz")) |
| 651 | (sha256 |
| 652 | (base32 |
| 653 | "0r47fm94wa6qrhp8cc1zzkjrxc32rnagfn9m9ga4dm6p6ydw4c8b")))) |
| 654 | (build-system haskell-build-system) |
| 655 | (native-inputs |
| 656 | `(("ghc-quickcheck" ,ghc-quickcheck) |
| 657 | ("ghc-hspec-meta" ,ghc-hspec-meta))) |
| 658 | (home-page "https://hspec.github.io/") |
| 659 | (synopsis "Automatically discover and run Hspec tests") |
| 660 | (description "hspec-discover is a tool which automatically discovers and |
| 661 | runs Hspec tests.") |
| 662 | (license license:expat))) |
| 663 | |
| 664 | (define-public ghc-hspec-core |
| 665 | (package |
| 666 | (name "ghc-hspec-core") |
| 667 | (version "2.7.1") |
| 668 | (source |
| 669 | (origin |
| 670 | (method url-fetch) |
| 671 | (uri (string-append "https://hackage.haskell.org/package/hspec-core/" |
| 672 | "hspec-core-" version ".tar.gz")) |
| 673 | (sha256 |
| 674 | (base32 |
| 675 | "08vk8588lap00hsln8zl64dazbb28lzk4b4h5vnm7xvhg7r21k1c")))) |
| 676 | (build-system haskell-build-system) |
| 677 | (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing. |
| 678 | (inputs |
| 679 | `(("ghc-setenv" ,ghc-setenv) |
| 680 | ("ghc-ansi-terminal" ,ghc-ansi-terminal) |
| 681 | ("ghc-clock" ,ghc-clock) |
| 682 | ("ghc-quickcheck-io" ,ghc-quickcheck-io) |
| 683 | ("ghc-hunit" ,ghc-hunit) |
| 684 | ("ghc-quickcheck" ,ghc-quickcheck) |
| 685 | ("ghc-hspec-expectations" ,ghc-hspec-expectations) |
| 686 | ("ghc-silently" ,ghc-silently) |
| 687 | ("ghc-tf-random" ,ghc-tf-random))) |
| 688 | (home-page "https://hspec.github.io/") |
| 689 | (synopsis "Testing framework for Haskell") |
| 690 | (description "This library exposes internal types and functions that can |
| 691 | be used to extend Hspec's functionality.") |
| 692 | (license license:expat))) |
| 693 | |
| 694 | (define-public ghc-hspec-meta |
| 695 | (package |
| 696 | (name "ghc-hspec-meta") |
| 697 | (version "2.6.0") |
| 698 | (source |
| 699 | (origin |
| 700 | (method url-fetch) |
| 701 | (uri (string-append "https://hackage.haskell.org/package/hspec-meta/" |
| 702 | "hspec-meta-" version ".tar.gz")) |
| 703 | (sha256 |
| 704 | (base32 |
| 705 | "1n1a4633wfivylglji8920f67mx7qz8j4q58n8p7dxk6yg4h3mz6")))) |
| 706 | (build-system haskell-build-system) |
| 707 | (inputs |
| 708 | `(("ghc-quickcheck" ,ghc-quickcheck) |
| 709 | ("ghc-hunit" ,ghc-hunit) |
| 710 | ("ghc-ansi-terminal" ,ghc-ansi-terminal) |
| 711 | ("ghc-clock" ,ghc-clock) |
| 712 | ("ghc-hspec-expectations" ,ghc-hspec-expectations) |
| 713 | ("ghc-setenv" ,ghc-setenv) |
| 714 | ("ghc-random" ,ghc-random) |
| 715 | ("ghc-quickcheck-io" ,ghc-quickcheck-io))) |
| 716 | (home-page "https://hspec.github.io/") |
| 717 | (synopsis "Version of Hspec to test Hspec itself") |
| 718 | (description "This library provides a stable version of Hspec which is |
| 719 | used to test the in-development version of Hspec.") |
| 720 | (license license:expat))) |
| 721 | |
| 722 | (define-public ghc-hspec |
| 723 | (package |
| 724 | (name "ghc-hspec") |
| 725 | (version "2.7.1") |
| 726 | (source |
| 727 | (origin |
| 728 | (method url-fetch) |
| 729 | (uri (string-append "https://hackage.haskell.org/package/hspec/" |
| 730 | "hspec-" version ".tar.gz")) |
| 731 | (sha256 |
| 732 | (base32 |
| 733 | "1x8rcr7j1azcaw0fg1xzp8j0gr4ias36z09aj24i4xp8pnyfp341")))) |
| 734 | (build-system haskell-build-system) |
| 735 | (inputs |
| 736 | `(("ghc-hspec-core" ,ghc-hspec-core) |
| 737 | ("hspec-discover" ,hspec-discover) |
| 738 | ("ghc-hspec-expectations" ,ghc-hspec-expectations) |
| 739 | ("ghc-quickcheck" ,ghc-quickcheck) |
| 740 | ("ghc-hunit" ,ghc-hunit) |
| 741 | ("ghc-stringbuilder" ,ghc-stringbuilder) |
| 742 | ("ghc-hspec-meta" ,ghc-hspec-meta))) |
| 743 | (home-page "https://hspec.github.io/") |
| 744 | (synopsis "Testing Framework for Haskell") |
| 745 | (description "This library provides the Hspec testing framework for |
| 746 | Haskell, inspired by the Ruby library RSpec.") |
| 747 | (license license:expat))) |
| 748 | |
| 749 | (define-public ghc-hspec-contrib |
| 750 | (package |
| 751 | (name "ghc-hspec-contrib") |
| 752 | (version "0.5.1") |
| 753 | (source (origin |
| 754 | (method url-fetch) |
| 755 | (uri (string-append "https://hackage.haskell.org/package/" |
| 756 | "hspec-contrib/hspec-contrib-" |
| 757 | version ".tar.gz")) |
| 758 | (sha256 |
| 759 | (base32 |
| 760 | "0hhzxaa3fxz5mk5qcsrnfr98a7bn3szx2ydgr0x9mbqmm1jg06rc")))) |
| 761 | (build-system haskell-build-system) |
| 762 | (inputs |
| 763 | `(("ghc-hspec-core" ,ghc-hspec-core) |
| 764 | ("ghc-hunit" ,ghc-hunit) |
| 765 | ("ghc-hspec" ,ghc-hspec) |
| 766 | ("ghc-quickcheck" ,ghc-quickcheck))) |
| 767 | (native-inputs |
| 768 | `(("hspec-discover" ,hspec-discover))) |
| 769 | (home-page "https://hspec.github.io/") |
| 770 | (synopsis "Contributed functionality for Hspec") |
| 771 | (description |
| 772 | "This package provides contributed Hspec extensions.") |
| 773 | (license license:expat))) |
| 774 | |
| 775 | (define-public ghc-hspec-expectations |
| 776 | (package |
| 777 | (name "ghc-hspec-expectations") |
| 778 | (version "0.8.2") |
| 779 | (source |
| 780 | (origin |
| 781 | (method url-fetch) |
| 782 | (uri (string-append "https://hackage.haskell.org/package/" |
| 783 | "hspec-expectations/hspec-expectations-" |
| 784 | version ".tar.gz")) |
| 785 | (sha256 |
| 786 | (base32 |
| 787 | "1vxl9zazbaapijr6zmcj72j9wf7ka1pirrjbwddwwddg3zm0g5l1")))) |
| 788 | (build-system haskell-build-system) |
| 789 | ;; Tests depend on ghc-nanospec. |
| 790 | (arguments '(#:tests? #f)) |
| 791 | (inputs `(("ghc-hunit" ,ghc-hunit))) |
| 792 | (home-page "https://github.com/sol/hspec-expectations") |
| 793 | (synopsis "Catchy combinators for HUnit") |
| 794 | (description "This library provides catchy combinators for HUnit, see |
| 795 | @uref{https://github.com/sol/hspec-expectations#readme, the README}.") |
| 796 | (license license:expat))) |
| 797 | |
| 798 | (define-public ghc-nanospec |
| 799 | (package |
| 800 | (name "ghc-nanospec") |
| 801 | (version "0.2.2") |
| 802 | (source |
| 803 | (origin |
| 804 | (method url-fetch) |
| 805 | (uri (string-append "https://hackage.haskell.org/package/" |
| 806 | "nanospec/nanospec-" |
| 807 | version ".tar.gz")) |
| 808 | (sha256 |
| 809 | (base32 |
| 810 | "1rcmhl9bhyfvanalnf1r86wkx6rq6wdvagnw1h011jcnnb1cq56g")))) |
| 811 | (build-system haskell-build-system) |
| 812 | (inputs |
| 813 | `(("ghc-hspec" ,ghc-hspec) |
| 814 | ("ghc-silently" ,ghc-silently))) |
| 815 | (home-page "https://github.com/hspec/nanospec#readme") |
| 816 | (synopsis "Lightweight implementation of a subset of Hspec's API") |
| 817 | (description |
| 818 | "Nanospec is a lightweight implementation of a subset of Hspec's API with |
| 819 | minimal dependencies.") |
| 820 | (license license:expat))) |
| 821 | |
| 822 | (define-public ghc-crypto-cipher-tests |
| 823 | (package |
| 824 | (name "ghc-crypto-cipher-tests") |
| 825 | (version "0.0.11") |
| 826 | (source |
| 827 | (origin |
| 828 | (method url-fetch) |
| 829 | (uri (string-append "https://hackage.haskell.org/package/" |
| 830 | "crypto-cipher-tests-" version "/" |
| 831 | "crypto-cipher-tests-" version ".tar.gz")) |
| 832 | (sha256 |
| 833 | (base32 |
| 834 | "19wqignlq90qwpam01hnmmrxaxh5lkax9l1l6rlbi4a07nvp1dnz")))) |
| 835 | (build-system haskell-build-system) |
| 836 | (inputs `(("ghc-quickcheck" ,ghc-quickcheck) |
| 837 | ("ghc-hunit" ,ghc-hunit) |
| 838 | ("ghc-test-framework" ,ghc-test-framework) |
| 839 | ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2) |
| 840 | ("ghc-test-framework-hunit" ,ghc-test-framework-hunit) |
| 841 | ("ghc-byteable" ,ghc-byteable) |
| 842 | ("ghc-securemem" ,ghc-securemem) |
| 843 | ("ghc-crypto-cipher-types" ,ghc-crypto-cipher-types))) |
| 844 | (home-page "https://github.com/vincenthz/hs-crypto-cipher") |
| 845 | (synopsis "Generic cryptography cipher tests for Haskell") |
| 846 | (description " This Haskell package contains generic tests for |
| 847 | cryptographic ciphers, and is used by the test runners of various Haskell |
| 848 | implementations of cryptographic ciphers.") |
| 849 | (license license:bsd-3))) |
| 850 | |
| 851 | (define-public ghc-hedgehog |
| 852 | (package |
| 853 | (name "ghc-hedgehog") |
| 854 | (version "1.0.1") |
| 855 | (source |
| 856 | (origin |
| 857 | (method url-fetch) |
| 858 | (uri (string-append |
| 859 | "mirror://hackage/package/hedgehog/hedgehog-" |
| 860 | version |
| 861 | ".tar.gz")) |
| 862 | (sha256 |
| 863 | (base32 |
| 864 | "1qc7hkqbnsk3f5r26wc35r3qiy941nmcxhfqgcq9027kw4gs0bi0")))) |
| 865 | (build-system haskell-build-system) |
| 866 | (inputs |
| 867 | `(("ghc-ansi-terminal" ,ghc-ansi-terminal) |
| 868 | ("ghc-async" ,ghc-async) |
| 869 | ("ghc-concurrent-output" ,ghc-concurrent-output) |
| 870 | ("ghc-exceptions" ,ghc-exceptions) |
| 871 | ("ghc-fail" ,ghc-fail) |
| 872 | ("ghc-lifted-async" ,ghc-lifted-async) |
| 873 | ("ghc-mmorph" ,ghc-mmorph) |
| 874 | ("ghc-monad-control" ,ghc-monad-control) |
| 875 | ("ghc-pretty-show" ,ghc-pretty-show) |
| 876 | ("ghc-primitive" ,ghc-primitive) |
| 877 | ("ghc-random" ,ghc-random) |
| 878 | ("ghc-resourcet" ,ghc-resourcet) |
| 879 | ("ghc-semigroups" ,ghc-semigroups) |
| 880 | ("ghc-th-lift" ,ghc-th-lift) |
| 881 | ("ghc-transformers-base" ,ghc-transformers-base) |
| 882 | ("ghc-wl-pprint-annotated" |
| 883 | ,ghc-wl-pprint-annotated))) |
| 884 | (home-page "https://hedgehog.qa") |
| 885 | (synopsis "Property-based testing in the spirt of QuickCheck") |
| 886 | (description |
| 887 | "Hedgehog is a property-based testing system, in the spirit of |
| 888 | QuickCheck. Hedgehog uses integrated shrinking, so shrinks obey the invariants |
| 889 | of generated values by construction. |
| 890 | |
| 891 | To get started quickly, see the examples: |
| 892 | @uref{https://github.com/hedgehogqa/haskell-hedgehog/tree/master/hedgehog-example}") |
| 893 | (license license:bsd-3))) |
| 894 | |
| 895 | (define-public cabal-doctest |
| 896 | (package |
| 897 | (name "cabal-doctest") |
| 898 | (version "1.0.8") |
| 899 | (source |
| 900 | (origin |
| 901 | (method url-fetch) |
| 902 | (uri (string-append "https://hackage.haskell.org/package/" |
| 903 | "cabal-doctest/cabal-doctest-" |
| 904 | version ".tar.gz")) |
| 905 | (sha256 |
| 906 | (base32 |
| 907 | "03if74imlhhk7m56nci5f1wclniwqdmwl4hl177040j1gnlac9i0")))) |
| 908 | (build-system haskell-build-system) |
| 909 | (home-page "https://github.com/phadej/cabal-doctest") |
| 910 | (synopsis "Setup.hs helper for running doctests") |
| 911 | (description |
| 912 | "To properly work, the @code{doctest} package needs plenty of |
| 913 | configuration. This library provides the common bits for writing custom |
| 914 | @file{Setup.hs} files.") |
| 915 | (license license:bsd-3))) |
| 916 | |
| 917 | (define-public ghc-testing-type-modifiers |
| 918 | (package |
| 919 | (name "ghc-testing-type-modifiers") |
| 920 | (version "0.1.0.1") |
| 921 | (source |
| 922 | (origin |
| 923 | (method url-fetch) |
| 924 | (uri (string-append "https://hackage.haskell.org/package/" |
| 925 | "testing-type-modifiers/testing-type-modifiers-" |
| 926 | version ".tar.gz")) |
| 927 | (sha256 |
| 928 | (base32 |
| 929 | "1wh2n95n39ivv6kbqn42vbzrj8zagsmk6f2al2qj40bg5kgdl2q5")))) |
| 930 | (build-system haskell-build-system) |
| 931 | (home-page "https://hackage.haskell.org/package/testing-type-modifiers") |
| 932 | (synopsis "Data type modifiers for property based testing") |
| 933 | (description "Property based testing libraries such as QuickCheck tend to |
| 934 | include type modifiers. Most of them are used to quantify over subsets of a |
| 935 | type. This library is intended to supply these modifiers to be used by |
| 936 | testing libraries, in an effort to make properties more portable between |
| 937 | testing frameworks.") |
| 938 | (license license:unlicense))) |
| 939 | |
| 940 | (define-public ghc-testing-feat |
| 941 | (package |
| 942 | (name "ghc-testing-feat") |
| 943 | (version "1.1.0.0") |
| 944 | (source |
| 945 | (origin |
| 946 | (method url-fetch) |
| 947 | (uri (string-append "https://hackage.haskell.org/package/" |
| 948 | "testing-feat/testing-feat-" version ".tar.gz")) |
| 949 | (sha256 |
| 950 | (base32 |
| 951 | "1v2qzzpf1s008g7q6q67glf7vbm1pkpq4rc3ii74f4g6vhfx610r")))) |
| 952 | (build-system haskell-build-system) |
| 953 | (inputs |
| 954 | `(("ghc-quickcheck" ,ghc-quickcheck) |
| 955 | ("ghc-size-based" ,ghc-size-based) |
| 956 | ("ghc-testing-type-modifiers" ,ghc-testing-type-modifiers) |
| 957 | ("ghc-semigroups" ,ghc-semigroups))) |
| 958 | (home-page "https://github.com/JonasDuregard/testing-feat") |
| 959 | (synopsis "Functional Enumeration of Algebraic Types") |
| 960 | (description "Feat (Functional Enumeration of Algebraic Types) |
| 961 | provides enumerations as functions from natural numbers to |
| 962 | values (similar to @code{toEnum} but for any algebraic data type). This |
| 963 | can be used for SmallCheck-style systematic testing, QuickCheck-style |
| 964 | random testing, and hybrids of the two.") |
| 965 | (license license:bsd-3))) |