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 Nikita <nikita@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 ;;; Copyright © 2019 Timothy Sample <samplet@ngyro.com>
  14 ;;; Copyright © 2020 John Soo <jsoo1@asu.edu>
  15 ;;; Copyright © 2020 Carlo Holl <carloholl@gmail.com>
  16 ;;;
  17 ;;; This file is part of GNU Guix.
  18 ;;;
  19 ;;; GNU Guix is free software; you can redistribute it and/or modify it
  20 ;;; under the terms of the GNU General Public License as published by
  21 ;;; the Free Software Foundation; either version 3 of the License, or (at
  22 ;;; your option) any later version.
  23 ;;;
  24 ;;; GNU Guix is distributed in the hope that it will be useful, but
  25 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
  26 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27 ;;; GNU General Public License for more details.
  28 ;;;
  29 ;;; You should have received a copy of the GNU General Public License
  30 ;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.
  31
  32 (define-module (gnu packages haskell-check)
  33   #:use-module (gnu packages)
  34   #:use-module (gnu packages haskell-crypto)
  35   #:use-module (gnu packages haskell-xyz)
  36   #:use-module (guix build-system haskell)
  37   #:use-module (guix download)
  38   #:use-module ((guix licenses) #:prefix license:)
  39   #:use-module (guix packages)
  40   #:use-module (guix utils))
  41
  42 (define-public ghc-tasty-ant-xml
  43   (package
  44     (name "ghc-tasty-ant-xml")
  45     (version "1.1.6")
  46     (source
  47      (origin
  48        (method url-fetch)
  49        (uri (string-append
  50              "https://hackage.haskell.org/package/tasty-ant-xml/tasty-ant-xml-"
  51              version
  52              ".tar.gz"))
  53        (sha256
  54         (base32
  55          "13qqpl1prr9dda87dp45mqybay24n8rhxxgvpc9j34kh72g8j5qw"))))
  56     (build-system haskell-build-system)
  57     (inputs
  58      `(("ghc-generic-deriving" ,ghc-generic-deriving)
  59        ("ghc-xml" ,ghc-xml)
  60        ("ghc-tagged" ,ghc-tagged)
  61        ("ghc-tasty" ,ghc-tasty)))
  62     (home-page
  63      "https://github.com/ocharles/tasty-ant-xml")
  64     (synopsis
  65      "Render tasty output to XML for Jenkins")
  66     (description
  67      "A tasty ingredient to output test results in XML, using the Ant
  68 schema.  This XML can be consumed by the Jenkins continuous integration
  69 framework.")
  70     (license license:bsd-3)))
  71
  72 (define-public ghc-tasty-smallcheck
  73   (package
  74     (name "ghc-tasty-smallcheck")
  75     (version "0.8.1")
  76     (source
  77      (origin
  78        (method url-fetch)
  79        (uri (string-append
  80              "https://hackage.haskell.org/package/tasty-smallcheck/tasty-smallcheck-"
  81              version
  82              ".tar.gz"))
  83        (sha256
  84         (base32
  85          "1n66ngzllf3xrlqykwszlkwsi96n5nkm7xbpfq7774vpvfnafjri"))))
  86     (build-system haskell-build-system)
  87     (inputs
  88      `(("ghc-tasty" ,ghc-tasty)
  89        ("ghc-smallcheck" ,ghc-smallcheck)
  90        ("ghc-async" ,ghc-async)
  91        ("ghc-tagged" ,ghc-tagged)))
  92     (home-page "https://documentup.com/feuerbach/tasty")
  93     (synopsis "SmallCheck support for the Tasty test framework")
  94     (description "This package provides SmallCheck support for the Tasty
  95 Haskell test framework.")
  96     (license license:bsd-3)))
  97
  98 (define-public ghc-tasty-quickcheck
  99   (package
 100     (name "ghc-tasty-quickcheck")
 101     (version "0.10.1")
 102     (source
 103      (origin
 104        (method url-fetch)
 105        (uri (string-append
 106              "https://hackage.haskell.org/package/tasty-quickcheck/"
 107              "tasty-quickcheck-" version ".tar.gz"))
 108        (sha256
 109         (base32
 110          "0k4vvd5vmrncv1s6gdf03l4xijwlk428sb9jfx8n1zaz02971msh"))))
 111     (build-system haskell-build-system)
 112     (inputs
 113      `(("ghc-quickcheck" ,ghc-quickcheck)
 114        ("ghc-tagged" ,ghc-tagged)
 115        ("ghc-tasty" ,ghc-tasty)
 116        ("ghc-random" ,ghc-random)
 117        ("ghc-ansi-terminal" ,ghc-ansi-terminal)
 118        ("ghc-tasty-hunit" ,ghc-tasty-hunit)
 119        ("ghc-pcre-light" ,ghc-pcre-light)))
 120     (home-page "http://documentup.com/feuerbach/tasty")
 121     (synopsis "QuickCheck support for the Tasty test framework")
 122     (description "This package provides QuickCheck support for the Tasty
 123 Haskell test framework.")
 124     (license license:expat)))
 125
 126 (define-public ghc-tasty-golden
 127   (package
 128     (name "ghc-tasty-golden")
 129     (version "2.3.2")
 130     (source
 131      (origin
 132        (method url-fetch)
 133        (uri (string-append
 134              "https://hackage.haskell.org/package/tasty-golden/tasty-golden-"
 135              version
 136              ".tar.gz"))
 137        (sha256
 138         (base32
 139          "0k3ibjhjc9vcwzrjnl4rnwvfm8l81q347nb7dgvcib6n5wm3s404"))))
 140     (build-system haskell-build-system)
 141     (inputs
 142      `(("ghc-temporary" ,ghc-temporary)
 143        ("ghc-tasty" ,ghc-tasty)
 144        ("ghc-optparse-applicative" ,ghc-optparse-applicative)
 145        ("ghc-tagged" ,ghc-tagged)
 146        ("ghc-async" ,ghc-async)
 147        ("ghc-tasty-hunit" ,ghc-tasty-hunit)
 148        ("ghc-temporary-rc" ,ghc-temporary-rc)))
 149     (home-page
 150      "https://github.com/feuerbach/tasty-golden")
 151     (synopsis "Golden tests support for tasty")
 152     (description
 153      "This package provides support for @code{golden testing}.  A @dfn{golden
 154 test} is an IO action that writes its result to a file.  To pass the test, this
 155 output file should be identical to the corresponding @code{golden} file, which
 156 contains the correct result for the test.")
 157     (license license:expat)))
 158
 159 (define-public ghc-tasty
 160   (package
 161     (name "ghc-tasty")
 162     (version "1.2.3")
 163     (source
 164      (origin
 165        (method url-fetch)
 166        (uri (string-append
 167              "https://hackage.haskell.org/package/tasty/tasty-"
 168              version
 169              ".tar.gz"))
 170        (sha256
 171         (base32
 172          "0qpn0avpw4w1qq5r2gwh2piipj0llqq6ylagr3xnqiraq6mhg8cc"))))
 173     (build-system haskell-build-system)
 174     (inputs
 175      `(("ghc-tagged" ,ghc-tagged)
 176        ("ghc-regex-tdfa" ,ghc-regex-tdfa)
 177        ("ghc-optparse-applicative" ,ghc-optparse-applicative)
 178        ("ghc-unbounded-delays" ,ghc-unbounded-delays)
 179        ("ghc-async" ,ghc-async)
 180        ("ghc-ansi-terminal" ,ghc-ansi-terminal)
 181        ("ghc-clock-bootstrap" ,ghc-clock-bootstrap)
 182        ("ghc-wcwidth" ,ghc-wcwidth-bootstrap)))
 183     (home-page "http://documentup.com/feuerbach/tasty")
 184     (synopsis "Modern and extensible testing framework")
 185     (description "Tasty is a modern testing framework for Haskell.  It lets
 186 you combine your unit tests, golden tests, QuickCheck/SmallCheck properties,
 187 and any other types of tests into a single test suite.")
 188     (license license:expat)))
 189
 190 (define-public ghc-tasty-hedgehog
 191   (package
 192     (name "ghc-tasty-hedgehog")
 193     (version "1.0.0.1")
 194     (source
 195      (origin
 196        (method url-fetch)
 197        (uri (string-append "https://hackage.haskell.org/package/"
 198                            "tasty-hedgehog/tasty-hedgehog-" version ".tar.gz"))
 199        (sha256
 200         (base32
 201          "1mbg5q0c0xfrk4npfj60pi693igb7r5l78x6xf9fk2jglw0nmxhz"))))
 202     (build-system haskell-build-system)
 203     (inputs
 204      `(("ghc-tagged" ,ghc-tagged)
 205        ("ghc-tasty" ,ghc-tasty)
 206        ("ghc-hedgehog" ,ghc-hedgehog)))
 207     (native-inputs
 208      `(("ghc-tasty-expected-failure" ,ghc-tasty-expected-failure)))
 209     (arguments
 210      `(#:cabal-revision
 211        ("1" "1n6797fm8swyrk8cw7zxz593gq82wx8dayvm204rmgcz75bslcpn")))
 212     (home-page "https://github.com/qfpl/tasty-hedgehog")
 213     (synopsis "Integration for tasty and hedgehog")
 214     (description "This package provides the means for integrating the
 215 @url{https://hackage.haskell.org/package/hedgehog, hedgehog testing library}
 216 with the @url{https://hackage.haskell.org/package/tasty, tasty testing
 217 framework}.")
 218     (license license:bsd-3)))
 219
 220 (define-public ghc-tasty-hspec
 221   (package
 222     (name "ghc-tasty-hspec")
 223     (version "1.1.5.1")
 224     (source
 225      (origin
 226        (method url-fetch)
 227        (uri (string-append
 228              "mirror://hackage/package/tasty-hspec/tasty-hspec-"
 229              version
 230              ".tar.gz"))
 231        (sha256
 232         (base32
 233          "0i9kdzjpk750sa078jj3iyhp72k0177zk7vxl131r6dkyz09x27y"))))
 234     (build-system haskell-build-system)
 235     (inputs
 236      `(("ghc-hspec" ,ghc-hspec)
 237        ("ghc-hspec-core" ,ghc-hspec-core)
 238        ("ghc-quickcheck" ,ghc-quickcheck)
 239        ("ghc-tasty" ,ghc-tasty)
 240        ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)
 241        ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
 242     (arguments
 243      `(#:cabal-revision
 244        ("4" "1yppwhs2r2rlwrzli9ccv5ldgl95h5p7pqhsr898r3das6daf6sk")))
 245     (home-page
 246      "https://github.com/mitchellwrosen/tasty-hspec")
 247     (synopsis
 248      "Hspec support for the Tasty test framework")
 249     (description
 250      "This package provides a Tasty provider for Hspec test suites.")
 251     (license license:bsd-3)))
 252
 253 (define-public ghc-tasty-hunit
 254   (package
 255     (name "ghc-tasty-hunit")
 256     (version "0.10.0.2")
 257     (source
 258      (origin
 259        (method url-fetch)
 260        (uri (string-append
 261              "https://hackage.haskell.org/package/tasty-hunit/tasty-hunit-"
 262              version
 263              ".tar.gz"))
 264        (sha256
 265         (base32
 266          "1xvf5xs0r8xqkcg354klz4wyzwyzvinalyl6f4fnxwqmzrgch8s8"))))
 267     (build-system haskell-build-system)
 268     (inputs
 269      `(("ghc-call-stack" ,ghc-call-stack-boot)
 270        ("ghc-tasty" ,ghc-tasty)))
 271     (home-page "http://documentup.com/feuerbach/tasty")
 272     (synopsis "HUnit support for the Tasty test framework")
 273     (description "This package provides HUnit support for the Tasty Haskell
 274 test framework.")
 275     (license license:expat)))
 276
 277 (define-public ghc-tasty-kat
 278   (package
 279     (name "ghc-tasty-kat")
 280     (version "0.0.3")
 281     (source (origin
 282               (method url-fetch)
 283               (uri (string-append "https://hackage.haskell.org/package/"
 284                                   "tasty-kat/tasty-kat-" version ".tar.gz"))
 285               (sha256
 286                (base32
 287                 "14yvlpli6cv6bn3kh8mlfp4x1l6ns4fvmfv6hmj75cvxyzq029d7"))))
 288     (build-system haskell-build-system)
 289     (inputs
 290      `(("ghc-tasty" ,ghc-tasty)
 291        ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
 292        ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
 293     (home-page "https://github.com/vincenthz/tasty-kat")
 294     (synopsis "Known Answer Tests (KAT) framework for tasty")
 295     (description
 296      "This package provides a @dfn{Known Answer Tests} (KAT) framework for
 297 tasty.")
 298     (license license:expat)))
 299
 300 (define-public ghc-tasty-lua
 301   (package
 302     (name "ghc-tasty-lua")
 303     (version "0.2.0.1")
 304     (source
 305      (origin
 306        (method url-fetch)
 307        (uri (string-append "https://hackage.haskell.org/package/"
 308                            "tasty-lua/tasty-lua-" version ".tar.gz"))
 309        (sha256
 310         (base32
 311          "0xlj36rrhkx312h7smx6ay20rhlhxvw2ma2ckdnzv1pvmdn6p5qx"))))
 312     (build-system haskell-build-system)
 313     (inputs
 314      `(("ghc-file-embed" ,ghc-file-embed)
 315        ("ghc-hslua" ,ghc-hslua)
 316        ("ghc-tasty" ,ghc-tasty)))
 317     (native-inputs
 318      `(("ghc-tasty-hunit" ,ghc-tasty-hunit)))
 319     (home-page "https://github.com/hslua/tasty-lua")
 320     (synopsis "Write tests in Lua, integrate into tasty")
 321     (description "This package gives users the ability to define tasty tests
 322 from Lua.")
 323     (license license:expat)))
 324
 325 (define-public ghc-tasty-th
 326   (package
 327     (name "ghc-tasty-th")
 328     (version "0.1.7")
 329     (source
 330      (origin
 331        (method url-fetch)
 332        (uri (string-append
 333              "https://hackage.haskell.org/package/tasty-th/tasty-th-"
 334              version ".tar.gz"))
 335        (sha256
 336         (base32
 337          "0b2ivrw2257m4cy4rjnkwqlarh83j1y3zywnmaqqqbvy667sqnj3"))))
 338     (build-system haskell-build-system)
 339     (inputs
 340      `(("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
 341        ("ghc-tasty" ,ghc-tasty)
 342        ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
 343     (home-page "https://github.com/bennofs/tasty-th")
 344     (synopsis "Automatically generate tasty TestTrees")
 345     (description
 346       "Tasty-th automatically generates tasty TestTrees from functions of the
 347 current module, using TemplateHaskell.  This is a fork the original
 348 test-framework-th package, modified to work with tasty instead of
 349 test-framework.")
 350     (license license:bsd-3)))
 351
 352 (define-public ghc-tasty-rerun
 353   (package
 354     (name "ghc-tasty-rerun")
 355     (version "1.1.14")
 356     (source (origin
 357               (method url-fetch)
 358               (uri (string-append
 359                     "https://hackage.haskell.org/package/tasty-rerun/"
 360                     "tasty-rerun-" version ".tar.gz"))
 361               (sha256
 362                (base32
 363                 "0s0zj8ds4g1w2cjzm2lh25ivg962jigqdrbj08v3dbz64lx4mlzr"))))
 364     (build-system haskell-build-system)
 365     (inputs
 366      `(("ghc-optparse-applicative" ,ghc-optparse-applicative)
 367        ("ghc-reducers" ,ghc-reducers)
 368        ("ghc-split" ,ghc-split)
 369        ("ghc-tagged" ,ghc-tagged)
 370        ("ghc-tasty" ,ghc-tasty)))
 371     (home-page "https://github.com/ocharles/tasty-rerun")
 372     (synopsis "Run tests by filtering the test tree")
 373     (description "This package adds the ability to run tests by filtering the
 374 test tree based on the result of a previous test run.  You can use this to run
 375 only those tests that failed in the last run, or to only run the tests that have
 376 been added since previous test run.")
 377   (license license:bsd-3)))
 378
 379 (define-public ghc-tasty-expected-failure
 380   (package
 381     (name "ghc-tasty-expected-failure")
 382     (version "0.11.1.2")
 383     (source
 384      (origin
 385        (method url-fetch)
 386        (uri (string-append "https://hackage.haskell.org/package/"
 387                            "tasty-expected-failure/tasty-expected-failure-"
 388                            version ".tar.gz"))
 389        (sha256
 390         (base32
 391          "175gdk1mkslcwjxajkbl4zmaigzf8h4svzd7va5qb519y0dxk28n"))))
 392     (build-system haskell-build-system)
 393     (inputs
 394      `(("ghc-tagged" ,ghc-tagged)
 395        ("ghc-tasty" ,ghc-tasty)))
 396     (home-page "https://github.com/nomeata/tasty-expected-failure")
 397     (synopsis "Mark tasty tests as failure expected")
 398     (description
 399      "With the function @code{Test.Tasty.ExpectedFailure.expectFail} in the
 400 provided module @code{Test.Tasty.ExpectedFailure}, you can mark that you
 401 expect test cases to fail, and not to pass. This can be used for test-driven
 402 development.")
 403     (license license:expat)))
 404
 405 (define-public ghc-quickcheck-instances
 406   (package
 407     (name "ghc-quickcheck-instances")
 408     (version "0.3.22")
 409     (source
 410      (origin
 411        (method url-fetch)
 412        (uri (string-append
 413              "https://hackage.haskell.org/package/"
 414              "quickcheck-instances/quickcheck-instances-"
 415              version ".tar.gz"))
 416        (sha256
 417         (base32
 418          "14asr9r7da3w7p4hjj51w2yb002nz8x0np8hdz9z4yjvi60vyrax"))))
 419     (build-system haskell-build-system)
 420     (arguments
 421      `(#:cabal-revision
 422        ("2" "1ia5fjhpg7rz793552v88gv2iqx7hl9mi2g09m0llasy1cpzc9jr")))
 423     (inputs
 424      `(("ghc-quickcheck" ,ghc-quickcheck)
 425        ("ghc-base-compat" ,ghc-base-compat)
 426        ("ghc-case-insensitive" ,ghc-case-insensitive)
 427        ("ghc-hashable" ,ghc-hashable)
 428        ("ghc-old-time" ,ghc-old-time)
 429        ("ghc-scientific" ,ghc-scientific)
 430        ("ghc-tagged" ,ghc-tagged)
 431        ("ghc-time-compat" ,ghc-time-compat)
 432        ("ghc-transformers-compat" ,ghc-transformers-compat)
 433        ("ghc-unordered-containers" ,ghc-unordered-containers)
 434        ("ghc-uuid-types" ,ghc-uuid-types)
 435        ("ghc-vector" ,ghc-vector)))
 436     (home-page "https://github.com/aslatter/qc-instances")
 437     (synopsis "Common quickcheck instances")
 438     (description "This package provides QuickCheck instances for types
 439 provided by the Haskell Platform.")
 440     (license license:bsd-3)))
 441
 442 (define-public ghc-quickcheck-unicode
 443   (package
 444     (name "ghc-quickcheck-unicode")
 445     (version "1.0.1.0")
 446     (source
 447      (origin
 448        (method url-fetch)
 449        (uri (string-append
 450              "https://hackage.haskell.org/package/quickcheck-unicode/"
 451              "quickcheck-unicode-" version ".tar.gz"))
 452        (sha256
 453         (base32
 454          "0s43s1bzbg3gwsjgm7fpyksd1339f0m26dlw2famxwyzgvm0a80k"))))
 455     (build-system haskell-build-system)
 456     (inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
 457     (home-page
 458      "https://github.com/bos/quickcheck-unicode")
 459     (synopsis "Generator functions Unicode-related tests")
 460     (description "This package provides generator and shrink functions for
 461 testing Unicode-related software.")
 462     (license license:bsd-3)))
 463
 464 (define-public ghc-quickcheck-io
 465   (package
 466     (name "ghc-quickcheck-io")
 467     (version "0.2.0")
 468     (source
 469      (origin
 470        (method url-fetch)
 471        (uri (string-append
 472              "https://hackage.haskell.org/package/quickcheck-io/quickcheck-io-"
 473              version
 474              ".tar.gz"))
 475        (sha256
 476         (base32
 477          "08k4v7pkgjf30pv5j2dfv1gqv6hclxlniyq2sps8zq4zswcr2xzv"))))
 478     (build-system haskell-build-system)
 479     (inputs
 480      `(("ghc-quickcheck" ,ghc-quickcheck)
 481        ("ghc-hunit" ,ghc-hunit)))
 482     (home-page
 483      "https://github.com/hspec/quickcheck-io#readme")
 484     (synopsis "Use HUnit assertions as QuickCheck properties")
 485     (description "This package provides an orphan instance that allows you to
 486 use HUnit assertions as QuickCheck properties.")
 487     (license license:expat)))
 488
 489 (define-public ghc-quickcheck
 490   (package
 491     (name "ghc-quickcheck")
 492     (version "2.13.2")
 493     (outputs '("out" "static" "doc"))
 494     (source
 495      (origin
 496        (method url-fetch)
 497        (uri (string-append
 498              "https://hackage.haskell.org/package/QuickCheck/QuickCheck-"
 499              version
 500              ".tar.gz"))
 501        (sha256
 502         (base32
 503          "0426j43af8v3qmdjjqxivazsvr3a2brac8yw09vpgpjkb2m0nmkv"))))
 504     (build-system haskell-build-system)
 505     (inputs
 506      `(("ghc-random" ,ghc-random)
 507        ("ghc-splitmix" ,ghc-splitmix-bootstrap)))
 508     (home-page "https://github.com/nick8325/quickcheck")
 509     (synopsis "Automatic testing of Haskell programs")
 510     (description
 511      "QuickCheck is a library for random testing of program properties.  The
 512 programmer provides a specification of the program, in the form of properties
 513 which functions should satisfy, and QuickCheck then tests that the properties
 514 hold in a large number of randomly generated cases.  Specifications are
 515 expressed in Haskell, using combinators defined in the QuickCheck library.")
 516     (license license:bsd-3)))
 517
 518 (define-public ghc-test-framework
 519   (package
 520     (name "ghc-test-framework")
 521     (version "0.8.2.0")
 522     (source
 523      (origin
 524        (method url-fetch)
 525        (uri (string-append "https://hackage.haskell.org/package/test-framework/"
 526                            "test-framework-" version ".tar.gz"))
 527        (sha256
 528         (base32
 529          "1hhacrzam6b8f10hyldmjw8pb7frdxh04rfg3farxcxwbnhwgbpm"))))
 530     (build-system haskell-build-system)
 531     (arguments
 532      `(#:tests? #f  ; FIXME: Tests do not build.
 533        #:cabal-revision
 534        ("5" "18g92ajx3ghznd6k3ihj22ln29n676ailzwx3k0f1kj3bmpilnh6")))
 535     (native-inputs
 536      `(("ghc-hunit" ,ghc-hunit)
 537        ("ghc-quickcheck" ,ghc-quickcheck)))
 538     (inputs
 539      `(("ghc-ansi-terminal" ,ghc-ansi-terminal)
 540        ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
 541        ("ghc-hostname" ,ghc-hostname)
 542        ("ghc-old-locale" ,ghc-old-locale)
 543        ("ghc-random" ,ghc-random)
 544        ("ghc-regex-posix" ,ghc-regex-posix)
 545        ("ghc-xml" ,ghc-xml)
 546        ("ghc-libxml" ,ghc-libxml)
 547        ("ghc-semigroups" ,ghc-semigroups-bootstrap)))
 548     (home-page "https://batterseapower.github.io/test-framework/")
 549     (synopsis "Framework for running and organising tests")
 550     (description
 551      "This package allows tests such as QuickCheck properties and HUnit test
 552 cases to be assembled into test groups, run in parallel (but reported in
 553 deterministic order, to aid diff interpretation) and filtered and controlled
 554 by command line options.  All of this comes with colored test output, progress
 555 reporting and test statistics output.")
 556     (license license:bsd-3)))
 557
 558 (define-public ghc-test-framework-hunit
 559   (package
 560     (name "ghc-test-framework-hunit")
 561     (version "0.3.0.2")
 562     (source
 563      (origin
 564        (method url-fetch)
 565        (uri (string-append "https://hackage.haskell.org/package/"
 566                            "test-framework-hunit/test-framework-hunit-"
 567                            version ".tar.gz"))
 568        (sha256
 569         (base32
 570          "1y0b6vg8nfm43v90lxxcydhi6qlxhfy4vpxbzm5ic2w55bh8xjwm"))))
 571     (build-system haskell-build-system)
 572     (arguments
 573      `(#:cabal-revision
 574        ("3" "0i9mlalv7cl1iq43ld5myrnpszq5rxmd79hk495dcb08rglhgl3z")))
 575     (inputs
 576      `(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
 577        ("ghc-hunit" ,ghc-hunit)
 578        ("ghc-test-framework" ,ghc-test-framework)))
 579     (home-page "https://batterseapower.github.io/test-framework/")
 580     (synopsis "HUnit support for test-framework")
 581     (description
 582      "This package provides HUnit support for the test-framework package.")
 583     (license license:bsd-3)))
 584
 585 (define-public ghc-test-framework-quickcheck2
 586   (package
 587     (name "ghc-test-framework-quickcheck2")
 588     (version "0.3.0.5")
 589     (source
 590      (origin
 591        (method url-fetch)
 592        (uri (string-append "https://hackage.haskell.org/package/"
 593                            "test-framework-quickcheck2/"
 594                            "test-framework-quickcheck2-" version ".tar.gz"))
 595        (sha256
 596         (base32
 597          "0ngf9vvby4nrdf1i7dxf5m9jn0g2pkq32w48xdr92n9hxka7ixn9"))))
 598     (build-system haskell-build-system)
 599     (arguments
 600      `(#:cabal-revision
 601        ("1" "1vmpk70h1594h9s216d3ngkb399fpny1d3sh4gg0vrc75p4as68d")))
 602     (inputs
 603      `(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
 604        ("ghc-quickcheck" ,ghc-quickcheck)
 605        ("ghc-random" ,ghc-random)
 606        ("ghc-test-framework" ,ghc-test-framework)))
 607     (home-page "https://batterseapower.github.io/test-framework/")
 608     (synopsis "QuickCheck2 support for test-framework")
 609     (description
 610      "This package provides QuickCheck2 support for the test-framework
 611 package.")
 612     (license license:bsd-3)))
 613
 614 (define-public ghc-test-framework-th
 615   (package
 616     (name "ghc-test-framework-th")
 617     (version "0.2.4")
 618     (source
 619      (origin
 620        (method url-fetch)
 621        (uri (string-append "https://hackage.haskell.org/package/"
 622                            "test-framework-th-" version "/"
 623                            "test-framework-th-" version ".tar.gz"))
 624        (sha256
 625         (base32
 626          "12lw7yj02jb9s0i7rb98jjam43j2h0gzmnbj9zi933fx7sg0sy4b"))))
 627     (build-system haskell-build-system)
 628     (inputs
 629      `(("ghc-test-framework" ,ghc-test-framework)
 630        ("ghc-language-haskell-extract" ,ghc-language-haskell-extract)
 631        ("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
 632        ("ghc-regex-posix" ,ghc-regex-posix)))
 633     (home-page "https://github.com/finnsson/test-generator")
 634     (synopsis "Auto generate the HUnit- and Quickcheck-bulk-code
 635 using Template Haskell")
 636     (description "This library contains two functions:
 637 @code{defaultMainGenerator} and @code{testGroupGenerator}.
 638
 639 @code{defaultMainGenerator} will extract all functions beginning with
 640 @code{case_}, @code{prop_}, or @code{test_} in the module and put them in a
 641 @code{testGroup}.
 642
 643 @code{testGroupGenerator} is like @code{defaultMainGenerator} but without
 644 @code{defaultMain}.  It is useful if you need a function for the testgroup
 645 \(e.g. if you want to be able to call the testgroup from another module).")
 646     (license license:bsd-3)))
 647
 648 (define-public ghc-hunit
 649   (package
 650     (name "ghc-hunit")
 651     (version "1.6.0.0")
 652     (outputs '("out" "static" "doc"))
 653     (source
 654      (origin
 655        (method url-fetch)
 656        (uri (string-append "https://hackage.haskell.org/package/HUnit/"
 657                            "HUnit-" version ".tar.gz"))
 658        (sha256
 659         (base32
 660          "1pnhwqq5v8h48gbp3ibv3skfj25mf4zs5svxcavq93p9cswycj3l"))))
 661     (build-system haskell-build-system)
 662     (inputs
 663      ;; We cannot use ghc-call-stack there, because it depends on
 664      ;; ghc-nanospec, which depends on ghc-hunit.
 665      `(("ghc-call-stack" ,ghc-call-stack-boot)))
 666     (home-page "http://hunit.sourceforge.net/")
 667     (synopsis "Unit testing framework for Haskell")
 668     (description
 669      "HUnit is a unit testing framework for Haskell, inspired by the
 670 JUnit tool for Java.")
 671     (license license:bsd-3)))
 672
 673 (define-public hspec-discover
 674   (package
 675     (name "hspec-discover")
 676     (version "2.7.1")
 677     (source
 678      (origin
 679        (method url-fetch)
 680        (uri (string-append "https://hackage.haskell.org/package/"
 681                            "hspec-discover/hspec-discover-"
 682                            version ".tar.gz"))
 683        (sha256
 684         (base32
 685          "0r47fm94wa6qrhp8cc1zzkjrxc32rnagfn9m9ga4dm6p6ydw4c8b"))))
 686     (build-system haskell-build-system)
 687     (native-inputs
 688      `(("ghc-quickcheck" ,ghc-quickcheck)
 689        ("ghc-hspec-meta" ,ghc-hspec-meta)))
 690     (home-page "https://hspec.github.io/")
 691     (synopsis "Automatically discover and run Hspec tests")
 692     (description "hspec-discover is a tool which automatically discovers and
 693 runs Hspec tests.")
 694     (license license:expat)))
 695
 696 (define-public ghc-hspec-core
 697   (package
 698     (name "ghc-hspec-core")
 699     (version "2.7.1")
 700     (source
 701      (origin
 702        (method url-fetch)
 703        (uri (string-append "https://hackage.haskell.org/package/hspec-core/"
 704                            "hspec-core-" version ".tar.gz"))
 705        (sha256
 706         (base32
 707          "08vk8588lap00hsln8zl64dazbb28lzk4b4h5vnm7xvhg7r21k1c"))))
 708     (build-system haskell-build-system)
 709     (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
 710     (inputs
 711      `(("ghc-setenv" ,ghc-setenv)
 712        ("ghc-ansi-terminal" ,ghc-ansi-terminal)
 713        ("ghc-clock" ,ghc-clock)
 714        ("ghc-quickcheck-io" ,ghc-quickcheck-io)
 715        ("ghc-hunit" ,ghc-hunit)
 716        ("ghc-quickcheck" ,ghc-quickcheck)
 717        ("ghc-hspec-expectations" ,ghc-hspec-expectations)
 718        ("ghc-silently" ,ghc-silently)
 719        ("ghc-tf-random" ,ghc-tf-random)))
 720     (home-page "https://hspec.github.io/")
 721     (synopsis "Testing framework for Haskell")
 722     (description "This library exposes internal types and functions that can
 723 be used to extend Hspec's functionality.")
 724     (license license:expat)))
 725
 726 (define-public ghc-hspec-meta
 727   (package
 728     (name "ghc-hspec-meta")
 729     (version "2.6.0")
 730     (source
 731      (origin
 732        (method url-fetch)
 733        (uri (string-append "https://hackage.haskell.org/package/hspec-meta/"
 734                            "hspec-meta-" version ".tar.gz"))
 735        (sha256
 736         (base32
 737          "1n1a4633wfivylglji8920f67mx7qz8j4q58n8p7dxk6yg4h3mz6"))))
 738     (build-system haskell-build-system)
 739     (inputs
 740      `(("ghc-quickcheck" ,ghc-quickcheck)
 741        ("ghc-hunit" ,ghc-hunit)
 742        ("ghc-ansi-terminal" ,ghc-ansi-terminal)
 743        ("ghc-clock" ,ghc-clock)
 744        ("ghc-hspec-expectations" ,ghc-hspec-expectations)
 745        ("ghc-setenv" ,ghc-setenv)
 746        ("ghc-random" ,ghc-random)
 747        ("ghc-quickcheck-io" ,ghc-quickcheck-io)))
 748     (home-page "https://hspec.github.io/")
 749     (synopsis "Version of Hspec to test Hspec itself")
 750     (description "This library provides a stable version of Hspec which is
 751 used to test the in-development version of Hspec.")
 752     (license license:expat)))
 753
 754 (define-public ghc-hspec
 755   (package
 756     (name "ghc-hspec")
 757     (version "2.7.1")
 758     (source
 759      (origin
 760        (method url-fetch)
 761        (uri (string-append "https://hackage.haskell.org/package/hspec/"
 762                            "hspec-" version ".tar.gz"))
 763        (sha256
 764         (base32
 765          "1x8rcr7j1azcaw0fg1xzp8j0gr4ias36z09aj24i4xp8pnyfp341"))))
 766     (build-system haskell-build-system)
 767     (outputs '("out" "static" "doc"))
 768     (inputs
 769      `(("ghc-hspec-core" ,ghc-hspec-core)
 770        ("hspec-discover" ,hspec-discover)
 771        ("ghc-hspec-expectations" ,ghc-hspec-expectations)
 772        ("ghc-quickcheck" ,ghc-quickcheck)
 773        ("ghc-hunit" ,ghc-hunit)
 774        ("ghc-stringbuilder" ,ghc-stringbuilder)
 775        ("ghc-hspec-meta" ,ghc-hspec-meta)))
 776     (home-page "https://hspec.github.io/")
 777     (synopsis "Testing Framework for Haskell")
 778     (description "This library provides the Hspec testing framework for
 779 Haskell, inspired by the Ruby library RSpec.")
 780     (license license:expat)))
 781
 782 (define-public ghc-hspec-contrib
 783   (package
 784     (name "ghc-hspec-contrib")
 785     (version "0.5.1")
 786     (source (origin
 787               (method url-fetch)
 788               (uri (string-append "https://hackage.haskell.org/package/"
 789                                   "hspec-contrib/hspec-contrib-"
 790                                   version ".tar.gz"))
 791               (sha256
 792                (base32
 793                 "0hhzxaa3fxz5mk5qcsrnfr98a7bn3szx2ydgr0x9mbqmm1jg06rc"))))
 794     (build-system haskell-build-system)
 795     (inputs
 796      `(("ghc-hspec-core" ,ghc-hspec-core)
 797        ("ghc-hunit" ,ghc-hunit)
 798        ("ghc-hspec" ,ghc-hspec)
 799        ("ghc-quickcheck" ,ghc-quickcheck)))
 800     (native-inputs
 801      `(("hspec-discover" ,hspec-discover)))
 802     (home-page "https://hspec.github.io/")
 803     (synopsis "Contributed functionality for Hspec")
 804     (description
 805      "This package provides contributed Hspec extensions.")
 806     (license license:expat)))
 807
 808 (define-public ghc-hspec-expectations
 809   (package
 810     (name "ghc-hspec-expectations")
 811     (version "0.8.2")
 812     (source
 813      (origin
 814        (method url-fetch)
 815        (uri (string-append "https://hackage.haskell.org/package/"
 816                            "hspec-expectations/hspec-expectations-"
 817                            version ".tar.gz"))
 818        (sha256
 819         (base32
 820          "1vxl9zazbaapijr6zmcj72j9wf7ka1pirrjbwddwwddg3zm0g5l1"))))
 821     (build-system haskell-build-system)
 822     ;; Tests depend on ghc-nanospec.
 823     (arguments '(#:tests? #f))
 824     (inputs `(("ghc-hunit" ,ghc-hunit)))
 825     (home-page "https://github.com/sol/hspec-expectations")
 826     (synopsis "Catchy combinators for HUnit")
 827     (description "This library provides catchy combinators for HUnit, see
 828 @uref{https://github.com/sol/hspec-expectations#readme, the README}.")
 829     (license license:expat)))
 830
 831 (define-public ghc-nanospec
 832   (package
 833     (name "ghc-nanospec")
 834     (version "0.2.2")
 835     (source
 836      (origin
 837        (method url-fetch)
 838        (uri (string-append "https://hackage.haskell.org/package/"
 839                            "nanospec/nanospec-"
 840                            version ".tar.gz"))
 841        (sha256
 842         (base32
 843          "1rcmhl9bhyfvanalnf1r86wkx6rq6wdvagnw1h011jcnnb1cq56g"))))
 844     (build-system haskell-build-system)
 845     (inputs
 846      `(("ghc-hspec" ,ghc-hspec)
 847        ("ghc-silently" ,ghc-silently)))
 848     (home-page "https://github.com/hspec/nanospec#readme")
 849     (synopsis "Lightweight implementation of a subset of Hspec's API")
 850     (description
 851      "Nanospec is a lightweight implementation of a subset of Hspec's API with
 852 minimal dependencies.")
 853     (license license:expat)))
 854
 855 (define-public ghc-crypto-cipher-tests
 856   (package
 857     (name "ghc-crypto-cipher-tests")
 858     (version "0.0.11")
 859     (source
 860      (origin
 861        (method url-fetch)
 862        (uri (string-append "https://hackage.haskell.org/package/"
 863                            "crypto-cipher-tests-" version "/"
 864                            "crypto-cipher-tests-" version ".tar.gz"))
 865        (sha256
 866         (base32
 867          "19wqignlq90qwpam01hnmmrxaxh5lkax9l1l6rlbi4a07nvp1dnz"))))
 868     (build-system haskell-build-system)
 869     (inputs `(("ghc-quickcheck" ,ghc-quickcheck)
 870               ("ghc-hunit" ,ghc-hunit)
 871               ("ghc-test-framework" ,ghc-test-framework)
 872               ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
 873               ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
 874               ("ghc-byteable" ,ghc-byteable)
 875               ("ghc-securemem" ,ghc-securemem)
 876               ("ghc-crypto-cipher-types" ,ghc-crypto-cipher-types)))
 877     (home-page "https://github.com/vincenthz/hs-crypto-cipher")
 878     (synopsis "Generic cryptography cipher tests for Haskell")
 879     (description " This Haskell package contains generic tests for
 880 cryptographic ciphers, and is used by the test runners of various Haskell
 881 implementations of cryptographic ciphers.")
 882     (license license:bsd-3)))
 883
 884 (define-public ghc-hedgehog
 885   (package
 886     (name "ghc-hedgehog")
 887     (version "1.0.1")
 888     (source
 889      (origin
 890        (method url-fetch)
 891        (uri (string-append
 892              "mirror://hackage/package/hedgehog/hedgehog-"
 893              version
 894              ".tar.gz"))
 895        (sha256
 896         (base32
 897          "1qc7hkqbnsk3f5r26wc35r3qiy941nmcxhfqgcq9027kw4gs0bi0"))))
 898     (build-system haskell-build-system)
 899     (inputs
 900      `(("ghc-ansi-terminal" ,ghc-ansi-terminal)
 901        ("ghc-async" ,ghc-async)
 902        ("ghc-concurrent-output" ,ghc-concurrent-output)
 903        ("ghc-exceptions" ,ghc-exceptions)
 904        ("ghc-fail" ,ghc-fail)
 905        ("ghc-lifted-async" ,ghc-lifted-async)
 906        ("ghc-mmorph" ,ghc-mmorph)
 907        ("ghc-monad-control" ,ghc-monad-control)
 908        ("ghc-pretty-show" ,ghc-pretty-show)
 909        ("ghc-primitive" ,ghc-primitive)
 910        ("ghc-random" ,ghc-random)
 911        ("ghc-resourcet" ,ghc-resourcet)
 912        ("ghc-semigroups" ,ghc-semigroups)
 913        ("ghc-th-lift" ,ghc-th-lift)
 914        ("ghc-transformers-base" ,ghc-transformers-base)
 915        ("ghc-wl-pprint-annotated"
 916         ,ghc-wl-pprint-annotated)))
 917     (home-page "https://hedgehog.qa")
 918     (synopsis "Property-based testing in the spirt of QuickCheck")
 919     (description
 920      "Hedgehog is a property-based testing system, in the spirit of
 921 QuickCheck.  Hedgehog uses integrated shrinking, so shrinks obey the invariants
 922 of generated values by construction.
 923
 924 To get started quickly, see the examples:
 925 @uref{https://github.com/hedgehogqa/haskell-hedgehog/tree/master/hedgehog-example}")
 926     (license license:bsd-3)))
 927
 928 (define-public cabal-doctest
 929   (package
 930     (name "cabal-doctest")
 931     (version "1.0.8")
 932     (source
 933      (origin
 934        (method url-fetch)
 935        (uri (string-append "https://hackage.haskell.org/package/"
 936                            "cabal-doctest/cabal-doctest-"
 937                            version ".tar.gz"))
 938        (sha256
 939         (base32
 940          "03if74imlhhk7m56nci5f1wclniwqdmwl4hl177040j1gnlac9i0"))))
 941     (build-system haskell-build-system)
 942     (home-page "https://github.com/phadej/cabal-doctest")
 943     (synopsis "Setup.hs helper for running doctests")
 944     (description
 945      "To properly work, the @code{doctest} package needs plenty of
 946 configuration.  This library provides the common bits for writing custom
 947 @file{Setup.hs} files.")
 948     (license license:bsd-3)))
 949
 950 (define-public ghc-testing-type-modifiers
 951   (package
 952     (name "ghc-testing-type-modifiers")
 953     (version "0.1.0.1")
 954     (source
 955       (origin
 956         (method url-fetch)
 957         (uri (string-append "https://hackage.haskell.org/package/"
 958                             "testing-type-modifiers/testing-type-modifiers-"
 959                             version ".tar.gz"))
 960         (sha256
 961           (base32
 962             "1wh2n95n39ivv6kbqn42vbzrj8zagsmk6f2al2qj40bg5kgdl2q5"))))
 963     (build-system haskell-build-system)
 964     (home-page "https://hackage.haskell.org/package/testing-type-modifiers")
 965     (synopsis "Data type modifiers for property based testing")
 966     (description "Property based testing libraries such as QuickCheck tend to
 967 include type modifiers.  Most of them are used to quantify over subsets of a
 968 type.  This library is intended to supply these modifiers to be used by
 969 testing libraries, in an effort to make properties more portable between
 970 testing frameworks.")
 971     (license license:unlicense)))
 972
 973 (define-public ghc-testing-feat
 974   (package
 975     (name "ghc-testing-feat")
 976     (version "1.1.0.0")
 977     (source
 978       (origin
 979         (method url-fetch)
 980         (uri (string-append "https://hackage.haskell.org/package/"
 981                             "testing-feat/testing-feat-" version ".tar.gz"))
 982         (sha256
 983           (base32
 984             "1v2qzzpf1s008g7q6q67glf7vbm1pkpq4rc3ii74f4g6vhfx610r"))))
 985     (build-system haskell-build-system)
 986     (inputs
 987       `(("ghc-quickcheck" ,ghc-quickcheck)
 988         ("ghc-size-based" ,ghc-size-based)
 989         ("ghc-testing-type-modifiers" ,ghc-testing-type-modifiers)
 990         ("ghc-semigroups" ,ghc-semigroups)))
 991     (home-page "https://github.com/JonasDuregard/testing-feat")
 992     (synopsis "Functional Enumeration of Algebraic Types")
 993     (description "Feat (Functional Enumeration of Algebraic Types)
 994 provides enumerations as functions from natural numbers to
 995 values (similar to @code{toEnum} but for any algebraic data type).  This
 996 can be used for SmallCheck-style systematic testing, QuickCheck-style
 997 random testing, and hybrids of the two.")
 998     (license license:bsd-3)))
 999
1000 (define-public ghc-inspection-testing
1001   (package
1002     (name "ghc-inspection-testing")
1003     (version "0.4.2.2")
1004     (source
1005      (origin
1006        (method url-fetch)
1007        (uri (string-append
1008              "https://hackage.haskell.org/package/inspection-testing/"
1009              "inspection-testing-" version ".tar.gz"))
1010        (sha256
1011         (base32
1012          "1bppz99p6ix6hah8lbr9mapl2zxgmkg9i7h6hk8wq6zf54hwz3yp"))))
1013     (build-system haskell-build-system)
1014     (home-page
1015      "https://github.com/nomeata/inspection-testing")
1016     (synopsis "GHC plugin to do inspection testing")
1017     (description
1018      "Some carefully crafted libraries make promises to their users beyond
1019 functionality and performance.
1020
1021 Examples are: Fusion libraries promise intermediate data structures to be
1022 eliminated.  Generic programming libraries promise that the generic
1023 implementation is identical to the hand-written one.  Some libraries may
1024 promise allocation-free or branch-free code.
1025
1026 Conventionally, the modus operandi in all these cases is that the library
1027 author manually inspects the (intermediate or final) code produced by the
1028 compiler.  This is not only tedious, but makes it very likely that some change,
1029 either in the library itself or the surrounding eco-system, breaks the
1030 library's promised without anyone noticing.
1031
1032 This package provides a disciplined way of specifying such properties, and
1033 have them checked by the compiler.  This way, this checking can be part of the
1034 regular development cycle and regressions caught early.
1035
1036 See the documentation in \"Test.Inspection\" or the project webpage for more
1037 examples and more information.")
1038     (license license:expat)))
1039
1040 (define-public ghc-easytest
1041   (package
1042     (name "ghc-easytest")
1043     (version "0.2.1")
1044     (source
1045      (origin
1046        (method url-fetch)
1047        (uri (string-append
1048              "https://hackage.haskell.org/package/easytest/easytest-"
1049              version ".tar.gz"))
1050        (sha256
1051         (base32
1052          "0gdyawzlw6d15yz7ji599xjgfr0g7l1iq11ffr4aw3j6g3dc6m8i"))))
1053     (build-system haskell-build-system)
1054     (inputs
1055      `(("ghc-async" ,ghc-async)
1056        ("ghc-random" ,ghc-random)
1057        ("ghc-call-stack" ,ghc-call-stack)))
1058     (home-page "https://github.com/joelburget/easytest")
1059     (synopsis "Testing library for Haskell")
1060     (description "EasyTest is a testing toolkit, meant to replace most uses of
1061 QuickCheck, SmallCheck, HUnit, and frameworks like Tasty, etc.  Tests can be
1062 written with ordinary Haskell code, with control flow explicit and under
1063 programmer control.")
1064     (license license:expat)))