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