;;; Copyright © 2015 Eric Bavier <bavier@member.fsf.org>
;;; Copyright © 2015 Federico Beffa <beffa@fbengineering.ch>
;;; Copyright © 2015, 2016, 2017, 2018 Ricardo Wurmus <rekado@elephly.net>
-;;; Copyright © 2016 ng0 <ng0@n0.is>
+;;; Copyright © 2016 Nikita <nikita@n0.is>
;;; Copyright © 2016 David Craven <david@craven.ch>
;;; Copyright © 2017 Danny Milosavljevic <dannym@scratchpost.org>
;;; Copyright © 2017 rsiddharth <s@ricketyspace.net>
;;; Copyright © 2017, 2018 Tobias Geerinckx-Rice <me@tobias.gr>
;;; Copyright © 2018 Tonton <tonton@riseup.net>
;;; Copyright © 2018 Arun Isaac <arunisaac@systemreboot.net>
+;;; Copyright © 2019 Timothy Sample <samplet@ngyro.com>
+;;; Copyright © 2020 John Soo <jsoo1@asu.edu>
+;;; Copyright © 2020 Carlo Holl <carloholl@gmail.com>
;;;
;;; This file is part of GNU Guix.
;;;
(define-module (gnu packages haskell-check)
#:use-module (gnu packages)
- #:use-module (gnu packages haskell)
#:use-module (gnu packages haskell-crypto)
+ #:use-module (gnu packages haskell-xyz)
#:use-module (guix build-system haskell)
#:use-module (guix download)
#:use-module ((guix licenses) #:prefix license:)
(define-public ghc-tasty-ant-xml
(package
(name "ghc-tasty-ant-xml")
- (version "1.1.4")
+ (version "1.1.6")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "0v0gsb90kh6hwlgxbclzawsskywc6yf7n8xhiifia97l4y0yx2m8"))))
+ "13qqpl1prr9dda87dp45mqybay24n8rhxxgvpc9j34kh72g8j5qw"))))
(build-system haskell-build-system)
(inputs
`(("ghc-generic-deriving" ,ghc-generic-deriving)
("ghc-xml" ,ghc-xml)
- ("ghc-stm" ,ghc-stm)
("ghc-tagged" ,ghc-tagged)
("ghc-tasty" ,ghc-tasty)))
(home-page
(define-public ghc-tasty-quickcheck
(package
(name "ghc-tasty-quickcheck")
- (version "0.10")
+ (version "0.10.1")
(source
(origin
(method url-fetch)
"tasty-quickcheck-" version ".tar.gz"))
(sha256
(base32
- "0vr6szbbz3s5461i0zr8zpq347zfvidfzv5gf3xwxhm0yk731z8h"))))
+ "0k4vvd5vmrncv1s6gdf03l4xijwlk428sb9jfx8n1zaz02971msh"))))
(build-system haskell-build-system)
(inputs
`(("ghc-quickcheck" ,ghc-quickcheck)
contains the correct result for the test.")
(license license:expat)))
-;; This package builds `clock` without tests, since the tests rely on tasty
-;; and tasty-quickcheck, which in turn require clock to build.
-(define ghc-clock-bootstrap
- (package
- (name "ghc-clock-bootstrap")
- (version "0.5.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/"
- "clock/"
- "clock-" version ".tar.gz"))
- (sha256
- (base32 "1ncph7vi2q6ywwc8ysxl1ibw6i5dwfvln88ssfazk8jgpj4iyykw"))))
- (build-system haskell-build-system)
- (arguments `(#:tests? #f)) ;; Testing suite depends on tasty and
- ;; tasty-quickcheck, which need clock to build.
- (home-page "https://hackage.haskell.org/package/clock")
- (synopsis "High-resolution clock for Haskell")
- (description "A package for convenient access to high-resolution clock and
-timer functions of different operating systems via a unified API.")
- (license license:bsd-3)))
-
(define-public ghc-tasty
(package
(name "ghc-tasty")
- (version "1.1.0.3")
+ (version "1.2.3")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "14riid753hjqr6lca1kgxpnvq0wykf0k3qc5jpag42hh8bszav22"))))
+ "0qpn0avpw4w1qq5r2gwh2piipj0llqq6ylagr3xnqiraq6mhg8cc"))))
(build-system haskell-build-system)
(inputs
- `(("ghc-stm" ,ghc-stm)
- ("ghc-tagged" ,ghc-tagged)
+ `(("ghc-tagged" ,ghc-tagged)
("ghc-regex-tdfa" ,ghc-regex-tdfa)
("ghc-optparse-applicative" ,ghc-optparse-applicative)
("ghc-unbounded-delays" ,ghc-unbounded-delays)
and any other types of tests into a single test suite.")
(license license:expat)))
+(define-public ghc-tasty-hedgehog
+ (package
+ (name "ghc-tasty-hedgehog")
+ (version "1.0.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "tasty-hedgehog/tasty-hedgehog-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1mbg5q0c0xfrk4npfj60pi693igb7r5l78x6xf9fk2jglw0nmxhz"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-tagged" ,ghc-tagged)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-hedgehog" ,ghc-hedgehog)))
+ (native-inputs
+ `(("ghc-tasty-expected-failure" ,ghc-tasty-expected-failure)))
+ (arguments
+ `(#:cabal-revision
+ ("1" "1n6797fm8swyrk8cw7zxz593gq82wx8dayvm204rmgcz75bslcpn")))
+ (home-page "https://github.com/qfpl/tasty-hedgehog")
+ (synopsis "Integration for tasty and hedgehog")
+ (description "This package provides the means for integrating the
+@url{https://hackage.haskell.org/package/hedgehog, hedgehog testing library}
+with the @url{https://hackage.haskell.org/package/tasty, tasty testing
+framework}.")
+ (license license:bsd-3)))
+
+(define-public ghc-tasty-hspec
+ (package
+ (name "ghc-tasty-hspec")
+ (version "1.1.5.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/tasty-hspec/tasty-hspec-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0i9kdzjpk750sa078jj3iyhp72k0177zk7vxl131r6dkyz09x27y"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("ghc-hspec-core" ,ghc-hspec-core)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+ (arguments
+ `(#:cabal-revision
+ ("4" "1yppwhs2r2rlwrzli9ccv5ldgl95h5p7pqhsr898r3das6daf6sk")))
+ (home-page
+ "https://github.com/mitchellwrosen/tasty-hspec")
+ (synopsis
+ "Hspec support for the Tasty test framework")
+ (description
+ "This package provides a Tasty provider for Hspec test suites.")
+ (license license:bsd-3)))
+
(define-public ghc-tasty-hunit
(package
(name "ghc-tasty-hunit")
- (version "0.10.0.1")
+ (version "0.10.0.2")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "0j3hgga6c3s8h5snzivb8a75h96207ia2rlbxzj07xbf4zpkp44g"))))
+ "1xvf5xs0r8xqkcg354klz4wyzwyzvinalyl6f4fnxwqmzrgch8s8"))))
(build-system haskell-build-system)
(inputs
`(("ghc-call-stack" ,ghc-call-stack-boot)
tasty.")
(license license:expat)))
+(define-public ghc-tasty-lua
+ (package
+ (name "ghc-tasty-lua")
+ (version "0.2.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "tasty-lua/tasty-lua-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0xlj36rrhkx312h7smx6ay20rhlhxvw2ma2ckdnzv1pvmdn6p5qx"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-file-embed" ,ghc-file-embed)
+ ("ghc-hslua" ,ghc-hslua)
+ ("ghc-tasty" ,ghc-tasty)))
+ (native-inputs
+ `(("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+ (home-page "https://github.com/hslua/tasty-lua")
+ (synopsis "Write tests in Lua, integrate into tasty")
+ (description "This package gives users the ability to define tasty tests
+from Lua.")
+ (license license:expat)))
+
(define-public ghc-tasty-th
(package
(name "ghc-tasty-th")
(define-public ghc-tasty-rerun
(package
(name "ghc-tasty-rerun")
- (version "1.1.12")
+ (version "1.1.14")
(source (origin
(method url-fetch)
(uri (string-append
"tasty-rerun-" version ".tar.gz"))
(sha256
(base32
- "05lp4zy6lwd916snq6hs43848n62j9vdfl3s8sfivqydrax0vvd8"))))
+ "0s0zj8ds4g1w2cjzm2lh25ivg962jigqdrbj08v3dbz64lx4mlzr"))))
(build-system haskell-build-system)
(inputs
`(("ghc-optparse-applicative" ,ghc-optparse-applicative)
("ghc-reducers" ,ghc-reducers)
("ghc-split" ,ghc-split)
- ("ghc-stm" ,ghc-stm)
("ghc-tagged" ,ghc-tagged)
("ghc-tasty" ,ghc-tasty)))
(home-page "https://github.com/ocharles/tasty-rerun")
(define-public ghc-tasty-expected-failure
(package
(name "ghc-tasty-expected-failure")
- (version "0.11.1.1")
+ (version "0.11.1.2")
(source
(origin
(method url-fetch)
version ".tar.gz"))
(sha256
(base32
- "1i2s809m644b7hgiblqay9j364r3fjj1rwbrahsn1pgr5q6mr6ji"))))
+ "175gdk1mkslcwjxajkbl4zmaigzf8h4svzd7va5qb519y0dxk28n"))))
(build-system haskell-build-system)
(inputs
`(("ghc-tagged" ,ghc-tagged)
("ghc-tasty" ,ghc-tasty)))
- (home-page "http://github.com/nomeata/tasty-expected-failure")
+ (home-page "https://github.com/nomeata/tasty-expected-failure")
(synopsis "Mark tasty tests as failure expected")
(description
"With the function @code{Test.Tasty.ExpectedFailure.expectFail} in the
(define-public ghc-quickcheck-instances
(package
(name "ghc-quickcheck-instances")
- (version "0.3.18")
+ (version "0.3.22")
(source
(origin
(method url-fetch)
version ".tar.gz"))
(sha256
(base32
- "1bh1pzz5fdcqvzdcirqxna6fnjms02min5md716299g5niz46w55"))))
+ "14asr9r7da3w7p4hjj51w2yb002nz8x0np8hdz9z4yjvi60vyrax"))))
(build-system haskell-build-system)
(arguments
`(#:cabal-revision
- ("1" "1sngfq3v71bvgjsl8cj5kh65m3fziwy8dkvwjzs0kxfrzr87faly")))
+ ("2" "1ia5fjhpg7rz793552v88gv2iqx7hl9mi2g09m0llasy1cpzc9jr")))
(inputs
`(("ghc-quickcheck" ,ghc-quickcheck)
("ghc-base-compat" ,ghc-base-compat)
("ghc-old-time" ,ghc-old-time)
("ghc-scientific" ,ghc-scientific)
("ghc-tagged" ,ghc-tagged)
- ("ghc-text" ,ghc-text)
+ ("ghc-time-compat" ,ghc-time-compat)
("ghc-transformers-compat" ,ghc-transformers-compat)
("ghc-unordered-containers" ,ghc-unordered-containers)
("ghc-uuid-types" ,ghc-uuid-types)
(define-public ghc-quickcheck
(package
(name "ghc-quickcheck")
- (version "2.11.3")
- (outputs '("out" "doc"))
+ (version "2.13.2")
+ (outputs '("out" "static" "doc"))
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "0xhqk35fkzlbjcqbabg6962jkv8d688nzmz7ng4bm84x2d95d328"))))
+ "0426j43af8v3qmdjjqxivazsvr3a2brac8yw09vpgpjkb2m0nmkv"))))
(build-system haskell-build-system)
- (arguments
- `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
(inputs
`(("ghc-random" ,ghc-random)
- ("ghc-tf-random" ,ghc-tf-random)))
+ ("ghc-splitmix" ,ghc-splitmix-bootstrap)))
(home-page "https://github.com/nick8325/quickcheck")
(synopsis "Automatic testing of Haskell programs")
(description
(build-system haskell-build-system)
(arguments
`(#:tests? #f ; FIXME: Tests do not build.
- #:phases
- (modify-phases %standard-phases
- (add-before 'configure 'update-constraints
- (lambda _
- (substitute* "test-framework.cabal"
- (("QuickCheck >= 2\\.3 && < 2\\.10")
- "QuickCheck >= 2.3 && < 2.12")))))))
+ #:cabal-revision
+ ("5" "18g92ajx3ghznd6k3ihj22ln29n676ailzwx3k0f1kj3bmpilnh6")))
(native-inputs
`(("ghc-hunit" ,ghc-hunit)
("ghc-quickcheck" ,ghc-quickcheck)))
(define-public ghc-test-framework-quickcheck2
(package
(name "ghc-test-framework-quickcheck2")
- (version "0.3.0.4")
+ (version "0.3.0.5")
(source
(origin
(method url-fetch)
"test-framework-quickcheck2-" version ".tar.gz"))
(sha256
(base32
- "0vj834337r6jzr3258cv68ly2sv5999mklpsrfngyk51kywsyqyp"))))
+ "0ngf9vvby4nrdf1i7dxf5m9jn0g2pkq32w48xdr92n9hxka7ixn9"))))
(build-system haskell-build-system)
(arguments
`(#:cabal-revision
- ("1" "147ngmfdkskyg7mwsp5w73a4dbx3rp5s38bci3z03kn1m093lxff")))
+ ("1" "1vmpk70h1594h9s216d3ngkb399fpny1d3sh4gg0vrc75p4as68d")))
(inputs
`(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
("ghc-quickcheck" ,ghc-quickcheck)
(package
(name "ghc-hunit")
(version "1.6.0.0")
- (outputs '("out" "doc"))
+ (outputs '("out" "static" "doc"))
(source
(origin
(method url-fetch)
(define-public hspec-discover
(package
(name "hspec-discover")
- (version "2.5.5")
+ (version "2.7.1")
(source
(origin
(method url-fetch)
version ".tar.gz"))
(sha256
(base32
- "04aidzi91ccr9bygmfkjzshz34z9vh8wvqj4zinx2clxq6r7gqfz"))))
+ "0r47fm94wa6qrhp8cc1zzkjrxc32rnagfn9m9ga4dm6p6ydw4c8b"))))
(build-system haskell-build-system)
(native-inputs
`(("ghc-quickcheck" ,ghc-quickcheck)
(define-public ghc-hspec-core
(package
(name "ghc-hspec-core")
- (version "2.5.5")
+ (version "2.7.1")
(source
(origin
(method url-fetch)
"hspec-core-" version ".tar.gz"))
(sha256
(base32
- "1vfrqlpn32s9wiykmkxbnrnd5p56yznw20pf8fwzw78ar4wpz55x"))))
+ "08vk8588lap00hsln8zl64dazbb28lzk4b4h5vnm7xvhg7r21k1c"))))
(build-system haskell-build-system)
(arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
(inputs
`(("ghc-setenv" ,ghc-setenv)
("ghc-ansi-terminal" ,ghc-ansi-terminal)
- ("ghc-async" ,ghc-async)
("ghc-clock" ,ghc-clock)
("ghc-quickcheck-io" ,ghc-quickcheck-io)
("ghc-hunit" ,ghc-hunit)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-hspec-expectations" ,ghc-hspec-expectations)
- ("ghc-silently" ,ghc-silently)))
+ ("ghc-silently" ,ghc-silently)
+ ("ghc-tf-random" ,ghc-tf-random)))
(home-page "https://hspec.github.io/")
(synopsis "Testing framework for Haskell")
(description "This library exposes internal types and functions that can
(define-public ghc-hspec-meta
(package
(name "ghc-hspec-meta")
- (version "2.4.6")
+ (version "2.6.0")
(source
(origin
(method url-fetch)
"hspec-meta-" version ".tar.gz"))
(sha256
(base32
- "0qmvk01n79j6skn79r6zalg2pd0x0nqqn9qn8mhg0pgyzcdnfc9b"))))
+ "1n1a4633wfivylglji8920f67mx7qz8j4q58n8p7dxk6yg4h3mz6"))))
(build-system haskell-build-system)
(inputs
`(("ghc-quickcheck" ,ghc-quickcheck)
("ghc-hunit" ,ghc-hunit)
("ghc-ansi-terminal" ,ghc-ansi-terminal)
- ("ghc-async" ,ghc-async)
+ ("ghc-clock" ,ghc-clock)
("ghc-hspec-expectations" ,ghc-hspec-expectations)
("ghc-setenv" ,ghc-setenv)
("ghc-random" ,ghc-random)
(define-public ghc-hspec
(package
(name "ghc-hspec")
- (version "2.5.5")
+ (version "2.7.1")
(source
(origin
(method url-fetch)
"hspec-" version ".tar.gz"))
(sha256
(base32
- "1yv4k5b5kkig2q3waj28587sq28wms7wfav5a3lq4dra6jybimfm"))))
+ "1x8rcr7j1azcaw0fg1xzp8j0gr4ias36z09aj24i4xp8pnyfp341"))))
(build-system haskell-build-system)
+ (outputs '("out" "static" "doc"))
(inputs
`(("ghc-hspec-core" ,ghc-hspec-core)
("hspec-discover" ,hspec-discover)
(define-public ghc-hspec-contrib
(package
(name "ghc-hspec-contrib")
- (version "0.5.0")
+ (version "0.5.1")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
version ".tar.gz"))
(sha256
(base32
- "13579xdqwbsy8k0vxdcvgy932d4p76mij1rzkzbpqbspfn7399yv"))))
+ "0hhzxaa3fxz5mk5qcsrnfr98a7bn3szx2ydgr0x9mbqmm1jg06rc"))))
(build-system haskell-build-system)
(inputs
`(("ghc-hspec-core" ,ghc-hspec-core)
cryptographic ciphers, and is used by the test runners of various Haskell
implementations of cryptographic ciphers.")
(license license:bsd-3)))
+
+(define-public ghc-hedgehog
+ (package
+ (name "ghc-hedgehog")
+ (version "1.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://hackage/package/hedgehog/hedgehog-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1qc7hkqbnsk3f5r26wc35r3qiy941nmcxhfqgcq9027kw4gs0bi0"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-ansi-terminal" ,ghc-ansi-terminal)
+ ("ghc-async" ,ghc-async)
+ ("ghc-concurrent-output" ,ghc-concurrent-output)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-fail" ,ghc-fail)
+ ("ghc-lifted-async" ,ghc-lifted-async)
+ ("ghc-mmorph" ,ghc-mmorph)
+ ("ghc-monad-control" ,ghc-monad-control)
+ ("ghc-pretty-show" ,ghc-pretty-show)
+ ("ghc-primitive" ,ghc-primitive)
+ ("ghc-random" ,ghc-random)
+ ("ghc-resourcet" ,ghc-resourcet)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-th-lift" ,ghc-th-lift)
+ ("ghc-transformers-base" ,ghc-transformers-base)
+ ("ghc-wl-pprint-annotated"
+ ,ghc-wl-pprint-annotated)))
+ (home-page "https://hedgehog.qa")
+ (synopsis "Property-based testing in the spirt of QuickCheck")
+ (description
+ "Hedgehog is a property-based testing system, in the spirit of
+QuickCheck. Hedgehog uses integrated shrinking, so shrinks obey the invariants
+of generated values by construction.
+
+To get started quickly, see the examples:
+@uref{https://github.com/hedgehogqa/haskell-hedgehog/tree/master/hedgehog-example}")
+ (license license:bsd-3)))
+
+(define-public cabal-doctest
+ (package
+ (name "cabal-doctest")
+ (version "1.0.8")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "cabal-doctest/cabal-doctest-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "03if74imlhhk7m56nci5f1wclniwqdmwl4hl177040j1gnlac9i0"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/phadej/cabal-doctest")
+ (synopsis "Setup.hs helper for running doctests")
+ (description
+ "To properly work, the @code{doctest} package needs plenty of
+configuration. This library provides the common bits for writing custom
+@file{Setup.hs} files.")
+ (license license:bsd-3)))
+
+(define-public ghc-testing-type-modifiers
+ (package
+ (name "ghc-testing-type-modifiers")
+ (version "0.1.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "testing-type-modifiers/testing-type-modifiers-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1wh2n95n39ivv6kbqn42vbzrj8zagsmk6f2al2qj40bg5kgdl2q5"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/testing-type-modifiers")
+ (synopsis "Data type modifiers for property based testing")
+ (description "Property based testing libraries such as QuickCheck tend to
+include type modifiers. Most of them are used to quantify over subsets of a
+type. This library is intended to supply these modifiers to be used by
+testing libraries, in an effort to make properties more portable between
+testing frameworks.")
+ (license license:unlicense)))
+
+(define-public ghc-testing-feat
+ (package
+ (name "ghc-testing-feat")
+ (version "1.1.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "testing-feat/testing-feat-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1v2qzzpf1s008g7q6q67glf7vbm1pkpq4rc3ii74f4g6vhfx610r"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-size-based" ,ghc-size-based)
+ ("ghc-testing-type-modifiers" ,ghc-testing-type-modifiers)
+ ("ghc-semigroups" ,ghc-semigroups)))
+ (home-page "https://github.com/JonasDuregard/testing-feat")
+ (synopsis "Functional Enumeration of Algebraic Types")
+ (description "Feat (Functional Enumeration of Algebraic Types)
+provides enumerations as functions from natural numbers to
+values (similar to @code{toEnum} but for any algebraic data type). This
+can be used for SmallCheck-style systematic testing, QuickCheck-style
+random testing, and hybrids of the two.")
+ (license license:bsd-3)))
+
+(define-public ghc-inspection-testing
+ (package
+ (name "ghc-inspection-testing")
+ (version "0.4.2.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/inspection-testing/"
+ "inspection-testing-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1bppz99p6ix6hah8lbr9mapl2zxgmkg9i7h6hk8wq6zf54hwz3yp"))))
+ (build-system haskell-build-system)
+ (home-page
+ "https://github.com/nomeata/inspection-testing")
+ (synopsis "GHC plugin to do inspection testing")
+ (description
+ "Some carefully crafted libraries make promises to their users beyond
+functionality and performance.
+
+Examples are: Fusion libraries promise intermediate data structures to be
+eliminated. Generic programming libraries promise that the generic
+implementation is identical to the hand-written one. Some libraries may
+promise allocation-free or branch-free code.
+
+Conventionally, the modus operandi in all these cases is that the library
+author manually inspects the (intermediate or final) code produced by the
+compiler. This is not only tedious, but makes it very likely that some change,
+either in the library itself or the surrounding eco-system, breaks the
+library's promised without anyone noticing.
+
+This package provides a disciplined way of specifying such properties, and
+have them checked by the compiler. This way, this checking can be part of the
+regular development cycle and regressions caught early.
+
+See the documentation in \"Test.Inspection\" or the project webpage for more
+examples and more information.")
+ (license license:expat)))
+
+(define-public ghc-easytest
+ (package
+ (name "ghc-easytest")
+ (version "0.2.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/easytest/easytest-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0gdyawzlw6d15yz7ji599xjgfr0g7l1iq11ffr4aw3j6g3dc6m8i"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-async" ,ghc-async)
+ ("ghc-random" ,ghc-random)
+ ("ghc-call-stack" ,ghc-call-stack)))
+ (home-page "https://github.com/joelburget/easytest")
+ (synopsis "Testing library for Haskell")
+ (description "EasyTest is a testing toolkit, meant to replace most uses of
+QuickCheck, SmallCheck, HUnit, and frameworks like Tasty, etc. Tests can be
+written with ordinary Haskell code, with control flow explicit and under
+programmer control.")
+ (license license:expat)))