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 Nils Gillmann <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)
  32   #:use-module (gnu packages haskell-crypto)
  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-stm" ,ghc-stm)
  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.8.4")
 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          "15rjxib5jmjq0hzj47x15kgp3awc73va4cy1pmpf7k3hvfv4qprn"))))
 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.1.1")
 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          "0pcf5hsyp5mmbqn7krdm49jxpkjm6rb4j83j28f76h7q55dzm1wy"))))
 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 'golden testing'.  A @dfn{golden test}
 152 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 'golden' file, which
 154 contains the correct result for the test.")
 155     (license license:expat)))
 156
 157 ;; This package builds `clock` without tests, since the tests rely on tasty
 158 ;; and tasty-quickcheck, which in turn require clock to build.
 159 (define ghc-clock-bootstrap
 160   (package
 161     (name "ghc-clock-bootstrap")
 162     (version "0.5.1")
 163     (source
 164      (origin
 165        (method url-fetch)
 166        (uri (string-append
 167              "https://hackage.haskell.org/package/"
 168              "clock/"
 169              "clock-" version ".tar.gz"))
 170        (sha256
 171         (base32 "1ncph7vi2q6ywwc8ysxl1ibw6i5dwfvln88ssfazk8jgpj4iyykw"))))
 172     (build-system haskell-build-system)
 173     (arguments `(#:tests? #f)) ;; Testing suite depends on tasty and
 174                                ;; tasty-quickcheck, which need clock to build.
 175     (home-page "https://hackage.haskell.org/package/clock")
 176     (synopsis "High-resolution clock for Haskell")
 177     (description "A package for convenient access to high-resolution clock and
 178 timer functions of different operating systems via a unified API.")
 179     (license license:bsd-3)))
 180
 181 (define-public ghc-tasty
 182   (package
 183     (name "ghc-tasty")
 184     (version "1.1.0.3")
 185     (source
 186      (origin
 187        (method url-fetch)
 188        (uri (string-append
 189              "https://hackage.haskell.org/package/tasty/tasty-"
 190              version
 191              ".tar.gz"))
 192        (sha256
 193         (base32
 194          "14riid753hjqr6lca1kgxpnvq0wykf0k3qc5jpag42hh8bszav22"))))
 195     (build-system haskell-build-system)
 196     (inputs
 197      `(("ghc-stm" ,ghc-stm)
 198        ("ghc-tagged" ,ghc-tagged)
 199        ("ghc-regex-tdfa" ,ghc-regex-tdfa)
 200        ("ghc-optparse-applicative" ,ghc-optparse-applicative)
 201        ("ghc-unbounded-delays" ,ghc-unbounded-delays)
 202        ("ghc-async" ,ghc-async)
 203        ("ghc-ansi-terminal" ,ghc-ansi-terminal)
 204        ("ghc-clock-bootstrap" ,ghc-clock-bootstrap)
 205        ("ghc-wcwidth" ,ghc-wcwidth-bootstrap)))
 206     (home-page "http://documentup.com/feuerbach/tasty")
 207     (synopsis "Modern and extensible testing framework")
 208     (description "Tasty is a modern testing framework for Haskell.  It lets
 209 you combine your unit tests, golden tests, QuickCheck/SmallCheck properties,
 210 and any other types of tests into a single test suite.")
 211     (license license:expat)))
 212
 213 (define-public ghc-tasty-hunit
 214   (package
 215     (name "ghc-tasty-hunit")
 216     (version "0.10.0.1")
 217     (source
 218      (origin
 219        (method url-fetch)
 220        (uri (string-append
 221              "https://hackage.haskell.org/package/tasty-hunit/tasty-hunit-"
 222              version
 223              ".tar.gz"))
 224        (sha256
 225         (base32
 226          "0j3hgga6c3s8h5snzivb8a75h96207ia2rlbxzj07xbf4zpkp44g"))))
 227     (build-system haskell-build-system)
 228     (inputs
 229      `(("ghc-call-stack" ,ghc-call-stack-boot)
 230        ("ghc-tasty" ,ghc-tasty)))
 231     (home-page "http://documentup.com/feuerbach/tasty")
 232     (synopsis "HUnit support for the Tasty test framework")
 233     (description "This package provides HUnit support for the Tasty Haskell
 234 test framework.")
 235     (license license:expat)))
 236
 237 (define-public ghc-tasty-kat
 238   (package
 239     (name "ghc-tasty-kat")
 240     (version "0.0.3")
 241     (source (origin
 242               (method url-fetch)
 243               (uri (string-append "https://hackage.haskell.org/package/"
 244                                   "tasty-kat/tasty-kat-" version ".tar.gz"))
 245               (sha256
 246                (base32
 247                 "14yvlpli6cv6bn3kh8mlfp4x1l6ns4fvmfv6hmj75cvxyzq029d7"))))
 248     (build-system haskell-build-system)
 249     (inputs
 250      `(("ghc-tasty" ,ghc-tasty)
 251        ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
 252        ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
 253     (home-page "https://github.com/vincenthz/tasty-kat")
 254     (synopsis "Known Answer Tests (KAT) framework for tasty")
 255     (description
 256      "This package provides a @dfn{Known Answer Tests} (KAT) framework for
 257 tasty.")
 258     (license license:expat)))
 259
 260 (define-public ghc-tasty-th
 261   (package
 262     (name "ghc-tasty-th")
 263     (version "0.1.4")
 264     (source
 265      (origin
 266        (method url-fetch)
 267        (uri (string-append
 268              "https://hackage.haskell.org/package/tasty-th/tasty-th-"
 269              version ".tar.gz"))
 270        (sha256
 271         (base32
 272          "0dff9si8i1qp0s7p4hlk0l29vq7wxfglw6mvlgmld43h7rllv88q"))))
 273     (build-system haskell-build-system)
 274     (inputs
 275      `(("ghc-tasty" ,ghc-tasty)))
 276     (home-page "https://github.com/bennofs/tasty-th")
 277     (synopsis "Automatically generate tasty TestTrees")
 278     (description
 279       "Tasty-th automatically generates tasty TestTrees from functions of the
 280 current module, using TemplateHaskell.  This is a fork the original
 281 test-framework-th package, modified to work with tasty instead of
 282 test-framework.")
 283     (license license:bsd-3)))
 284
 285 (define-public ghc-tasty-rerun
 286   (package
 287     (name "ghc-tasty-rerun")
 288     (version "1.1.8")
 289     (source (origin
 290               (method url-fetch)
 291               (uri (string-append
 292                     "https://hackage.haskell.org/package/tasty-rerun/"
 293                     "tasty-rerun-" version ".tar.gz"))
 294               (sha256
 295                (base32
 296                 "0yg8cicfn3qaazvp4rbanzy3dyk95k3y1kkd4bykvkl9v4076788"))))
 297     (build-system haskell-build-system)
 298     (inputs
 299      `(("ghc-optparse-applicative" ,ghc-optparse-applicative)
 300        ("ghc-reducers" ,ghc-reducers)
 301        ("ghc-split" ,ghc-split)
 302        ("ghc-stm" ,ghc-stm)
 303        ("ghc-tagged" ,ghc-tagged)
 304        ("ghc-tasty" ,ghc-tasty)))
 305     (home-page "https://github.com/ocharles/tasty-rerun")
 306     (synopsis "Run tests by filtering the test tree")
 307     (description "This package adds the ability to run tests by filtering the
 308 test tree based on the result of a previous test run.  You can use this to run
 309 only those tests that failed in the last run, or to only run the tests that have
 310 been added since previous test run.")
 311   (license license:bsd-3)))
 312
 313 (define-public ghc-tasty-expected-failure
 314   (package
 315     (name "ghc-tasty-expected-failure")
 316     (version "0.11.1.1")
 317     (source
 318      (origin
 319        (method url-fetch)
 320        (uri (string-append "https://hackage.haskell.org/package/"
 321                            "tasty-expected-failure/tasty-expected-failure-"
 322                            version ".tar.gz"))
 323        (sha256
 324         (base32
 325          "1i2s809m644b7hgiblqay9j364r3fjj1rwbrahsn1pgr5q6mr6ji"))))
 326     (build-system haskell-build-system)
 327     (inputs
 328      `(("ghc-tagged" ,ghc-tagged)
 329        ("ghc-tasty" ,ghc-tasty)))
 330     (home-page "http://github.com/nomeata/tasty-expected-failure")
 331     (synopsis "Mark tasty tests as failure expected")
 332     (description
 333      "With the function @code{Test.Tasty.ExpectedFailure.expectFail} in the
 334 provided module @code{Test.Tasty.ExpectedFailure}, you can mark that you
 335 expect test cases to fail, and not to pass. This can be used for test-driven
 336 development.")
 337     (license license:expat)))
 338
 339 (define-public ghc-quickcheck-instances
 340   (package
 341     (name "ghc-quickcheck-instances")
 342     (version "0.3.18")
 343     (source
 344      (origin
 345        (method url-fetch)
 346        (uri (string-append
 347              "https://hackage.haskell.org/package/"
 348              "quickcheck-instances/quickcheck-instances-"
 349              version ".tar.gz"))
 350        (sha256
 351         (base32
 352          "1bh1pzz5fdcqvzdcirqxna6fnjms02min5md716299g5niz46w55"))))
 353     (build-system haskell-build-system)
 354     (arguments
 355      `(#:configure-flags (list "--allow-newer=base-compat")))
 356     (inputs
 357      `(("ghc-quickcheck" ,ghc-quickcheck)
 358        ("ghc-base-compat" ,ghc-base-compat)
 359        ("ghc-case-insensitive" ,ghc-case-insensitive)
 360        ("ghc-hashable" ,ghc-hashable)
 361        ("ghc-old-time" ,ghc-old-time)
 362        ("ghc-scientific" ,ghc-scientific)
 363        ("ghc-tagged" ,ghc-tagged)
 364        ("ghc-text" ,ghc-text)
 365        ("ghc-transformers-compat" ,ghc-transformers-compat)
 366        ("ghc-unordered-containers" ,ghc-unordered-containers)
 367        ("ghc-uuid-types" ,ghc-uuid-types)
 368        ("ghc-vector" ,ghc-vector)))
 369     (home-page "https://github.com/aslatter/qc-instances")
 370     (synopsis "Common quickcheck instances")
 371     (description "This package provides QuickCheck instances for types
 372 provided by the Haskell Platform.")
 373     (license license:bsd-3)))
 374
 375 (define-public ghc-quickcheck-unicode
 376   (package
 377     (name "ghc-quickcheck-unicode")
 378     (version "1.0.1.0")
 379     (source
 380      (origin
 381        (method url-fetch)
 382        (uri (string-append
 383              "https://hackage.haskell.org/package/quickcheck-unicode/"
 384              "quickcheck-unicode-" version ".tar.gz"))
 385        (sha256
 386         (base32
 387          "0s43s1bzbg3gwsjgm7fpyksd1339f0m26dlw2famxwyzgvm0a80k"))))
 388     (build-system haskell-build-system)
 389     (inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
 390     (home-page
 391      "https://github.com/bos/quickcheck-unicode")
 392     (synopsis "Generator functions Unicode-related tests")
 393     (description "This package provides generator and shrink functions for
 394 testing Unicode-related software.")
 395     (license license:bsd-3)))
 396
 397 (define-public ghc-quickcheck-io
 398   (package
 399     (name "ghc-quickcheck-io")
 400     (version "0.2.0")
 401     (source
 402      (origin
 403        (method url-fetch)
 404        (uri (string-append
 405              "https://hackage.haskell.org/package/quickcheck-io/quickcheck-io-"
 406              version
 407              ".tar.gz"))
 408        (sha256
 409         (base32
 410          "08k4v7pkgjf30pv5j2dfv1gqv6hclxlniyq2sps8zq4zswcr2xzv"))))
 411     (build-system haskell-build-system)
 412     (inputs
 413      `(("ghc-quickcheck" ,ghc-quickcheck)
 414        ("ghc-hunit" ,ghc-hunit)))
 415     (home-page
 416      "https://github.com/hspec/quickcheck-io#readme")
 417     (synopsis "Use HUnit assertions as QuickCheck properties")
 418     (description "This package provides an orphan instance that allows you to
 419 use HUnit assertions as QuickCheck properties.")
 420     (license license:expat)))
 421
 422 (define-public ghc-quickcheck
 423   (package
 424     (name "ghc-quickcheck")
 425     (version "2.11.3")
 426     (outputs '("out" "doc"))
 427     (source
 428      (origin
 429        (method url-fetch)
 430        (uri (string-append
 431              "https://hackage.haskell.org/package/QuickCheck/QuickCheck-"
 432              version
 433              ".tar.gz"))
 434        (sha256
 435         (base32
 436          "0xhqk35fkzlbjcqbabg6962jkv8d688nzmz7ng4bm84x2d95d328"))))
 437     (build-system haskell-build-system)
 438     (arguments
 439      `(#:tests? #f))  ; FIXME: currently missing libraries used for tests.
 440     (inputs
 441      `(("ghc-random" ,ghc-random)
 442        ("ghc-tf-random" ,ghc-tf-random)))
 443     (home-page "https://github.com/nick8325/quickcheck")
 444     (synopsis "Automatic testing of Haskell programs")
 445     (description
 446      "QuickCheck is a library for random testing of program properties.  The
 447 programmer provides a specification of the program, in the form of properties
 448 which functions should satisfy, and QuickCheck then tests that the properties
 449 hold in a large number of randomly generated cases.  Specifications are
 450 expressed in Haskell, using combinators defined in the QuickCheck library.")
 451     (license license:bsd-3)))
 452
 453 (define-public ghc-test-framework
 454   (package
 455     (name "ghc-test-framework")
 456     (version "0.8.2.0")
 457     (source
 458      (origin
 459        (method url-fetch)
 460        (uri (string-append "https://hackage.haskell.org/package/test-framework/"
 461                            "test-framework-" version ".tar.gz"))
 462        (sha256
 463         (base32
 464          "1hhacrzam6b8f10hyldmjw8pb7frdxh04rfg3farxcxwbnhwgbpm"))))
 465     (build-system haskell-build-system)
 466     (arguments
 467      `(#:tests? #f  ; FIXME: Tests do not build.
 468        #:phases
 469        (modify-phases %standard-phases
 470          (add-before 'configure 'update-constraints
 471            (lambda _
 472              (substitute* "test-framework.cabal"
 473                (("QuickCheck     >= 2\\.3 && < 2\\.10")
 474                 "QuickCheck     >= 2.3 && < 2.12")))))))
 475     (native-inputs
 476      `(("ghc-hunit" ,ghc-hunit)
 477        ("ghc-quickcheck" ,ghc-quickcheck)))
 478     (inputs
 479      `(("ghc-ansi-terminal" ,ghc-ansi-terminal)
 480        ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
 481        ("ghc-hostname" ,ghc-hostname)
 482        ("ghc-old-locale" ,ghc-old-locale)
 483        ("ghc-random" ,ghc-random)
 484        ("ghc-regex-posix" ,ghc-regex-posix)
 485        ("ghc-xml" ,ghc-xml)
 486        ("ghc-libxml" ,ghc-libxml)
 487        ("ghc-semigroups" ,ghc-semigroups-bootstrap)))
 488     (home-page "https://batterseapower.github.io/test-framework/")
 489     (synopsis "Framework for running and organising tests")
 490     (description
 491      "This package allows tests such as QuickCheck properties and HUnit test
 492 cases to be assembled into test groups, run in parallel (but reported in
 493 deterministic order, to aid diff interpretation) and filtered and controlled
 494 by command line options.  All of this comes with colored test output, progress
 495 reporting and test statistics output.")
 496     (license license:bsd-3)))
 497
 498 (define-public ghc-test-framework-hunit
 499   (package
 500     (name "ghc-test-framework-hunit")
 501     (version "0.3.0.2")
 502     (source
 503      (origin
 504        (method url-fetch)
 505        (uri (string-append "https://hackage.haskell.org/package/"
 506                            "test-framework-hunit/test-framework-hunit-"
 507                            version ".tar.gz"))
 508        (sha256
 509         (base32
 510          "1y0b6vg8nfm43v90lxxcydhi6qlxhfy4vpxbzm5ic2w55bh8xjwm"))))
 511     (build-system haskell-build-system)
 512     (arguments
 513      `(#:cabal-revision
 514        ("3" "0i9mlalv7cl1iq43ld5myrnpszq5rxmd79hk495dcb08rglhgl3z")))
 515     (inputs
 516      `(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
 517        ("ghc-hunit" ,ghc-hunit)
 518        ("ghc-test-framework" ,ghc-test-framework)))
 519     (home-page "https://batterseapower.github.io/test-framework/")
 520     (synopsis "HUnit support for test-framework")
 521     (description
 522      "This package provides HUnit support for the test-framework package.")
 523     (license license:bsd-3)))
 524
 525 (define-public ghc-test-framework-quickcheck2
 526   (package
 527     (name "ghc-test-framework-quickcheck2")
 528     (version "0.3.0.4")
 529     (source
 530      (origin
 531        (method url-fetch)
 532        (uri (string-append "https://hackage.haskell.org/package/"
 533                            "test-framework-quickcheck2/"
 534                            "test-framework-quickcheck2-" version ".tar.gz"))
 535        (sha256
 536         (base32
 537          "0vj834337r6jzr3258cv68ly2sv5999mklpsrfngyk51kywsyqyp"))))
 538     (build-system haskell-build-system)
 539     (arguments
 540      `(#:cabal-revision
 541        ("1" "147ngmfdkskyg7mwsp5w73a4dbx3rp5s38bci3z03kn1m093lxff")))
 542     (inputs
 543      `(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
 544        ("ghc-quickcheck" ,ghc-quickcheck)
 545        ("ghc-random" ,ghc-random)
 546        ("ghc-test-framework" ,ghc-test-framework)))
 547     (home-page "https://batterseapower.github.io/test-framework/")
 548     (synopsis "QuickCheck2 support for test-framework")
 549     (description
 550      "This packages provides QuickCheck2 support for the test-framework
 551 package.")
 552     (license license:bsd-3)))
 553
 554 (define-public ghc-test-framework-th
 555   (package
 556     (name "ghc-test-framework-th")
 557     (version "0.2.4")
 558     (source
 559      (origin
 560        (method url-fetch)
 561        (uri (string-append "https://hackage.haskell.org/package/"
 562                            "test-framework-th-" version "/"
 563                            "test-framework-th-" version ".tar.gz"))
 564        (sha256
 565         (base32
 566          "12lw7yj02jb9s0i7rb98jjam43j2h0gzmnbj9zi933fx7sg0sy4b"))))
 567     (build-system haskell-build-system)
 568     (inputs
 569      `(("ghc-test-framework" ,ghc-test-framework)
 570        ("ghc-language-haskell-extract" ,ghc-language-haskell-extract)
 571        ("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
 572        ("ghc-regex-posix" ,ghc-regex-posix)))
 573     (home-page "https://github.com/finnsson/test-generator")
 574     (synopsis "Auto generate the HUnit- and Quickcheck-bulk-code
 575 using Template Haskell")
 576     (description "This library contains two functions:
 577 @code{defaultMainGenerator} and @code{testGroupGenerator}.
 578
 579 @code{defaultMainGenerator} will extract all functions beginning with
 580 @code{case_}, @code{prop_}, or @code{test_} in the module and put them in a
 581 @code{testGroup}.
 582
 583 @code{testGroupGenerator} is like @code{defaultMainGenerator} but without
 584 @code{defaultMain}.  It is useful if you need a function for the testgroup
 585 \(e.g. if you want to be able to call the testgroup from another module).")
 586     (license license:bsd-3)))
 587
 588 (define-public ghc-hunit
 589   (package
 590     (name "ghc-hunit")
 591     (version "1.6.0.0")
 592     (outputs '("out" "doc"))
 593     (source
 594      (origin
 595        (method url-fetch)
 596        (uri (string-append "https://hackage.haskell.org/package/HUnit/"
 597                            "HUnit-" version ".tar.gz"))
 598        (sha256
 599         (base32
 600          "1pnhwqq5v8h48gbp3ibv3skfj25mf4zs5svxcavq93p9cswycj3l"))))
 601     (build-system haskell-build-system)
 602     (inputs
 603      ;; We cannot use ghc-call-stack there, because it depends on
 604      ;; ghc-nanospec, which depends on ghc-hunit.
 605      `(("ghc-call-stack" ,ghc-call-stack-boot)))
 606     (home-page "http://hunit.sourceforge.net/")
 607     (synopsis "Unit testing framework for Haskell")
 608     (description
 609      "HUnit is a unit testing framework for Haskell, inspired by the
 610 JUnit tool for Java.")
 611     (license license:bsd-3)))
 612
 613 (define-public hspec-discover
 614   (package
 615     (name "hspec-discover")
 616     (version "2.5.5")
 617     (source
 618      (origin
 619        (method url-fetch)
 620        (uri (string-append "https://hackage.haskell.org/package/"
 621                            "hspec-discover/hspec-discover-"
 622                            version ".tar.gz"))
 623        (sha256
 624         (base32
 625          "04aidzi91ccr9bygmfkjzshz34z9vh8wvqj4zinx2clxq6r7gqfz"))))
 626     (build-system haskell-build-system)
 627     (native-inputs
 628      `(("ghc-quickcheck" ,ghc-quickcheck)
 629        ("ghc-hspec-meta" ,ghc-hspec-meta)))
 630     (home-page "https://hspec.github.io/")
 631     (synopsis "Automatically discover and run Hspec tests")
 632     (description "hspec-discover is a tool which automatically discovers and
 633 runs Hspec tests.")
 634     (license license:expat)))
 635
 636 (define-public ghc-hspec-core
 637   (package
 638     (name "ghc-hspec-core")
 639     (version "2.5.5")
 640     (source
 641      (origin
 642        (method url-fetch)
 643        (uri (string-append "https://hackage.haskell.org/package/hspec-core/"
 644                            "hspec-core-" version ".tar.gz"))
 645        (sha256
 646         (base32
 647          "1vfrqlpn32s9wiykmkxbnrnd5p56yznw20pf8fwzw78ar4wpz55x"))))
 648     (build-system haskell-build-system)
 649     (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
 650     (inputs
 651      `(("ghc-setenv" ,ghc-setenv)
 652        ("ghc-ansi-terminal" ,ghc-ansi-terminal)
 653        ("ghc-async" ,ghc-async)
 654        ("ghc-clock" ,ghc-clock)
 655        ("ghc-quickcheck-io" ,ghc-quickcheck-io)
 656        ("ghc-hunit" ,ghc-hunit)
 657        ("ghc-quickcheck" ,ghc-quickcheck)
 658        ("ghc-hspec-expectations" ,ghc-hspec-expectations)
 659        ("ghc-silently" ,ghc-silently)))
 660     (home-page "https://hspec.github.io/")
 661     (synopsis "Testing framework for Haskell")
 662     (description "This library exposes internal types and functions that can
 663 be used to extend Hspec's functionality.")
 664     (license license:expat)))
 665
 666 (define-public ghc-hspec-meta
 667   (package
 668     (name "ghc-hspec-meta")
 669     (version "2.4.6")
 670     (source
 671      (origin
 672        (method url-fetch)
 673        (uri (string-append "https://hackage.haskell.org/package/hspec-meta/"
 674                            "hspec-meta-" version ".tar.gz"))
 675        (sha256
 676         (base32
 677          "0qmvk01n79j6skn79r6zalg2pd0x0nqqn9qn8mhg0pgyzcdnfc9b"))))
 678     (build-system haskell-build-system)
 679     (inputs
 680      `(("ghc-quickcheck" ,ghc-quickcheck)
 681        ("ghc-hunit" ,ghc-hunit)
 682        ("ghc-ansi-terminal" ,ghc-ansi-terminal)
 683        ("ghc-async" ,ghc-async)
 684        ("ghc-hspec-expectations" ,ghc-hspec-expectations)
 685        ("ghc-setenv" ,ghc-setenv)
 686        ("ghc-random" ,ghc-random)
 687        ("ghc-quickcheck-io" ,ghc-quickcheck-io)))
 688     (home-page "https://hspec.github.io/")
 689     (synopsis "Version of Hspec to test Hspec itself")
 690     (description "This library provides a stable version of Hspec which is
 691 used to test the in-development version of Hspec.")
 692     (license license:expat)))
 693
 694 (define-public ghc-hspec
 695   (package
 696     (name "ghc-hspec")
 697     (version "2.5.5")
 698     (source
 699      (origin
 700        (method url-fetch)
 701        (uri (string-append "https://hackage.haskell.org/package/hspec/"
 702                            "hspec-" version ".tar.gz"))
 703        (sha256
 704         (base32
 705          "1yv4k5b5kkig2q3waj28587sq28wms7wfav5a3lq4dra6jybimfm"))))
 706     (build-system haskell-build-system)
 707     (inputs
 708      `(("ghc-hspec-core" ,ghc-hspec-core)
 709        ("hspec-discover" ,hspec-discover)
 710        ("ghc-hspec-expectations" ,ghc-hspec-expectations)
 711        ("ghc-quickcheck" ,ghc-quickcheck)
 712        ("ghc-hunit" ,ghc-hunit)
 713        ("ghc-stringbuilder" ,ghc-stringbuilder)
 714        ("ghc-hspec-meta" ,ghc-hspec-meta)))
 715     (home-page "https://hspec.github.io/")
 716     (synopsis "Testing Framework for Haskell")
 717     (description "This library provides the Hspec testing framework for
 718 Haskell, inspired by the Ruby library RSpec.")
 719     (license license:expat)))
 720
 721 (define-public ghc-hspec-contrib
 722   (package
 723     (name "ghc-hspec-contrib")
 724     (version "0.5.0")
 725     (source (origin
 726               (method url-fetch)
 727               (uri (string-append "https://hackage.haskell.org/package/"
 728                                   "hspec-contrib/hspec-contrib-"
 729                                   version ".tar.gz"))
 730               (sha256
 731                (base32
 732                 "13579xdqwbsy8k0vxdcvgy932d4p76mij1rzkzbpqbspfn7399yv"))))
 733     (build-system haskell-build-system)
 734     (inputs
 735      `(("ghc-hspec-core" ,ghc-hspec-core)
 736        ("ghc-hunit" ,ghc-hunit)
 737        ("ghc-hspec" ,ghc-hspec)
 738        ("ghc-quickcheck" ,ghc-quickcheck)))
 739     (native-inputs
 740      `(("hspec-discover" ,hspec-discover)))
 741     (home-page "https://hspec.github.io/")
 742     (synopsis "Contributed functionality for Hspec")
 743     (description
 744      "This package provides contributed Hspec extensions.")
 745     (license license:expat)))
 746
 747 (define-public ghc-hspec-expectations
 748   (package
 749     (name "ghc-hspec-expectations")
 750     (version "0.8.2")
 751     (source
 752      (origin
 753        (method url-fetch)
 754        (uri (string-append "https://hackage.haskell.org/package/"
 755                            "hspec-expectations/hspec-expectations-"
 756                            version ".tar.gz"))
 757        (sha256
 758         (base32
 759          "1vxl9zazbaapijr6zmcj72j9wf7ka1pirrjbwddwwddg3zm0g5l1"))))
 760     (build-system haskell-build-system)
 761     ;; Tests depend on ghc-nanospec.
 762     (arguments '(#:tests? #f))
 763     (inputs `(("ghc-hunit" ,ghc-hunit)))
 764     (home-page "https://github.com/sol/hspec-expectations")
 765     (synopsis "Catchy combinators for HUnit")
 766     (description "This library provides catchy combinators for HUnit, see
 767 @uref{https://github.com/sol/hspec-expectations#readme, the README}.")
 768     (license license:expat)))
 769
 770 (define-public ghc-nanospec
 771   (package
 772     (name "ghc-nanospec")
 773     (version "0.2.2")
 774     (source
 775      (origin
 776        (method url-fetch)
 777        (uri (string-append "https://hackage.haskell.org/package/"
 778                            "nanospec/nanospec-"
 779                            version ".tar.gz"))
 780        (sha256
 781         (base32
 782          "1rcmhl9bhyfvanalnf1r86wkx6rq6wdvagnw1h011jcnnb1cq56g"))))
 783     (build-system haskell-build-system)
 784     (inputs
 785      `(("ghc-hspec" ,ghc-hspec)
 786        ("ghc-silently" ,ghc-silently)))
 787     (home-page "https://github.com/hspec/nanospec#readme")
 788     (synopsis "Lightweight implementation of a subset of Hspec's API")
 789     (description
 790      "Nanospec is a lightweight implementation of a subset of Hspec's API with
 791 minimal dependencies.")
 792     (license license:expat)))
 793
 794 (define-public ghc-crypto-cipher-tests
 795   (package
 796     (name "ghc-crypto-cipher-tests")
 797     (version "0.0.11")
 798     (source
 799      (origin
 800        (method url-fetch)
 801        (uri (string-append "https://hackage.haskell.org/package/"
 802                            "crypto-cipher-tests-" version "/"
 803                            "crypto-cipher-tests-" version ".tar.gz"))
 804        (sha256
 805         (base32
 806          "19wqignlq90qwpam01hnmmrxaxh5lkax9l1l6rlbi4a07nvp1dnz"))))
 807     (build-system haskell-build-system)
 808     (inputs `(("ghc-quickcheck" ,ghc-quickcheck)
 809               ("ghc-hunit" ,ghc-hunit)
 810               ("ghc-test-framework" ,ghc-test-framework)
 811               ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
 812               ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
 813               ("ghc-byteable" ,ghc-byteable)
 814               ("ghc-securemem" ,ghc-securemem)
 815               ("ghc-crypto-cipher-types" ,ghc-crypto-cipher-types)))
 816     (home-page "https://github.com/vincenthz/hs-crypto-cipher")
 817     (synopsis "Generic cryptography cipher tests for Haskell")
 818     (description " This Haskell package contains generic tests for
 819 cryptographic ciphers, and is used by the test runners of various Haskell
 820 implementations of cryptographic ciphers.")
 821     (license license:bsd-3)))