gnu/packages/haskell-check.scm

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