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, 2021 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 ;;; Copyright © 2021 John Kehayias <john.kehayias@protonmail.com>
  17 ;;;
  18 ;;; This file is part of GNU Guix.
  19 ;;;
  20 ;;; GNU Guix is free software; you can redistribute it and/or modify it
  21 ;;; under the terms of the GNU General Public License as published by
  22 ;;; the Free Software Foundation; either version 3 of the License, or (at
  23 ;;; your option) any later version.
  24 ;;;
  25 ;;; GNU Guix is distributed in the hope that it will be useful, but
  26 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
  27 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28 ;;; GNU General Public License for more details.
  29 ;;;
  30 ;;; You should have received a copy of the GNU General Public License
  31 ;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.
  32
  33 (define-module (gnu packages haskell-check)
  34   #:use-module (gnu packages)
  35   #:use-module (gnu packages haskell-crypto)
  36   #:use-module (gnu packages haskell-web)
  37   #:use-module (gnu packages haskell-xyz)
  38   #:use-module (guix build-system haskell)
  39   #:use-module (guix download)
  40   #:use-module ((guix licenses) #:prefix license:)
  41   #:use-module (guix packages)
  42   #:use-module (guix utils))
  43
  44 (define-public ghc-tasty-ant-xml
  45   (package
  46     (name "ghc-tasty-ant-xml")
  47     (version "1.1.8")
  48     (source
  49      (origin
  50        (method url-fetch)
  51        (uri (string-append
  52              "https://hackage.haskell.org/package/tasty-ant-xml/tasty-ant-xml-"
  53              version
  54              ".tar.gz"))
  55        (sha256
  56         (base32
  57          "0h9mllhw9cd0rn34xhj8grwmbny7z7hpd8qmp9lfcdj0s4qx9vx8"))))
  58     (build-system haskell-build-system)
  59     (inputs
  60      (list ghc-generic-deriving ghc-xml ghc-tagged 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.2")
  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          "0csgwn3vch0jnpqyyfnrfjq4z0dpl67imh5a7byll3hhlyidgjym"))))
  85     (build-system haskell-build-system)
  86     (inputs
  87      (list ghc-tasty ghc-smallcheck ghc-async ghc-tagged))
  88     (home-page "https://documentup.com/feuerbach/tasty")
  89     (synopsis "SmallCheck support for the Tasty test framework")
  90     (description "This package provides SmallCheck support for the Tasty
  91 Haskell test framework.")
  92     (license license:bsd-3)))
  93
  94 (define-public ghc-tasty-quickcheck
  95   (package
  96     (name "ghc-tasty-quickcheck")
  97     (version "0.10.1.2")
  98     (source
  99      (origin
 100        (method url-fetch)
 101        (uri (string-append
 102              "https://hackage.haskell.org/package/tasty-quickcheck/"
 103              "tasty-quickcheck-" version ".tar.gz"))
 104        (sha256
 105         (base32
 106          "0i1i78587znqzwps49milyr5n2k388ld2kr9ysz1vw8gcw51qq49"))))
 107     (build-system haskell-build-system)
 108     (inputs
 109      (list ghc-quickcheck
 110            ghc-tagged
 111            ghc-tasty
 112            ghc-random
 113            ghc-ansi-terminal
 114            ghc-tasty-hunit
 115            ghc-pcre-light))
 116     (home-page "http://documentup.com/feuerbach/tasty")
 117     (synopsis "QuickCheck support for the Tasty test framework")
 118     (description "This package provides QuickCheck support for the Tasty
 119 Haskell test framework.")
 120     (license license:expat)))
 121
 122 (define-public ghc-tasty-golden
 123   (package
 124     (name "ghc-tasty-golden")
 125     (version "2.3.4")
 126     (source
 127      (origin
 128        (method url-fetch)
 129        (uri (string-append
 130              "https://hackage.haskell.org/package/tasty-golden/tasty-golden-"
 131              version
 132              ".tar.gz"))
 133        (sha256
 134         (base32
 135          "1nskavqgfxx1cw7q6c0cmizlwj54rnlv93yhgssaa77gv1nbvwpn"))))
 136     (build-system haskell-build-system)
 137     (inputs
 138      (list ghc-async
 139            ghc-optparse-applicative
 140            ghc-tagged
 141            ghc-tasty
 142            ghc-temporary
 143            ghc-unix-compat))
 144     (native-inputs (list ghc-tasty-hunit))
 145     (home-page
 146      "https://github.com/feuerbach/tasty-golden")
 147     (synopsis "Golden tests support for tasty")
 148     (description
 149      "This package provides support for @code{golden testing}.  A @dfn{golden
 150 test} is an IO action that writes its result to a file.  To pass the test, this
 151 output file should be identical to the corresponding @code{golden} file, which
 152 contains the correct result for the test.")
 153     (license license:expat)))
 154
 155 (define-public ghc-tasty
 156   (package
 157     (name "ghc-tasty")
 158     (version "1.4.2")
 159     (source
 160      (origin
 161        (method url-fetch)
 162        (uri (string-append
 163              "https://hackage.haskell.org/package/tasty/tasty-"
 164              version
 165              ".tar.gz"))
 166        (sha256
 167         (base32
 168          "0574hbqzxzyv6vsk5kzbf04kz58y0iy8x9ydcj4b8fpncgmgy63g"))))
 169     (build-system haskell-build-system)
 170     (inputs
 171      (list ghc-tagged
 172            ghc-regex-tdfa
 173            ghc-optparse-applicative
 174            ghc-unbounded-delays
 175            ghc-async
 176            ghc-ansi-terminal
 177            ghc-clock-bootstrap
 178            ghc-wcwidth-bootstrap))
 179     (home-page "http://documentup.com/feuerbach/tasty")
 180     (synopsis "Modern and extensible testing framework")
 181     (description "Tasty is a modern testing framework for Haskell.  It lets
 182 you combine your unit tests, golden tests, QuickCheck/SmallCheck properties,
 183 and any other types of tests into a single test suite.")
 184     (license license:expat)))
 185
 186 (define-public ghc-tasty-hedgehog
 187   (package
 188     (name "ghc-tasty-hedgehog")
 189     (version "1.1.0.0")
 190     (source
 191      (origin
 192        (method url-fetch)
 193        (uri (string-append "https://hackage.haskell.org/package/"
 194                            "tasty-hedgehog/tasty-hedgehog-" version ".tar.gz"))
 195        (sha256
 196         (base32
 197          "0cy49z8n124xh2ra2482vfy5if1n6d9lbdjma2zg1mxfj0k0zyfb"))))
 198     (build-system haskell-build-system)
 199     (inputs
 200      (list ghc-tagged ghc-tasty ghc-hedgehog))
 201     (native-inputs
 202      (list ghc-tasty-expected-failure))
 203     (home-page "https://github.com/qfpl/tasty-hedgehog")
 204     (synopsis "Integration for tasty and hedgehog")
 205     (description "This package provides the means for integrating the
 206 @url{https://hackage.haskell.org/package/hedgehog, hedgehog testing library}
 207 with the @url{https://hackage.haskell.org/package/tasty, tasty testing
 208 framework}.")
 209     (license license:bsd-3)))
 210
 211 (define-public ghc-tasty-hspec
 212   (package
 213     (name "ghc-tasty-hspec")
 214     (version "1.1.6")
 215     (source
 216      (origin
 217        (method url-fetch)
 218        (uri (string-append
 219              "https://hackage.haskell.org/package/tasty-hspec/tasty-hspec-"
 220              version
 221              ".tar.gz"))
 222        (sha256
 223         (base32
 224          "02s82ijs2ringqxsqbm7m3vcy5brmwxa617azxv0v2phi3rdkjvl"))))
 225     (build-system haskell-build-system)
 226     (inputs
 227      (list ghc-hspec
 228            ghc-hspec-core
 229            ghc-quickcheck
 230            ghc-tagged
 231            ghc-tasty
 232            ghc-tasty-smallcheck
 233            ghc-tasty-quickcheck))
 234     (arguments
 235      `(#:cabal-revision
 236        ("1" "0za15rg0szacxq9yfxxjzddr77ai7ng5827a20pj9dr5anjlnajj")))
 237     (home-page
 238      "https://github.com/mitchellwrosen/tasty-hspec")
 239     (synopsis
 240      "Hspec support for the Tasty test framework")
 241     (description
 242      "This package provides a Tasty provider for Hspec test suites.")
 243     (license license:bsd-3)))
 244
 245 (define-public ghc-tasty-hunit
 246   (package
 247     (name "ghc-tasty-hunit")
 248     (version "0.10.0.3")
 249     (source
 250      (origin
 251        (method url-fetch)
 252        (uri (string-append
 253              "https://hackage.haskell.org/package/tasty-hunit/tasty-hunit-"
 254              version
 255              ".tar.gz"))
 256        (sha256
 257         (base32
 258          "0gz6zz3w7s44pymw33xcxnawryl27zk33766sab96nz2xh91kvxp"))))
 259     (build-system haskell-build-system)
 260     (inputs
 261      (list ghc-call-stack-boot ghc-tasty))
 262     (home-page "http://documentup.com/feuerbach/tasty")
 263     (synopsis "HUnit support for the Tasty test framework")
 264     (description "This package provides HUnit support for the Tasty Haskell
 265 test framework.")
 266     (license license:expat)))
 267
 268 (define-public ghc-tasty-kat
 269   (package
 270     (name "ghc-tasty-kat")
 271     (version "0.0.3")
 272     (source (origin
 273               (method url-fetch)
 274               (uri (string-append "https://hackage.haskell.org/package/"
 275                                   "tasty-kat/tasty-kat-" version ".tar.gz"))
 276               (sha256
 277                (base32
 278                 "14yvlpli6cv6bn3kh8mlfp4x1l6ns4fvmfv6hmj75cvxyzq029d7"))))
 279     (build-system haskell-build-system)
 280     (inputs
 281      (list ghc-tasty ghc-tasty-quickcheck ghc-tasty-hunit))
 282     (home-page "https://github.com/vincenthz/tasty-kat")
 283     (synopsis "Known Answer Tests (KAT) framework for tasty")
 284     (description
 285      "This package provides a @dfn{Known Answer Tests} (KAT) framework for
 286 tasty.")
 287     (license license:expat)))
 288
 289 (define-public ghc-tasty-lua
 290   (package
 291     (name "ghc-tasty-lua")
 292     (version "0.2.3.2")
 293     (source
 294      (origin
 295        (method url-fetch)
 296        (uri (string-append "https://hackage.haskell.org/package/"
 297                            "tasty-lua/tasty-lua-" version ".tar.gz"))
 298        (sha256
 299         (base32
 300          "0wa73ihkjcxi50lgpdzwwdx7s903lqi79hw7hxlvhbcvdly1cq53"))))
 301     (build-system haskell-build-system)
 302     (inputs
 303      (list ghc-file-embed ghc-hslua ghc-tasty))
 304     (native-inputs
 305      (list ghc-tasty-hunit))
 306     (home-page "https://github.com/hslua/tasty-lua")
 307     (synopsis "Write tests in Lua, integrate into tasty")
 308     (description "This package gives users the ability to define tasty tests
 309 from Lua.")
 310     (license license:expat)))
 311
 312 (define-public ghc-tasty-th
 313   (package
 314     (name "ghc-tasty-th")
 315     (version "0.1.7")
 316     (source
 317      (origin
 318        (method url-fetch)
 319        (uri (string-append
 320              "https://hackage.haskell.org/package/tasty-th/tasty-th-"
 321              version ".tar.gz"))
 322        (sha256
 323         (base32
 324          "0b2ivrw2257m4cy4rjnkwqlarh83j1y3zywnmaqqqbvy667sqnj3"))))
 325     (build-system haskell-build-system)
 326     (inputs
 327      (list ghc-haskell-src-exts ghc-tasty ghc-tasty-hunit))
 328     (home-page "https://github.com/bennofs/tasty-th")
 329     (synopsis "Automatically generate tasty TestTrees")
 330     (description
 331       "Tasty-th automatically generates tasty TestTrees from functions of the
 332 current module, using TemplateHaskell.  This is a fork the original
 333 test-framework-th package, modified to work with tasty instead of
 334 test-framework.")
 335     (license license:bsd-3)))
 336
 337 (define-public ghc-tasty-rerun
 338   (package
 339     (name "ghc-tasty-rerun")
 340     (version "1.1.18")
 341     (source (origin
 342               (method url-fetch)
 343               (uri (string-append
 344                     "https://hackage.haskell.org/package/tasty-rerun/"
 345                     "tasty-rerun-" version ".tar.gz"))
 346               (sha256
 347                (base32
 348                 "0sccp5zx9v2rx741nbmgd8mzjhy5m4v74hk26d23xz93ph8aqx7s"))))
 349     (build-system haskell-build-system)
 350     (inputs
 351      (list ghc-optparse-applicative ghc-reducers ghc-split ghc-tagged
 352            ghc-tasty))
 353     (home-page "https://github.com/ocharles/tasty-rerun")
 354     (synopsis "Run tests by filtering the test tree")
 355     (description "This package adds the ability to run tests by filtering the
 356 test tree based on the result of a previous test run.  You can use this to run
 357 only those tests that failed in the last run, or to only run the tests that have
 358 been added since previous test run.")
 359   (license license:bsd-3)))
 360
 361 (define-public ghc-tasty-expected-failure
 362   (package
 363     (name "ghc-tasty-expected-failure")
 364     (version "0.12.3")
 365     (source
 366      (origin
 367        (method url-fetch)
 368        (uri (string-append "https://hackage.haskell.org/package/"
 369                            "tasty-expected-failure/tasty-expected-failure-"
 370                            version ".tar.gz"))
 371        (sha256
 372         (base32
 373          "0zlgxs24d54byfhvwdg85xk1572zpjs71bjlxxrxcvralrfcq1yb"))))
 374     (build-system haskell-build-system)
 375     (arguments `(#:tests? #f)) ; TODO: Loops.
 376 ;    (native-inputs
 377 ;     `(("ghc-tasty-hunit" ,ghc-tasty-hunit)
 378 ;       ("ghc-tasty-golden" ,ghc-tasty-golden)
 379 ;       ("ghc-hedgehog" ,ghc-hedgehog)
 380 ;       ("ghc-tasty-hedgehog" ,ghc-tasty-hedgehog)))
 381     (inputs
 382      (list ghc-tagged ghc-tasty ghc-unbounded-delays))
 383     (home-page "https://github.com/nomeata/tasty-expected-failure")
 384     (synopsis "Mark tasty tests as failure expected")
 385     (description
 386      "With the function @code{Test.Tasty.ExpectedFailure.expectFail} in the
 387 provided module @code{Test.Tasty.ExpectedFailure}, you can mark that you
 388 expect test cases to fail, and not to pass. This can be used for test-driven
 389 development.")
 390     (license license:expat)))
 391
 392 (define-public ghc-quickcheck-instances
 393   (package
 394     (name "ghc-quickcheck-instances")
 395     (version "0.3.25.2")
 396     (source
 397      (origin
 398        (method url-fetch)
 399        (uri (string-append
 400              "https://hackage.haskell.org/package/"
 401              "quickcheck-instances/quickcheck-instances-"
 402              version ".tar.gz"))
 403        (sha256
 404         (base32
 405          "0ihqbarl2ddrfgq3mq09lswwn8213qpw13g49qxs5mjkcm6gbk3h"))))
 406     (build-system haskell-build-system)
 407     (arguments
 408      `(#:cabal-revision
 409        ("2" "1lsa3pbg4ljlk29fhm3mdklnx3hwffyga1nr5krbpcyc3ywq8fq8")))
 410     (inputs
 411      (list ghc-case-insensitive
 412            ghc-data-fix
 413            ghc-hashable
 414            ghc-integer-logarithms
 415            ghc-old-time
 416            ghc-quickcheck
 417            ghc-scientific
 418            ghc-splitmix
 419            ghc-strict
 420            ghc-tagged
 421            ghc-these
 422            ghc-time-compat
 423            ghc-transformers-compat
 424            ghc-unordered-containers
 425            ghc-uuid-types
 426            ghc-vector))
 427     (home-page "https://github.com/aslatter/qc-instances")
 428     (synopsis "Common quickcheck instances")
 429     (description "This package provides QuickCheck instances for types
 430 provided by the Haskell Platform.")
 431     (license license:bsd-3)))
 432
 433 (define-public ghc-quickcheck-unicode
 434   (package
 435     (name "ghc-quickcheck-unicode")
 436     (version "1.0.1.0")
 437     (source
 438      (origin
 439        (method url-fetch)
 440        (uri (string-append
 441              "https://hackage.haskell.org/package/quickcheck-unicode/"
 442              "quickcheck-unicode-" version ".tar.gz"))
 443        (sha256
 444         (base32
 445          "0s43s1bzbg3gwsjgm7fpyksd1339f0m26dlw2famxwyzgvm0a80k"))))
 446     (build-system haskell-build-system)
 447     (inputs (list ghc-quickcheck))
 448     (home-page
 449      "https://github.com/bos/quickcheck-unicode")
 450     (synopsis "Generator functions Unicode-related tests")
 451     (description "This package provides generator and shrink functions for
 452 testing Unicode-related software.")
 453     (license license:bsd-3)))
 454
 455 (define-public ghc-quickcheck-io
 456   (package
 457     (name "ghc-quickcheck-io")
 458     (version "0.2.0")
 459     (source
 460      (origin
 461        (method url-fetch)
 462        (uri (string-append
 463              "https://hackage.haskell.org/package/quickcheck-io/quickcheck-io-"
 464              version
 465              ".tar.gz"))
 466        (sha256
 467         (base32
 468          "08k4v7pkgjf30pv5j2dfv1gqv6hclxlniyq2sps8zq4zswcr2xzv"))))
 469     (build-system haskell-build-system)
 470     (inputs
 471      (list ghc-quickcheck ghc-hunit))
 472     (home-page
 473      "https://github.com/hspec/quickcheck-io#readme")
 474     (synopsis "Use HUnit assertions as QuickCheck properties")
 475     (description "This package provides an orphan instance that allows you to
 476 use HUnit assertions as QuickCheck properties.")
 477     (license license:expat)))
 478
 479 (define-public ghc-quickcheck
 480   (package
 481     (name "ghc-quickcheck")
 482     (version "2.14.2")
 483     (source
 484      (origin
 485        (method url-fetch)
 486        (uri (string-append
 487              "https://hackage.haskell.org/package/QuickCheck/QuickCheck-"
 488              version
 489              ".tar.gz"))
 490        (sha256
 491         (base32
 492          "1wrnrm9sq4s0bly0q58y80g4153q45iglqa34xsi2q3bd62nqyyq"))))
 493     (build-system haskell-build-system)
 494     (inputs
 495      (list ghc-random ghc-splitmix-bootstrap))
 496     (home-page "https://github.com/nick8325/quickcheck")
 497     (synopsis "Automatic testing of Haskell programs")
 498     (description
 499      "QuickCheck is a library for random testing of program properties.  The
 500 programmer provides a specification of the program, in the form of properties
 501 which functions should satisfy, and QuickCheck then tests that the properties
 502 hold in a large number of randomly generated cases.  Specifications are
 503 expressed in Haskell, using combinators defined in the QuickCheck library.")
 504     (license license:bsd-3)))
 505
 506 (define-public ghc-quickcheck-assertions
 507   (package
 508     (name "ghc-quickcheck-assertions")
 509     (version "0.3.0")
 510     (source
 511      (origin
 512        (method url-fetch)
 513        (uri (string-append "https://hackage.haskell.org/package/"
 514                            "quickcheck-assertions/"
 515                            "quickcheck-assertions-" version ".tar.gz"))
 516        (sha256
 517         (base32 "1kyam4cy7qmnizjwjm8jamq43w7f0fs6ljfplwj0ib6wi2kjh0wv"))))
 518     (build-system haskell-build-system)
 519     (native-inputs
 520      (list ghc-hspec))
 521     (inputs
 522      (list ghc-ieee754 ghc-pretty-show ghc-quickcheck))
 523     (home-page "https://github.com/s9gf4ult/quickcheck-assertions")
 524     (synopsis "HUnit-like assertions for QuickCheck")
 525     (description
 526      "This Haskell library provides convenient assertions with pretty-printed
 527 failure messages for QuickCheck properties, that are similar to those of
 528 HUnit.")
 529     (license license:lgpl3)))
 530
 531 (define-public ghc-test-framework
 532   (package
 533     (name "ghc-test-framework")
 534     (version "0.8.2.0")
 535     (source
 536      (origin
 537        (method url-fetch)
 538        (uri (string-append "https://hackage.haskell.org/package/test-framework/"
 539                            "test-framework-" version ".tar.gz"))
 540        (sha256
 541         (base32
 542          "1hhacrzam6b8f10hyldmjw8pb7frdxh04rfg3farxcxwbnhwgbpm"))))
 543     (build-system haskell-build-system)
 544     (arguments
 545      `(#:tests? #f  ; FIXME: Tests do not build.
 546        #:cabal-revision
 547        ("6" "0wbq9wiaag69nsqxwijzhs5y1hb9kbpkp1x65dvx158cxp8i9w9r")))
 548     (native-inputs
 549      (list ghc-hunit ghc-quickcheck))
 550     (inputs
 551      `(("ghc-ansi-terminal" ,ghc-ansi-terminal)
 552        ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
 553        ("ghc-hostname" ,ghc-hostname)
 554        ("ghc-old-locale" ,ghc-old-locale)
 555        ("ghc-random" ,ghc-random)
 556        ("ghc-regex-posix" ,ghc-regex-posix)
 557        ("ghc-xml" ,ghc-xml)
 558        ("ghc-libxml" ,ghc-libxml)
 559        ("ghc-semigroups" ,ghc-semigroups-bootstrap)))
 560     (home-page "https://batterseapower.github.io/test-framework/")
 561     (synopsis "Framework for running and organising tests")
 562     (description
 563      "This package allows tests such as QuickCheck properties and HUnit test
 564 cases to be assembled into test groups, run in parallel (but reported in
 565 deterministic order, to aid diff interpretation) and filtered and controlled
 566 by command line options.  All of this comes with colored test output, progress
 567 reporting and test statistics output.")
 568     (license license:bsd-3)))
 569
 570 (define-public ghc-test-framework-hunit
 571   (package
 572     (name "ghc-test-framework-hunit")
 573     (version "0.3.0.2")
 574     (source
 575      (origin
 576        (method url-fetch)
 577        (uri (string-append "https://hackage.haskell.org/package/"
 578                            "test-framework-hunit/test-framework-hunit-"
 579                            version ".tar.gz"))
 580        (sha256
 581         (base32
 582          "1y0b6vg8nfm43v90lxxcydhi6qlxhfy4vpxbzm5ic2w55bh8xjwm"))))
 583     (build-system haskell-build-system)
 584     (arguments
 585      `(#:cabal-revision
 586        ("3" "0i9mlalv7cl1iq43ld5myrnpszq5rxmd79hk495dcb08rglhgl3z")))
 587     (inputs
 588      (list ghc-extensible-exceptions ghc-hunit ghc-test-framework))
 589     (home-page "https://batterseapower.github.io/test-framework/")
 590     (synopsis "HUnit support for test-framework")
 591     (description
 592      "This package provides HUnit support for the test-framework package.")
 593     (license license:bsd-3)))
 594
 595 (define-public ghc-test-framework-quickcheck2
 596   (package
 597     (name "ghc-test-framework-quickcheck2")
 598     (version "0.3.0.5")
 599     (source
 600      (origin
 601        (method url-fetch)
 602        (uri (string-append "https://hackage.haskell.org/package/"
 603                            "test-framework-quickcheck2/"
 604                            "test-framework-quickcheck2-" version ".tar.gz"))
 605        (sha256
 606         (base32
 607          "0ngf9vvby4nrdf1i7dxf5m9jn0g2pkq32w48xdr92n9hxka7ixn9"))))
 608     (build-system haskell-build-system)
 609     (arguments
 610      `(#:cabal-revision
 611        ("3" "0mglqfimla4vvv80mg08aj76zf4993wmngqlirh05h8i9nmgv6lh")))
 612     (inputs
 613      (list ghc-extensible-exceptions ghc-quickcheck ghc-random
 614            ghc-test-framework))
 615     (home-page "https://batterseapower.github.io/test-framework/")
 616     (synopsis "QuickCheck2 support for test-framework")
 617     (description
 618      "This package provides QuickCheck2 support for the test-framework
 619 package.")
 620     (license license:bsd-3)))
 621
 622 (define-public ghc-test-framework-smallcheck
 623   (package
 624     (name "ghc-test-framework-smallcheck")
 625     (version "0.2")
 626     (source
 627      (origin
 628        (method url-fetch)
 629        (uri (string-append "https://hackage.haskell.org/package/"
 630                            "test-framework-smallcheck/"
 631                            "test-framework-smallcheck-" version ".tar.gz"))
 632        (sha256
 633         (base32 "1xpgpk1gp4w7w46b4rhj80fa0bcyz8asj2dcjb5x1c37b7rw90b0"))))
 634     (build-system haskell-build-system)
 635     (inputs
 636      (list ghc-smallcheck ghc-test-framework))
 637     (home-page "https://github.com/Bodigrim/smallcheck")
 638     (synopsis "SmallCheck support for test-framework")
 639     (description
 640      "This package lets programmers use SmallCheck properties in Haskell's
 641 test-framework.  New projects should use ghc-tasty-smallcheck instead.")
 642     (license license:bsd-3)))
 643
 644 (define-public ghc-test-framework-th
 645   (package
 646     (name "ghc-test-framework-th")
 647     (version "0.2.4")
 648     (source
 649      (origin
 650        (method url-fetch)
 651        (uri (string-append "https://hackage.haskell.org/package/"
 652                            "test-framework-th-" version "/"
 653                            "test-framework-th-" version ".tar.gz"))
 654        (sha256
 655         (base32
 656          "12lw7yj02jb9s0i7rb98jjam43j2h0gzmnbj9zi933fx7sg0sy4b"))))
 657     (build-system haskell-build-system)
 658     (inputs
 659      (list ghc-test-framework ghc-language-haskell-extract
 660            ghc-haskell-src-exts ghc-regex-posix))
 661     (home-page "https://github.com/finnsson/test-generator")
 662     (synopsis "Auto generate the HUnit- and Quickcheck-bulk-code
 663 using Template Haskell")
 664     (description "This library contains two functions:
 665 @code{defaultMainGenerator} and @code{testGroupGenerator}.
 666
 667 @code{defaultMainGenerator} will extract all functions beginning with
 668 @code{case_}, @code{prop_}, or @code{test_} in the module and put them in a
 669 @code{testGroup}.
 670
 671 @code{testGroupGenerator} is like @code{defaultMainGenerator} but without
 672 @code{defaultMain}.  It is useful if you need a function for the testgroup
 673 \(e.g. if you want to be able to call the testgroup from another module).")
 674     (license license:bsd-3)))
 675
 676 (define-public ghc-hunit
 677   (package
 678     (name "ghc-hunit")
 679     (version "1.6.2.0")
 680     (outputs '("out" "static" "doc"))
 681     (source
 682      (origin
 683        (method url-fetch)
 684        (uri (string-append "https://hackage.haskell.org/package/HUnit/"
 685                            "HUnit-" version ".tar.gz"))
 686        (sha256
 687         (base32
 688          "1as4sw5y39c3zrmr6sb8zbw74c9gdn4401y0dx45ih7zf6457dxh"))))
 689     (build-system haskell-build-system)
 690     (inputs
 691      ;; We cannot use ghc-call-stack there, because it depends on
 692      ;; ghc-nanospec, which depends on ghc-hunit.
 693      (list ghc-call-stack-boot))
 694     (home-page "http://hunit.sourceforge.net/")
 695     (synopsis "Unit testing framework for Haskell")
 696     (description
 697      "HUnit is a unit testing framework for Haskell, inspired by the
 698 JUnit tool for Java.")
 699     (license license:bsd-3)))
 700
 701 (define-public hspec-discover
 702   (package
 703     (name "hspec-discover")
 704     (version "2.7.10")
 705     (source
 706      (origin
 707        (method url-fetch)
 708        (uri (string-append "https://hackage.haskell.org/package/"
 709                            "hspec-discover/hspec-discover-"
 710                            version ".tar.gz"))
 711        (sha256
 712         (base32
 713          "13yzvd3b679skvs1insk4s0wc4zvmz6hs38kc8q0j6vzqq06smqa"))))
 714     (build-system haskell-build-system)
 715     (native-inputs
 716      (list ghc-quickcheck ghc-hspec-meta))
 717     (home-page "https://hspec.github.io/")
 718     (synopsis "Automatically discover and run Hspec tests")
 719     (description "hspec-discover is a tool which automatically discovers and
 720 runs Hspec tests.")
 721     (license license:expat)))
 722
 723 (define-public ghc-hspec-core
 724   (package
 725     (name "ghc-hspec-core")
 726     (version "2.7.10")
 727     (source
 728      (origin
 729        (method url-fetch)
 730        (uri (string-append "https://hackage.haskell.org/package/hspec-core/"
 731                            "hspec-core-" version ".tar.gz"))
 732        (sha256
 733         (base32
 734          "12k9yp5gznrda449ir60d5wv3xl7nnyffkb5mhfc0svw9f8lxlv1"))))
 735     (build-system haskell-build-system)
 736     (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
 737     (inputs
 738      (list ghc-setenv
 739            ghc-ansi-terminal
 740            ghc-clock
 741            ghc-quickcheck-io
 742            ghc-hunit
 743            ghc-quickcheck
 744            ghc-hspec-expectations
 745            ghc-silently
 746            ghc-tf-random))
 747     (home-page "https://hspec.github.io/")
 748     (synopsis "Testing framework for Haskell")
 749     (description "This library exposes internal types and functions that can
 750 be used to extend Hspec's functionality.")
 751     (license license:expat)))
 752
 753 (define-public ghc-hspec-meta
 754   (package
 755     (name "ghc-hspec-meta")
 756     (version "2.7.8")
 757     (source
 758      (origin
 759        (method url-fetch)
 760        (uri (string-append "https://hackage.haskell.org/package/hspec-meta/"
 761                            "hspec-meta-" version ".tar.gz"))
 762        (sha256
 763         (base32
 764          "0sfj0n2hy1r8ifysgbcmfdygcd7vyzr13ldkcp0l2ml337f8j0si"))))
 765     (build-system haskell-build-system)
 766     (inputs
 767      (list ghc-quickcheck
 768            ghc-hunit
 769            ghc-ansi-terminal
 770            ghc-clock
 771            ghc-hspec-expectations
 772            ghc-setenv
 773            ghc-random
 774            ghc-quickcheck-io))
 775     (home-page "https://hspec.github.io/")
 776     (synopsis "Version of Hspec to test Hspec itself")
 777     (description "This library provides a stable version of Hspec which is
 778 used to test the in-development version of Hspec.")
 779     (license license:expat)))
 780
 781 (define-public ghc-hspec
 782   (package
 783     (name "ghc-hspec")
 784     (version "2.7.10")
 785     (source
 786      (origin
 787        (method url-fetch)
 788        (uri (string-append "https://hackage.haskell.org/package/hspec/"
 789                            "hspec-" version ".tar.gz"))
 790        (sha256
 791         (base32
 792          "0z0lwrmrqkglr78n6k2c36n4h68142bh785ys0x4jaibjshvs6rw"))))
 793     (build-system haskell-build-system)
 794     (outputs '("out" "static" "doc"))
 795     (inputs
 796      (list ghc-hspec-core
 797            hspec-discover
 798            ghc-hspec-expectations
 799            ghc-quickcheck
 800            ghc-hunit
 801            ghc-stringbuilder
 802            ghc-hspec-meta))
 803     (home-page "https://hspec.github.io/")
 804     (synopsis "Testing Framework for Haskell")
 805     (description "This library provides the Hspec testing framework for
 806 Haskell, inspired by the Ruby library RSpec.")
 807     (license license:expat)))
 808
 809 (define-public ghc-hspec-contrib
 810   (package
 811     (name "ghc-hspec-contrib")
 812     (version "0.5.1")
 813     (source (origin
 814               (method url-fetch)
 815               (uri (string-append "https://hackage.haskell.org/package/"
 816                                   "hspec-contrib/hspec-contrib-"
 817                                   version ".tar.gz"))
 818               (sha256
 819                (base32
 820                 "0hhzxaa3fxz5mk5qcsrnfr98a7bn3szx2ydgr0x9mbqmm1jg06rc"))))
 821     (build-system haskell-build-system)
 822     (inputs
 823      (list ghc-hspec-core ghc-hunit ghc-hspec ghc-quickcheck))
 824     (native-inputs
 825      (list hspec-discover))
 826     (home-page "https://hspec.github.io/")
 827     (synopsis "Contributed functionality for Hspec")
 828     (description
 829      "This package provides contributed Hspec extensions.")
 830     (license license:expat)))
 831
 832 (define-public ghc-hspec-expectations
 833   (package
 834     (name "ghc-hspec-expectations")
 835     (version "0.8.2")
 836     (source
 837      (origin
 838        (method url-fetch)
 839        (uri (string-append "https://hackage.haskell.org/package/"
 840                            "hspec-expectations/hspec-expectations-"
 841                            version ".tar.gz"))
 842        (sha256
 843         (base32
 844          "1vxl9zazbaapijr6zmcj72j9wf7ka1pirrjbwddwwddg3zm0g5l1"))))
 845     (build-system haskell-build-system)
 846     ;; Tests depend on ghc-nanospec.
 847     (arguments '(#:tests? #f))
 848     (inputs (list ghc-hunit))
 849     (home-page "https://github.com/sol/hspec-expectations")
 850     (synopsis "Catchy combinators for HUnit")
 851     (description "This library provides catchy combinators for HUnit, see
 852 @uref{https://github.com/sol/hspec-expectations#readme, the README}.")
 853     (license license:expat)))
 854
 855 (define-public ghc-nanospec
 856   (package
 857     (name "ghc-nanospec")
 858     (version "0.2.2")
 859     (source
 860      (origin
 861        (method url-fetch)
 862        (uri (string-append "https://hackage.haskell.org/package/"
 863                            "nanospec/nanospec-"
 864                            version ".tar.gz"))
 865        (sha256
 866         (base32
 867          "1rcmhl9bhyfvanalnf1r86wkx6rq6wdvagnw1h011jcnnb1cq56g"))))
 868     (build-system haskell-build-system)
 869     (inputs
 870      (list ghc-hspec ghc-silently))
 871     (home-page "https://github.com/hspec/nanospec#readme")
 872     (synopsis "Lightweight implementation of a subset of Hspec's API")
 873     (description
 874      "Nanospec is a lightweight implementation of a subset of Hspec's API with
 875 minimal dependencies.")
 876     (license license:expat)))
 877
 878 (define-public ghc-crypto-cipher-tests
 879   (package
 880     (name "ghc-crypto-cipher-tests")
 881     (version "0.0.11")
 882     (source
 883      (origin
 884        (method url-fetch)
 885        (uri (string-append "https://hackage.haskell.org/package/"
 886                            "crypto-cipher-tests-" version "/"
 887                            "crypto-cipher-tests-" version ".tar.gz"))
 888        (sha256
 889         (base32
 890          "19wqignlq90qwpam01hnmmrxaxh5lkax9l1l6rlbi4a07nvp1dnz"))))
 891     (build-system haskell-build-system)
 892     (inputs (list ghc-quickcheck
 893                   ghc-hunit
 894                   ghc-test-framework
 895                   ghc-test-framework-quickcheck2
 896                   ghc-test-framework-hunit
 897                   ghc-byteable
 898                   ghc-securemem
 899                   ghc-crypto-cipher-types))
 900     (home-page "https://github.com/vincenthz/hs-crypto-cipher")
 901     (synopsis "Generic cryptography cipher tests for Haskell")
 902     (description " This Haskell package contains generic tests for
 903 cryptographic ciphers, and is used by the test runners of various Haskell
 904 implementations of cryptographic ciphers.")
 905     (license license:bsd-3)))
 906
 907 (define-public ghc-hedgehog
 908   (package
 909     (name "ghc-hedgehog")
 910     (version "1.0.5")
 911     (source
 912      (origin
 913        (method url-fetch)
 914        (uri (string-append
 915              "https://hackage.haskell.org/package/hedgehog/hedgehog-"
 916              version
 917              ".tar.gz"))
 918        (sha256
 919         (base32
 920          "1qsqs8lmxa3wmw228cwi98vvvh9hqbc9d43i1sy2c9igw9xlhfi6"))))
 921     (build-system haskell-build-system)
 922     (inputs
 923      (list ghc-ansi-terminal
 924            ghc-async
 925            ghc-concurrent-output
 926            ghc-erf
 927            ;("ghc-exceptions" ,ghc-exceptions)
 928            ghc-lifted-async
 929            ghc-mmorph
 930            ghc-monad-control
 931            ghc-pretty-show
 932            ghc-primitive
 933            ghc-random
 934            ghc-resourcet
 935            ghc-transformers-base
 936            ghc-wl-pprint-annotated))
 937     (home-page "https://hedgehog.qa")
 938     (synopsis "Property-based testing in the spirt of QuickCheck")
 939     (description
 940      "Hedgehog is a property-based testing system, in the spirit of
 941 QuickCheck.  Hedgehog uses integrated shrinking, so shrinks obey the invariants
 942 of generated values by construction.
 943
 944 To get started quickly, see the examples:
 945 @uref{https://github.com/hedgehogqa/haskell-hedgehog/tree/master/hedgehog-example}")
 946     (license license:bsd-3)))
 947
 948 (define-public cabal-doctest
 949   (package
 950     (name "cabal-doctest")
 951     (version "1.0.8")
 952     (source
 953      (origin
 954        (method url-fetch)
 955        (uri (string-append "https://hackage.haskell.org/package/"
 956                            "cabal-doctest/cabal-doctest-"
 957                            version ".tar.gz"))
 958        (sha256
 959         (base32
 960          "03if74imlhhk7m56nci5f1wclniwqdmwl4hl177040j1gnlac9i0"))))
 961     (build-system haskell-build-system)
 962     (arguments
 963      `(#:cabal-revision
 964        ("2" "05v1awad3d1wvc763xcgvxm4n6n7bs7byc6s14kdbw35zcaddlcb")))
 965     (home-page "https://github.com/phadej/cabal-doctest")
 966     (synopsis "Setup.hs helper for running doctests")
 967     (description
 968      "To properly work, the @code{doctest} package needs plenty of
 969 configuration.  This library provides the common bits for writing custom
 970 @file{Setup.hs} files.")
 971     (license license:bsd-3)))
 972
 973 (define-public ghc-testing-type-modifiers
 974   (package
 975     (name "ghc-testing-type-modifiers")
 976     (version "0.1.0.1")
 977     (source
 978       (origin
 979         (method url-fetch)
 980         (uri (string-append "https://hackage.haskell.org/package/"
 981                             "testing-type-modifiers/testing-type-modifiers-"
 982                             version ".tar.gz"))
 983         (sha256
 984           (base32
 985             "1wh2n95n39ivv6kbqn42vbzrj8zagsmk6f2al2qj40bg5kgdl2q5"))))
 986     (build-system haskell-build-system)
 987     (home-page "https://hackage.haskell.org/package/testing-type-modifiers")
 988     (synopsis "Data type modifiers for property based testing")
 989     (description "Property based testing libraries such as QuickCheck tend to
 990 include type modifiers.  Most of them are used to quantify over subsets of a
 991 type.  This library is intended to supply these modifiers to be used by
 992 testing libraries, in an effort to make properties more portable between
 993 testing frameworks.")
 994     (license license:unlicense)))
 995
 996 (define-public ghc-testing-feat
 997   (package
 998     (name "ghc-testing-feat")
 999     (version "1.1.0.0")
1000     (source
1001       (origin
1002         (method url-fetch)
1003         (uri (string-append "https://hackage.haskell.org/package/"
1004                             "testing-feat/testing-feat-" version ".tar.gz"))
1005         (sha256
1006           (base32
1007             "1v2qzzpf1s008g7q6q67glf7vbm1pkpq4rc3ii74f4g6vhfx610r"))))
1008     (build-system haskell-build-system)
1009     (inputs
1010       (list ghc-quickcheck ghc-size-based ghc-testing-type-modifiers
1011             ghc-semigroups))
1012     (home-page "https://github.com/JonasDuregard/testing-feat")
1013     (synopsis "Functional Enumeration of Algebraic Types")
1014     (description "Feat (Functional Enumeration of Algebraic Types)
1015 provides enumerations as functions from natural numbers to
1016 values (similar to @code{toEnum} but for any algebraic data type).  This
1017 can be used for SmallCheck-style systematic testing, QuickCheck-style
1018 random testing, and hybrids of the two.")
1019     (license license:bsd-3)))
1020
1021 (define-public ghc-inspection-testing
1022   (package
1023     (name "ghc-inspection-testing")
1024     (version "0.4.6.0")
1025     (source
1026      (origin
1027        (method url-fetch)
1028        (uri (string-append
1029              "https://hackage.haskell.org/package/inspection-testing/"
1030              "inspection-testing-" version ".tar.gz"))
1031        (sha256
1032         (base32
1033          "0qz1npyycj4bvyly9xmjbnhw569l52h38gx02rk0r7zhapw83aig"))))
1034     (build-system haskell-build-system)
1035     (home-page
1036      "https://github.com/nomeata/inspection-testing")
1037     (synopsis "GHC plugin to do inspection testing")
1038     (description
1039      "Some carefully crafted libraries make promises to their users beyond
1040 functionality and performance.
1041
1042 Examples are: Fusion libraries promise intermediate data structures to be
1043 eliminated.  Generic programming libraries promise that the generic
1044 implementation is identical to the hand-written one.  Some libraries may
1045 promise allocation-free or branch-free code.
1046
1047 Conventionally, the modus operandi in all these cases is that the library
1048 author manually inspects the (intermediate or final) code produced by the
1049 compiler.  This is not only tedious, but makes it very likely that some change,
1050 either in the library itself or the surrounding eco-system, breaks the
1051 library's promised without anyone noticing.
1052
1053 This package provides a disciplined way of specifying such properties, and
1054 have them checked by the compiler.  This way, this checking can be part of the
1055 regular development cycle and regressions caught early.
1056
1057 See the documentation in \"Test.Inspection\" or the project webpage for more
1058 examples and more information.")
1059     (license license:expat)))
1060
1061 (define-public ghc-quickcheck-classes
1062   (package
1063     (name "ghc-quickcheck-classes")
1064     (version "0.6.5.0")
1065     (source
1066       (origin
1067         (method url-fetch)
1068         (uri (string-append
1069                "https://hackage.haskell.org/package/quickcheck-classes/quickcheck-classes-"
1070                version
1071                ".tar.gz"))
1072         (sha256
1073           (base32 "19iw15mvb7gws3ljdxqwsbb4pmfc0sfflf8szgmrhiqr3k82mqv2"))))
1074     (build-system haskell-build-system)
1075     (inputs
1076       (list ghc-quickcheck
1077             ghc-primitive
1078             ghc-primitive-addr
1079             ghc-quickcheck-classes-base
1080             ghc-aeson
1081             ghc-semigroupoids
1082             ghc-semirings
1083             ghc-vector))
1084     (native-inputs
1085       (list ghc-base-orphans
1086             ghc-tagged
1087             ghc-base-orphans
1088             ghc-tagged
1089             ghc-tasty
1090             ghc-tasty-quickcheck))
1091     (home-page "https://github.com/andrewthad/quickcheck-classes#readme")
1092     (synopsis "QuickCheck common typeclasses")
1093     (description
1094       "This library provides QuickCheck properties to ensure that typeclass
1095 instances adhere to the set of laws that they are supposed to.  There are
1096 other libraries that do similar things, such as @code{genvalidity-hspec} and
1097 @code{checkers}.  This library differs from other solutions by not introducing
1098 any new typeclasses that the user needs to learn.  /Note:/ on GHC < 8.5, this
1099 library uses the higher-kinded typeclasses (@code{Data.Functor.Classes.Show1},
1100 @code{Data.Functor.Classes.Eq1}, @code{Data.Functor.Classes.Ord1}, etc.), but
1101 on GHC >= 8.5, it uses @code{-XQuantifiedConstraints} to express these
1102 constraints more cleanly.")
1103     (license license:bsd-3)))
1104
1105 (define-public ghc-quickcheck-classes-base
1106   (package
1107     (name "ghc-quickcheck-classes-base")
1108     (version "0.6.2.0")
1109     (source
1110       (origin
1111         (method url-fetch)
1112         (uri (string-append
1113                "https://hackage.haskell.org/package/quickcheck-classes-base/quickcheck-classes-base-"
1114                version
1115                ".tar.gz"))
1116         (sha256
1117           (base32 "16c6gq4cqpkwnq1pzkhm6r7mrwk4an50ha5w77bmiia2qkhla6ch"))))
1118     (build-system haskell-build-system)
1119     (inputs
1120       (list ghc-quickcheck
1121             ghc-contravariant
1122             ghc-bifunctors
1123             ghc-semigroups
1124             ghc-fail
1125             ghc-tagged))
1126     (home-page "https://github.com/andrewthad/quickcheck-classes#readme")
1127     (synopsis "QuickCheck common typeclasses from `base`")
1128     (description
1129       "This library is a minimal variant of `quickcheck-classes`
1130 that only provides laws for typeclasses from `base`. The main
1131 purpose of splitting this out is so that `primitive` can depend
1132 on `quickcheck-classes-base` in its test suite, avoiding the
1133 circular dependency that arises if `quickcheck-classes` is used
1134 instead. . This library provides QuickCheck properties to ensure
1135 that typeclass instances adhere to the set of laws that they are
1136 supposed to. There are other libraries that do similar things,
1137 such as `genvalidity-hspec` and `checkers`. This library differs
1138 from other solutions by not introducing any new typeclasses that
1139 the user needs to learn. . /Note:/ on GHC < 8.5, this library
1140 uses the higher-kinded typeclasses ('Data.Functor.Classes.Show1',
1141 'Data.Functor.Classes.Eq1', 'Data.Functor.Classes.Ord1', etc.),
1142 but on GHC >= 8.5, it uses `-XQuantifiedConstraints` to express
1143 these constraints more cleanly.")
1144     (license license:bsd-3)))
1145
1146 (define-public ghc-doctest-lib
1147   (package
1148     (name "ghc-doctest-lib")
1149     (version "0.1")
1150     (source
1151       (origin
1152         (method url-fetch)
1153         (uri (string-append
1154                "https://hackage.haskell.org/package/doctest-lib/doctest-lib-"
1155                version
1156                ".tar.gz"))
1157         (sha256
1158           (base32 "1vswam0dhw52dihgnzirh18gqs8rj8h6jd7pl6y1mg2f9f9zmih2"))))
1159     (build-system haskell-build-system)
1160     (home-page "https://hub.darcs.net/thielema/doctest-lib/")
1161     (synopsis "Parts of doctest exposed as library")
1162     (description
1163       "Parts of doctest exposed as library. For use with the doctest-extract utility.")
1164     (license license:expat)))
1165
1166 (define-public ghc-doctest-exitcode-stdio
1167   (package
1168     (name "ghc-doctest-exitcode-stdio")
1169     (version "0.0")
1170     (source
1171       (origin
1172         (method url-fetch)
1173         (uri (string-append
1174                "https://hackage.haskell.org/package/doctest-exitcode-stdio/doctest-exitcode-stdio-"
1175                version
1176                ".tar.gz"))
1177         (sha256
1178           (base32 "1g3c7yrqq2mwqbmvs8vkx1a3cf0p0x74b7fnn344dsk7bsfpgv0x"))))
1179     (build-system haskell-build-system)
1180     (inputs
1181       (list ghc-doctest-lib ghc-quickcheck ghc-semigroups))
1182     (home-page "https://hub.darcs.net/thielema/doctest-exitcode-stdio/")
1183     (synopsis "Run Doctests in a @code{Cabal.Test.exitcode-stdio} environment")
1184     (description
1185       "This package allows on to run Doctests in a Cabal.Test.exitcode-stdio
1186 environment.")
1187     (license license:bsd-3)))
1188
1189 (define-public ghc-cabal-doctest
1190   (package
1191     (name "ghc-cabal-doctest")
1192     (version "1.0.8")
1193     (source
1194       (origin
1195         (method url-fetch)
1196         (uri (string-append
1197                "https://hackage.haskell.org/package/cabal-doctest/cabal-doctest-"
1198                version
1199                ".tar.gz"))
1200         (sha256
1201           (base32 "03if74imlhhk7m56nci5f1wclniwqdmwl4hl177040j1gnlac9i0"))))
1202     (build-system haskell-build-system)
1203     (arguments
1204       `(#:cabal-revision
1205         ("2" "05v1awad3d1wvc763xcgvxm4n6n7bs7byc6s14kdbw35zcaddlcb")))
1206     (home-page "https://github.com/phadej/cabal-doctest")
1207     (synopsis "@file{Setup.hs} helper for Doctests running")
1208     (description
1209       "This package provides helpers for running Doctests in @file{Setup.hs}.")
1210     (license license:bsd-3)))
1211
1212 (define-public ghc-tasty-silver
1213   (package
1214     (name "ghc-tasty-silver")
1215     (version "3.2.3")
1216     (source
1217       (origin
1218         (method url-fetch)
1219         (uri (string-append
1220                "https://hackage.haskell.org/package/tasty-silver/tasty-silver-"
1221                version
1222                ".tar.gz"))
1223         (sha256
1224           (base32 "0nvh2k8iqqkanmp7lpwd3asimyarzisly8wavbdahcxryn0j4xb7"))))
1225     (build-system haskell-build-system)
1226     (inputs
1227       (list ghc-ansi-terminal
1228             ghc-async
1229             ghc-optparse-applicative
1230             ghc-process-extras
1231             ghc-regex-tdfa
1232             ghc-semigroups
1233             ghc-tagged
1234             ghc-tasty
1235             ghc-temporary))
1236     (native-inputs
1237      (list ghc-tasty-hunit ghc-silently))
1238     (home-page "https://github.com/phile314/tasty-silver")
1239     (synopsis "Fancy test runner, including support for golden tests")
1240     (description
1241       "This package provides a fancy test runner and support for @dfn{golden
1242 testing}.  A golden test is an IO action that writes its result to a file.  To
1243 pass the test, this output file should be identical to the corresponding
1244 ``golden'' file, which contains the correct result for the test.  The test
1245 runner allows filtering tests using regexes, and to interactively inspect the
1246 result of golden tests.")
1247     (license license:expat)))
1248