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