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