gnu/packages/haskell-check.scm

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