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 Ricardo Wurmus <rekado@elephly.net>
   6 ;;; Copyright © 2016 ng0 <ng0@infotropique.org>
   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 ;;;
  12 ;;; This file is part of GNU Guix.
  13 ;;;
  14 ;;; GNU Guix is free software; you can redistribute it and/or modify it
  15 ;;; under the terms of the GNU General Public License as published by
  16 ;;; the Free Software Foundation; either version 3 of the License, or (at
  17 ;;; your option) any later version.
  18 ;;;
  19 ;;; GNU Guix is distributed in the hope that it will be useful, but
  20 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
  21 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22 ;;; GNU General Public License for more details.
  23 ;;;
  24 ;;; You should have received a copy of the GNU General Public License
  25 ;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.
  26
  27 (define-module (gnu packages haskell-check)
  28   #:use-module (gnu packages)
  29   #:use-module (gnu packages haskell)
  30   #:use-module (guix build-system haskell)
  31   #:use-module (guix download)
  32   #:use-module ((guix licenses) #:prefix license:)
  33   #:use-module (guix packages)
  34   #:use-module (guix utils))
  35
  36 (define-public ghc-tasty-ant-xml
  37   (package
  38     (name "ghc-tasty-ant-xml")
  39     (version "1.0.2")
  40     (source
  41      (origin
  42        (method url-fetch)
  43        (uri (string-append
  44              "https://hackage.haskell.org/package/tasty-ant-xml/tasty-ant-xml-"
  45              version
  46              ".tar.gz"))
  47        (sha256
  48         (base32
  49          "0pgz2lclg2hp72ykljcbxd88pjanfdfk8m5vb2qzcyjr85kwrhxv"))))
  50     (build-system haskell-build-system)
  51     (inputs
  52      `(("ghc-generic-deriving" ,ghc-generic-deriving)
  53        ("ghc-xml" ,ghc-xml)
  54        ("ghc-mtl" ,ghc-mtl)
  55        ("ghc-stm" ,ghc-stm)
  56        ("ghc-tagged" ,ghc-tagged)
  57        ("ghc-tasty" ,ghc-tasty)))
  58     (home-page
  59      "https://github.com/ocharles/tasty-ant-xml")
  60     (synopsis
  61      "Render tasty output to XML for Jenkins")
  62     (description
  63      "A tasty ingredient to output test results in XML, using the Ant
  64 schema.  This XML can be consumed by the Jenkins continuous integration
  65 framework.")
  66     (license license:bsd-3)))
  67
  68 (define-public ghc-tasty-smallcheck
  69   (package
  70     (name "ghc-tasty-smallcheck")
  71     (version "0.8.1")
  72     (source
  73      (origin
  74        (method url-fetch)
  75        (uri (string-append
  76              "https://hackage.haskell.org/package/tasty-smallcheck/tasty-smallcheck-"
  77              version
  78              ".tar.gz"))
  79        (sha256
  80         (base32
  81          "1n66ngzllf3xrlqykwszlkwsi96n5nkm7xbpfq7774vpvfnafjri"))))
  82     (build-system haskell-build-system)
  83     (inputs
  84      `(("ghc-tasty" ,ghc-tasty)
  85        ("ghc-smallcheck" ,ghc-smallcheck)
  86        ("ghc-async" ,ghc-async)
  87        ("ghc-tagged" ,ghc-tagged)))
  88     (home-page "https://documentup.com/feuerbach/tasty")
  89     (synopsis "SmallCheck support for the Tasty test framework")
  90     (description "This package provides SmallCheck support for the Tasty
  91 Haskell test framework.")
  92     (license license:bsd-3)))
  93
  94 (define-public ghc-tasty-quickcheck
  95   (package
  96     (name "ghc-tasty-quickcheck")
  97     (version "0.8.4")
  98     (source
  99      (origin
 100        (method url-fetch)
 101        (uri (string-append
 102              "https://hackage.haskell.org/package/tasty-quickcheck/"
 103              "tasty-quickcheck-" version ".tar.gz"))
 104        (sha256
 105         (base32
 106          "15rjxib5jmjq0hzj47x15kgp3awc73va4cy1pmpf7k3hvfv4qprn"))))
 107     (build-system haskell-build-system)
 108     (inputs
 109      `(("ghc-quickcheck" ,ghc-quickcheck)
 110        ("ghc-tagged" ,ghc-tagged)
 111        ("ghc-tasty" ,ghc-tasty)
 112        ("ghc-random" ,ghc-random)
 113        ("ghc-ansi-terminal" ,ghc-ansi-terminal)
 114        ("ghc-tasty-hunit" ,ghc-tasty-hunit)
 115        ("ghc-pcre-light" ,ghc-pcre-light)))
 116     (home-page "http://documentup.com/feuerbach/tasty")
 117     (synopsis "QuickCheck support for the Tasty test framework")
 118     (description "This package provides QuickCheck support for the Tasty
 119 Haskell test framework.")
 120     (license license:expat)))
 121
 122 (define-public ghc-tasty-golden
 123   (package
 124     (name "ghc-tasty-golden")
 125     (version "2.3.1.1")
 126     (source
 127      (origin
 128        (method url-fetch)
 129        (uri (string-append
 130              "https://hackage.haskell.org/package/tasty-golden/tasty-golden-"
 131              version
 132              ".tar.gz"))
 133        (sha256
 134         (base32
 135          "0pcf5hsyp5mmbqn7krdm49jxpkjm6rb4j83j28f76h7q55dzm1wy"))))
 136     (build-system haskell-build-system)
 137     (inputs
 138      `(("ghc-temporary" ,ghc-temporary)
 139        ("ghc-tasty" ,ghc-tasty)
 140        ("ghc-mtl" ,ghc-mtl)
 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 'golden testing'.  A @dfn{golden test}
 151 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 '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 "0.11.0.1")
 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          "1chapivmmwsb1ghwagvdm80bfj3hdk75m94z4p212ng2i4ghpjkx"))))
 194     (build-system haskell-build-system)
 195     (inputs
 196      `(("ghc-stm" ,ghc-stm)
 197        ("ghc-mtl" ,ghc-mtl)
 198        ("ghc-tagged" ,ghc-tagged)
 199        ("ghc-regex-tdfa-rc" ,ghc-regex-tdfa-rc)
 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     (home-page "http://documentup.com/feuerbach/tasty")
 206     (synopsis "Modern and extensible testing framework")
 207     (description "Tasty is a modern testing framework for Haskell.  It lets
 208 you combine your unit tests, golden tests, QuickCheck/SmallCheck properties,
 209 and any other types of tests into a single test suite.")
 210     (license license:expat)))
 211
 212 (define-public ghc-tasty-hunit
 213   (package
 214     (name "ghc-tasty-hunit")
 215     (version "0.9.2")
 216     (source
 217      (origin
 218        (method url-fetch)
 219        (uri (string-append
 220              "https://hackage.haskell.org/package/tasty-hunit/tasty-hunit-"
 221              version
 222              ".tar.gz"))
 223        (sha256
 224         (base32
 225          "08qnxaw34wfnzi9irs1jd4d0zczqm3k5ffkd4zwhkz0dflmgq7mf"))))
 226     (build-system haskell-build-system)
 227     (inputs
 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-mtl" ,ghc-mtl)
 250        ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
 251        ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
 252     (home-page "https://github.com/vincenthz/tasty-kat")
 253     (synopsis "Known Answer Tests (KAT) framework for tasty")
 254     (description
 255      "This package provides a @dfn{Known Answer Tests} (KAT) framework for
 256 tasty.")
 257     (license license:expat)))
 258
 259 (define-public ghc-tasty-th
 260   (package
 261     (name "ghc-tasty-th")
 262     (version "0.1.4")
 263     (source
 264      (origin
 265        (method url-fetch)
 266        (uri (string-append
 267              "https://hackage.haskell.org/package/tasty-th/tasty-th-"
 268              version ".tar.gz"))
 269        (sha256
 270         (base32
 271          "0dff9si8i1qp0s7p4hlk0l29vq7wxfglw6mvlgmld43h7rllv88q"))))
 272     (build-system haskell-build-system)
 273     (inputs
 274      `(("ghc-tasty" ,ghc-tasty)))
 275     (home-page "https://github.com/bennofs/tasty-th")
 276     (synopsis "Automatically generate tasty TestTrees")
 277     (description
 278       "Tasty-th automatically generates tasty TestTrees from functions of the
 279 current module, using TemplateHaskell.  This is a fork the original
 280 test-framework-th package, modified to work with tasty instead of
 281 test-framework.")
 282     (license license:bsd-3)))
 283
 284 (define-public ghc-tasty-rerun
 285   (package
 286     (name "ghc-tasty-rerun")
 287     (version "1.1.8")
 288     (source (origin
 289               (method url-fetch)
 290               (uri (string-append
 291                     "https://hackage.haskell.org/package/tasty-rerun/"
 292                     "tasty-rerun-" version ".tar.gz"))
 293               (sha256
 294                (base32
 295                 "0yg8cicfn3qaazvp4rbanzy3dyk95k3y1kkd4bykvkl9v4076788"))))
 296     (build-system haskell-build-system)
 297     (inputs
 298      `(("ghc-mtl" ,ghc-mtl)
 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-quickcheck-instances
 314   (package
 315     (name "ghc-quickcheck-instances")
 316     (version "0.3.12")
 317     (source
 318      (origin
 319        (method url-fetch)
 320        (uri (string-append
 321              "https://hackage.haskell.org/package/"
 322              "quickcheck-instances/quickcheck-instances-"
 323              version ".tar.gz"))
 324        (sha256
 325         (base32
 326          "1wwvkzpams7i0j7nk5qj8vvhj8x5zcbgbgrpczszgvshva4bkmfx"))))
 327     (build-system haskell-build-system)
 328     (inputs
 329      `(("ghc-old-time" ,ghc-old-time)
 330        ("ghc-unordered-containers" ,ghc-unordered-containers)
 331        ("ghc-hashable" ,ghc-hashable)
 332        ("ghc-quickcheck" ,ghc-quickcheck)
 333        ("ghc-scientific" ,ghc-scientific)
 334        ("ghc-vector" ,ghc-vector)
 335        ("ghc-text" ,ghc-text)))
 336     (home-page
 337      "https://github.com/aslatter/qc-instances")
 338     (synopsis "Common quickcheck instances")
 339     (description "This package provides QuickCheck instances for types
 340 provided by the Haskell Platform.")
 341     (license license:bsd-3)))
 342
 343 (define-public ghc-quickcheck-unicode
 344   (package
 345     (name "ghc-quickcheck-unicode")
 346     (version "1.0.1.0")
 347     (source
 348      (origin
 349        (method url-fetch)
 350        (uri (string-append
 351              "https://hackage.haskell.org/package/quickcheck-unicode/"
 352              "quickcheck-unicode-" version ".tar.gz"))
 353        (sha256
 354         (base32
 355          "0s43s1bzbg3gwsjgm7fpyksd1339f0m26dlw2famxwyzgvm0a80k"))))
 356     (build-system haskell-build-system)
 357     (inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
 358     (home-page
 359      "https://github.com/bos/quickcheck-unicode")
 360     (synopsis "Generator functions Unicode-related tests")
 361     (description "This package provides generator and shrink functions for
 362 testing Unicode-related software.")
 363     (license license:bsd-3)))
 364
 365 (define-public ghc-quickcheck-io
 366   (package
 367     (name "ghc-quickcheck-io")
 368     (version "0.2.0")
 369     (source
 370      (origin
 371        (method url-fetch)
 372        (uri (string-append
 373              "https://hackage.haskell.org/package/quickcheck-io/quickcheck-io-"
 374              version
 375              ".tar.gz"))
 376        (sha256
 377         (base32
 378          "08k4v7pkgjf30pv5j2dfv1gqv6hclxlniyq2sps8zq4zswcr2xzv"))))
 379     (build-system haskell-build-system)
 380     (inputs
 381      `(("ghc-quickcheck" ,ghc-quickcheck)
 382        ("ghc-hunit" ,ghc-hunit)))
 383     (home-page
 384      "https://github.com/hspec/quickcheck-io#readme")
 385     (synopsis "Use HUnit assertions as QuickCheck properties")
 386     (description "This package provides an orphan instance that allows you to
 387 use HUnit assertions as QuickCheck properties.")
 388     (license license:expat)))
 389
 390 (define-public ghc-quickcheck
 391   (package
 392     (name "ghc-quickcheck")
 393     (version "2.8.2")
 394     (outputs '("out" "doc"))
 395     (source
 396      (origin
 397        (method url-fetch)
 398        (uri (string-append
 399              "https://hackage.haskell.org/package/QuickCheck/QuickCheck-"
 400              version
 401              ".tar.gz"))
 402        (sha256
 403         (base32
 404          "1ai6k5v0bibaxq8xffcblc6rwmmk6gf8vjyd9p2h3y6vwbhlvilq"))))
 405     (build-system haskell-build-system)
 406     (arguments
 407      `(#:tests? #f  ; FIXME: currently missing libraries used for tests.
 408        #:configure-flags '("-f base4")))
 409     (inputs
 410      `(("ghc-tf-random" ,ghc-tf-random)))
 411     (home-page
 412      "https://github.com/nick8325/quickcheck")
 413     (synopsis
 414      "Automatic testing of Haskell programs")
 415     (description
 416      "QuickCheck is a library for random testing of program properties.")
 417     (license license:bsd-3)))
 418
 419 (define-public ghc-test-framework
 420   (package
 421     (name "ghc-test-framework")
 422     (version "0.8.1.1")
 423     (source
 424      (origin
 425        (method url-fetch)
 426        (uri (string-append "https://hackage.haskell.org/package/test-framework/"
 427                            "test-framework-" version ".tar.gz"))
 428        (sha256
 429         (base32
 430          "0wxjgdvb1c4ykazw774zlx86550848wbsvgjgcrdzcgbb9m650vq"))))
 431     (build-system haskell-build-system)
 432     (native-inputs
 433      `(("ghc-hunit" ,ghc-hunit)
 434        ("ghc-quickcheck" ,ghc-quickcheck)))
 435     (inputs
 436      `(("ghc-ansi-terminal" ,ghc-ansi-terminal)
 437        ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
 438        ("ghc-hostname" ,ghc-hostname)
 439        ("ghc-old-locale" ,ghc-old-locale)
 440        ("ghc-random" ,ghc-random)
 441        ("ghc-regex-posix" ,ghc-regex-posix)
 442        ("ghc-xml" ,ghc-xml)
 443        ("ghc-libxml" ,ghc-libxml)))
 444     (home-page "https://batterseapower.github.io/test-framework/")
 445     (synopsis "Framework for running and organising tests")
 446     (description
 447      "This package allows tests such as QuickCheck properties and HUnit test
 448 cases to be assembled into test groups, run in parallel (but reported in
 449 deterministic order, to aid diff interpretation) and filtered and controlled
 450 by command line options.  All of this comes with colored test output, progress
 451 reporting and test statistics output.")
 452     (license license:bsd-3)))
 453
 454 (define-public ghc-test-framework-hunit
 455   (package
 456     (name "ghc-test-framework-hunit")
 457     (version "0.3.0.2")
 458     (source
 459      (origin
 460        (method url-fetch)
 461        (uri (string-append "https://hackage.haskell.org/package/"
 462                            "test-framework-hunit/test-framework-hunit-"
 463                            version ".tar.gz"))
 464        (sha256
 465         (base32
 466          "1y0b6vg8nfm43v90lxxcydhi6qlxhfy4vpxbzm5ic2w55bh8xjwm"))))
 467     (build-system haskell-build-system)
 468     (inputs
 469      `(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
 470        ("ghc-hunit" ,ghc-hunit)
 471        ("ghc-test-framework" ,ghc-test-framework)))
 472     (home-page "https://batterseapower.github.io/test-framework/")
 473     (synopsis "HUnit support for test-framework")
 474     (description
 475      "This package provides HUnit support for the test-framework package.")
 476     (license license:bsd-3)))
 477
 478 (define-public ghc-test-framework-quickcheck2
 479   (package
 480     (name "ghc-test-framework-quickcheck2")
 481     (version "0.3.0.3")
 482     (source
 483      (origin
 484        (method url-fetch)
 485        (uri (string-append "https://hackage.haskell.org/package/"
 486                            "test-framework-quickcheck2/"
 487                            "test-framework-quickcheck2-" version ".tar.gz"))
 488        (sha256
 489         (base32
 490          "12p1zwrsz35r3j5gzbvixz9z1h5643rhihf5gqznmc991krwd5nc"))
 491        (modules '((guix build utils)))
 492        (snippet
 493         ;; The Hackage page and the cabal file linked there for this package
 494         ;; both list 2.9 as the upper version limit, but the source tarball
 495         ;; specifies 2.8.  Assume the Hackage page is correct.
 496         '(substitute* "test-framework-quickcheck2.cabal"
 497            (("QuickCheck >= 2.4 && < 2.8") "QuickCheck >= 2.4 && < 2.9")))))
 498     (build-system haskell-build-system)
 499     (inputs
 500      `(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
 501        ("ghc-quickcheck" ,ghc-quickcheck)
 502        ("ghc-random" ,ghc-random)
 503        ("ghc-test-framework" ,ghc-test-framework)))
 504     (home-page "https://batterseapower.github.io/test-framework/")
 505     (synopsis "QuickCheck2 support for test-framework")
 506     (description
 507      "This packages provides QuickCheck2 support for the test-framework
 508 package.")
 509     (license license:bsd-3)))
 510
 511 (define-public ghc-test-framework-th
 512   (package
 513     (name "ghc-test-framework-th")
 514     (version "0.2.4")
 515     (source
 516      (origin
 517        (method url-fetch)
 518        (uri (string-append "https://hackage.haskell.org/package/"
 519                            "test-framework-th-" version "/"
 520                            "test-framework-th-" version ".tar.gz"))
 521        (sha256
 522         (base32
 523          "12lw7yj02jb9s0i7rb98jjam43j2h0gzmnbj9zi933fx7sg0sy4b"))))
 524     (build-system haskell-build-system)
 525     (inputs
 526      `(("ghc-test-framework" ,ghc-test-framework)
 527        ("ghc-language-haskell-extract" ,ghc-language-haskell-extract)
 528        ("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
 529        ("ghc-regex-posix" ,ghc-regex-posix)))
 530     (home-page "https://github.com/finnsson/test-generator")
 531     (synopsis "Auto generate the HUnit- and Quickcheck-bulk-code
 532 using Template Haskell")
 533     (description "This library contains two functions:
 534 @code{defaultMainGenerator} and @code{testGroupGenerator}.
 535
 536 @code{defaultMainGenerator} will extract all functions beginning with
 537 @code{case_}, @code{prop_}, or @code{test_} in the module and put them in a
 538 @code{testGroup}.
 539
 540 @code{testGroupGenerator} is like @code{defaultMainGenerator} but without
 541 @code{defaultMain}.  It is useful if you need a function for the testgroup
 542 \(e.g. if you want to be able to call the testgroup from another module).")
 543     (license license:bsd-3)))
 544
 545 (define-public ghc-hunit
 546   (package
 547     (name "ghc-hunit")
 548     (version "1.2.5.2")
 549     (outputs '("out" "doc"))
 550     (source
 551      (origin
 552        (method url-fetch)
 553        (uri (string-append
 554              "https://hackage.haskell.org/package/HUnit/HUnit-"
 555              version
 556              ".tar.gz"))
 557        (sha256
 558         (base32
 559          "0hcs6qh8bqhip1kkjjnw7ccgcsmawdz5yvffjj5y8zd2vcsavx8a"))))
 560     (build-system haskell-build-system)
 561     (home-page "http://hunit.sourceforge.net/")
 562     (synopsis "Unit testing framework for Haskell")
 563     (description
 564      "HUnit is a unit testing framework for Haskell, inspired by the
 565 JUnit tool for Java.")
 566     (license license:bsd-3)))
 567
 568 (define-public hspec-discover
 569   (package
 570     (name "hspec-discover")
 571     (version "2.2.0")
 572     (source
 573      (origin
 574        (method url-fetch)
 575        (uri (string-append
 576              "https://hackage.haskell.org/package/hspec-discover/hspec-discover-"
 577              version
 578              ".tar.gz"))
 579        (sha256
 580         (base32
 581          "0w3awzbljf4hqhxrjrxqa1lfcclg92bhmq641gz2q80vycspapzx"))))
 582     (build-system haskell-build-system)
 583     (arguments `(#:haddock? #f)) ; Haddock phase fails because there are no
 584                                  ; documentation files.
 585     (inputs `(("ghc-hspec-meta" ,ghc-hspec-meta)))
 586     (home-page "http://hspec.github.io/")
 587     (synopsis "Automatically discover and run Hspec tests")
 588     (description "hspec-discover is a tool which automatically discovers and
 589 runs Hspec tests.")
 590     (license license:expat)))
 591
 592 (define-public ghc-hspec-core
 593   (package
 594     (name "ghc-hspec-core")
 595     (version "2.2.0")
 596     (source
 597      (origin
 598        (method url-fetch)
 599        (uri (string-append
 600              "https://hackage.haskell.org/package/hspec-core/hspec-core-"
 601              version
 602              ".tar.gz"))
 603        (sha256
 604         (base32
 605          "1wgd55k652jaf81nkvciyqi67ycj7zamr4nd9z1cqf8nr9fc3sa4"))))
 606     (build-system haskell-build-system)
 607     (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
 608     (inputs
 609      `(("ghc-setenv" ,ghc-setenv)
 610        ("ghc-ansi-terminal" ,ghc-ansi-terminal)
 611        ("ghc-async" ,ghc-async)
 612        ("ghc-quickcheck-io" ,ghc-quickcheck-io)
 613        ("ghc-hunit" ,ghc-hunit)
 614        ("ghc-quickcheck" ,ghc-quickcheck)
 615        ("ghc-hspec-expectations" ,ghc-hspec-expectations)
 616        ("ghc-silently" ,ghc-silently)))
 617     (home-page "http://hspec.github.io/")
 618     (synopsis "Testing framework for Haskell")
 619     (description "This library exposes internal types and functions that can
 620 be used to extend Hspec's functionality.")
 621     (license license:expat)))
 622
 623 (define-public ghc-hspec-meta
 624   (package
 625     (name "ghc-hspec-meta")
 626     (version "2.2.0")
 627     (source
 628      (origin
 629        (method url-fetch)
 630        (uri (string-append
 631              "https://hackage.haskell.org/package/hspec-meta/hspec-meta-"
 632              version
 633              ".tar.gz"))
 634        (sha256
 635         (base32
 636          "1fmqmgrzp135cxhmxxbaswkk4bqbpgfml00cmcz0d39n11vzpa5z"))))
 637     (build-system haskell-build-system)
 638     (inputs
 639      `(("ghc-quickcheck" ,ghc-quickcheck)
 640        ("ghc-hunit" ,ghc-hunit)
 641        ("ghc-ansi-terminal" ,ghc-ansi-terminal)
 642        ("ghc-async" ,ghc-async)
 643        ("ghc-hspec-expectations" ,ghc-hspec-expectations)
 644        ("ghc-setenv" ,ghc-setenv)
 645        ("ghc-random" ,ghc-random)
 646        ("ghc-quickcheck-io" ,ghc-quickcheck-io)))
 647     (home-page "http://hspec.github.io/")
 648     (synopsis "Version of Hspec to test Hspec itself")
 649     (description "This library provides a stable version of Hspec which is
 650 used to test the in-development version of Hspec.")
 651     (license license:expat)))
 652
 653 (define-public ghc-hspec
 654   (package
 655     (name "ghc-hspec")
 656     (version "2.2.0")
 657     (source
 658      (origin
 659        (method url-fetch)
 660        (uri (string-append
 661              "https://hackage.haskell.org/package/hspec/hspec-"
 662              version
 663              ".tar.gz"))
 664        (sha256
 665         (base32
 666          "0zqisxznlbszivsgy3irvf566zhcr6ipqqj3x9i7pj5hy913jwqf"))))
 667     (build-system haskell-build-system)
 668     (inputs
 669      `(("ghc-hspec-core" ,ghc-hspec-core)
 670        ("hspec-discover" ,hspec-discover)
 671        ("ghc-hspec-expectations" ,ghc-hspec-expectations)
 672        ("ghc-quickcheck" ,ghc-quickcheck)
 673        ("ghc-hunit" ,ghc-hunit)
 674        ("ghc-stringbuilder" ,ghc-stringbuilder)
 675        ("ghc-hspec-meta" ,ghc-hspec-meta)))
 676     (home-page "http://hspec.github.io/")
 677     (synopsis "Testing Framework for Haskell")
 678     (description "This library provides the Hspec testing framework for
 679 Haskell, inspired by the Ruby library RSpec.")
 680     (license license:expat)))
 681
 682 (define-public ghc-hspec-contrib
 683   (package
 684     (name "ghc-hspec-contrib")
 685     (version "0.3.0")
 686     (source (origin
 687               (method url-fetch)
 688               (uri (string-append "https://hackage.haskell.org/package/"
 689                                   "hspec-contrib/hspec-contrib-"
 690                                   version ".tar.gz"))
 691               (sha256
 692                (base32
 693                 "006syw8xagfhsx06ws9ywig1qx5lk4cgl7sq6pbid1s64c72mxn4"))))
 694     (build-system haskell-build-system)
 695     (inputs
 696      `(("ghc-hspec-core" ,ghc-hspec-core)
 697        ("ghc-hunit" ,ghc-hunit)
 698        ("ghc-hspec" ,ghc-hspec)
 699        ("ghc-quickcheck" ,ghc-quickcheck)))
 700     (native-inputs
 701      `(("hspec-discover" ,hspec-discover)))
 702     (home-page "http://hspec.github.io/")
 703     (synopsis "Contributed functionality for Hspec")
 704     (description
 705      "This package provides contributed Hspec extensions.")
 706     (license license:expat)))
 707
 708 (define-public ghc-hspec-expectations
 709   (package
 710     (name "ghc-hspec-expectations")
 711     (version "0.7.2")
 712     (source
 713      (origin
 714        (method url-fetch)
 715        (uri (string-append
 716              "https://hackage.haskell.org/package/hspec-expectations/hspec-expectations-"
 717              version
 718              ".tar.gz"))
 719        (sha256
 720         (base32
 721          "1w56jiqfyl237sr207gh3b0l8sr9layy0mdsgd5wknzb49mif6ip"))))
 722     (build-system haskell-build-system)
 723     (inputs `(("ghc-hunit" ,ghc-hunit)))
 724     (home-page "https://github.com/sol/hspec-expectations")
 725     (synopsis "Catchy combinators for HUnit")
 726     (description "This library provides catchy combinators for HUnit, see
 727 @uref{https://github.com/sol/hspec-expectations#readme, the README}.")
 728     (license license:expat)))