;;; 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 Nils Gillmann <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>
;;;
;;; 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.0.2")
+ (version "1.1.6")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "0pgz2lclg2hp72ykljcbxd88pjanfdfk8m5vb2qzcyjr85kwrhxv"))))
+ "13qqpl1prr9dda87dp45mqybay24n8rhxxgvpc9j34kh72g8j5qw"))))
(build-system haskell-build-system)
(inputs
`(("ghc-generic-deriving" ,ghc-generic-deriving)
("ghc-xml" ,ghc-xml)
- ("ghc-mtl" ,ghc-mtl)
- ("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.8.4")
+ (version "0.10.1")
(source
(origin
(method url-fetch)
"tasty-quickcheck-" version ".tar.gz"))
(sha256
(base32
- "15rjxib5jmjq0hzj47x15kgp3awc73va4cy1pmpf7k3hvfv4qprn"))))
+ "0k4vvd5vmrncv1s6gdf03l4xijwlk428sb9jfx8n1zaz02971msh"))))
(build-system haskell-build-system)
(inputs
`(("ghc-quickcheck" ,ghc-quickcheck)
(define-public ghc-tasty-golden
(package
(name "ghc-tasty-golden")
- (version "2.3.1.1")
+ (version "2.3.2")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "0pcf5hsyp5mmbqn7krdm49jxpkjm6rb4j83j28f76h7q55dzm1wy"))))
+ "0k3ibjhjc9vcwzrjnl4rnwvfm8l81q347nb7dgvcib6n5wm3s404"))))
(build-system haskell-build-system)
(inputs
`(("ghc-temporary" ,ghc-temporary)
("ghc-tasty" ,ghc-tasty)
- ("ghc-mtl" ,ghc-mtl)
("ghc-optparse-applicative" ,ghc-optparse-applicative)
("ghc-tagged" ,ghc-tagged)
("ghc-async" ,ghc-async)
"https://github.com/feuerbach/tasty-golden")
(synopsis "Golden tests support for tasty")
(description
- "This package provides support for 'golden testing'. A @dfn{golden test}
-is an IO action that writes its result to a file. To pass the test, this
-output file should be identical to the corresponding 'golden' file, which
+ "This package provides support for @code{golden testing}. A @dfn{golden
+test} is an IO action that writes its result to a file. To pass the test, this
+output file should be identical to the corresponding @code{golden} file, which
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 "0.11.0.4")
+ (version "1.2.3")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "05pxjzgbgjdn7477xry0ssjrnmnsydqiq6nm6ck8n2da1baliqp0"))))
+ "0qpn0avpw4w1qq5r2gwh2piipj0llqq6ylagr3xnqiraq6mhg8cc"))))
(build-system haskell-build-system)
(inputs
- `(("ghc-stm" ,ghc-stm)
- ("ghc-mtl" ,ghc-mtl)
- ("ghc-tagged" ,ghc-tagged)
+ `(("ghc-tagged" ,ghc-tagged)
("ghc-regex-tdfa" ,ghc-regex-tdfa)
- ("ghc-regex-tdfa-rc" ,ghc-regex-tdfa-rc)
("ghc-optparse-applicative" ,ghc-optparse-applicative)
("ghc-unbounded-delays" ,ghc-unbounded-delays)
("ghc-async" ,ghc-async)
("ghc-ansi-terminal" ,ghc-ansi-terminal)
- ("ghc-clock-bootstrap" ,ghc-clock-bootstrap)))
+ ("ghc-clock-bootstrap" ,ghc-clock-bootstrap)
+ ("ghc-wcwidth" ,ghc-wcwidth-bootstrap)))
(home-page "http://documentup.com/feuerbach/tasty")
(synopsis "Modern and extensible testing framework")
(description "Tasty is a modern testing framework for Haskell. It lets
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.9.2")
+ (version "0.10.0.2")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "08qnxaw34wfnzi9irs1jd4d0zczqm3k5ffkd4zwhkz0dflmgq7mf"))))
+ "1xvf5xs0r8xqkcg354klz4wyzwyzvinalyl6f4fnxwqmzrgch8s8"))))
(build-system haskell-build-system)
(inputs
- `(("ghc-tasty" ,ghc-tasty)))
+ `(("ghc-call-stack" ,ghc-call-stack-boot)
+ ("ghc-tasty" ,ghc-tasty)))
(home-page "http://documentup.com/feuerbach/tasty")
(synopsis "HUnit support for the Tasty test framework")
(description "This package provides HUnit support for the Tasty Haskell
(build-system haskell-build-system)
(inputs
`(("ghc-tasty" ,ghc-tasty)
- ("ghc-mtl" ,ghc-mtl)
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
("ghc-tasty-hunit" ,ghc-tasty-hunit)))
(home-page "https://github.com/vincenthz/tasty-kat")
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")
- (version "0.1.4")
+ (version "0.1.7")
(source
(origin
(method url-fetch)
version ".tar.gz"))
(sha256
(base32
- "0dff9si8i1qp0s7p4hlk0l29vq7wxfglw6mvlgmld43h7rllv88q"))))
+ "0b2ivrw2257m4cy4rjnkwqlarh83j1y3zywnmaqqqbvy667sqnj3"))))
(build-system haskell-build-system)
(inputs
- `(("ghc-tasty" ,ghc-tasty)))
+ `(("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
(home-page "https://github.com/bennofs/tasty-th")
(synopsis "Automatically generate tasty TestTrees")
(description
(define-public ghc-tasty-rerun
(package
(name "ghc-tasty-rerun")
- (version "1.1.8")
+ (version "1.1.14")
(source (origin
(method url-fetch)
(uri (string-append
"tasty-rerun-" version ".tar.gz"))
(sha256
(base32
- "0yg8cicfn3qaazvp4rbanzy3dyk95k3y1kkd4bykvkl9v4076788"))))
+ "0s0zj8ds4g1w2cjzm2lh25ivg962jigqdrbj08v3dbz64lx4mlzr"))))
(build-system haskell-build-system)
(inputs
- `(("ghc-mtl" ,ghc-mtl)
- ("ghc-optparse-applicative" ,ghc-optparse-applicative)
+ `(("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.0.4")
+ (version "0.11.1.2")
(source
(origin
(method url-fetch)
version ".tar.gz"))
(sha256
(base32
- "0r555f18d2gj96pjyc13chn1nxaxl81am4xgip3mvvjhw8s5mva1"))))
+ "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.16.1")
+ (version "0.3.22")
(source
(origin
(method url-fetch)
version ".tar.gz"))
(sha256
(base32
- "01v5bs7r9yvhkvb4yc9bqnacy8r6cy2gr9lnmwx40n5apgi0gcbz"))))
+ "14asr9r7da3w7p4hjj51w2yb002nz8x0np8hdz9z4yjvi60vyrax"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("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.10.1")
- (outputs '("out" "doc"))
+ (version "2.13.2")
+ (outputs '("out" "static" "doc"))
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "1rfmns3lj3hl93k1jws85ajkkw7z9ll8cw292n9m7zald1w5dfqx"))))
+ "0426j43af8v3qmdjjqxivazsvr3a2brac8yw09vpgpjkb2m0nmkv"))))
(build-system haskell-build-system)
(arguments
- `(#:tests? #f ; FIXME: currently missing libraries used for tests.
- #:configure-flags '("-f base4")))
+ `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
(inputs
`(("ghc-random" ,ghc-random)
+ ("ghc-splitmix" ,ghc-splitmix-bootstrap)
("ghc-tf-random" ,ghc-tf-random)))
(home-page "https://github.com/nick8325/quickcheck")
(synopsis "Automatic testing of Haskell programs")
expressed in Haskell, using combinators defined in the QuickCheck library.")
(license license:bsd-3)))
-(define-public ghc-quickcheck-2.9
- (package
- (inherit ghc-quickcheck)
- (name "ghc-quickcheck")
- (version "2.9.2")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/QuickCheck-2.9.2/QuickCheck-"
- version ".tar.gz"))
- (sha256
- (base32
- "119np67qvx8hyp9vkg4gr2wv3lj3j6ay2vl4hxspkg43ymb1cp0m"))))))
-
-(define-public ghc-quickcheck-latest
- (package (inherit ghc-quickcheck)
- (version "2.11.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/QuickCheck/QuickCheck-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "0xhqk35fkzlbjcqbabg6962jkv8d688nzmz7ng4bm84x2d95d328"))))))
-
(define-public ghc-test-framework
(package
(name "ghc-test-framework")
- (version "0.8.1.1")
+ (version "0.8.2.0")
(source
(origin
(method url-fetch)
"test-framework-" version ".tar.gz"))
(sha256
(base32
- "0wxjgdvb1c4ykazw774zlx86550848wbsvgjgcrdzcgbb9m650vq"))))
+ "1hhacrzam6b8f10hyldmjw8pb7frdxh04rfg3farxcxwbnhwgbpm"))))
(build-system haskell-build-system)
(arguments
- `(#:configure-flags (list "--allow-newer=time")))
+ `(#:tests? #f ; FIXME: Tests do not build.
+ #:cabal-revision
+ ("5" "18g92ajx3ghznd6k3ihj22ln29n676ailzwx3k0f1kj3bmpilnh6")))
(native-inputs
`(("ghc-hunit" ,ghc-hunit)
("ghc-quickcheck" ,ghc-quickcheck)))
("ghc-random" ,ghc-random)
("ghc-regex-posix" ,ghc-regex-posix)
("ghc-xml" ,ghc-xml)
- ("ghc-libxml" ,ghc-libxml)))
+ ("ghc-libxml" ,ghc-libxml)
+ ("ghc-semigroups" ,ghc-semigroups-bootstrap)))
(home-page "https://batterseapower.github.io/test-framework/")
(synopsis "Framework for running and organising tests")
(description
(base32
"1y0b6vg8nfm43v90lxxcydhi6qlxhfy4vpxbzm5ic2w55bh8xjwm"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("3" "0i9mlalv7cl1iq43ld5myrnpszq5rxmd79hk495dcb08rglhgl3z")))
(inputs
`(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
("ghc-hunit" ,ghc-hunit)
(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" "1vmpk70h1594h9s216d3ngkb399fpny1d3sh4gg0vrc75p4as68d")))
(inputs
`(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
("ghc-quickcheck" ,ghc-quickcheck)
(home-page "https://batterseapower.github.io/test-framework/")
(synopsis "QuickCheck2 support for test-framework")
(description
- "This packages provides QuickCheck2 support for the test-framework
+ "This package provides QuickCheck2 support for the test-framework
package.")
(license license:bsd-3)))
(define-public ghc-hunit
(package
(name "ghc-hunit")
- (version "1.3.1.2")
- (outputs '("out" "doc"))
+ (version "1.6.0.0")
+ (outputs '("out" "static" "doc"))
(source
(origin
(method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/HUnit/HUnit-"
- version
- ".tar.gz"))
+ (uri (string-append "https://hackage.haskell.org/package/HUnit/"
+ "HUnit-" version ".tar.gz"))
(sha256
(base32
- "10akdh4fl615rrshxi3m5gf414il1q42z4zqyb6q4jasmscvzpms"))))
+ "1pnhwqq5v8h48gbp3ibv3skfj25mf4zs5svxcavq93p9cswycj3l"))))
(build-system haskell-build-system)
+ (inputs
+ ;; We cannot use ghc-call-stack there, because it depends on
+ ;; ghc-nanospec, which depends on ghc-hunit.
+ `(("ghc-call-stack" ,ghc-call-stack-boot)))
(home-page "http://hunit.sourceforge.net/")
(synopsis "Unit testing framework for Haskell")
(description
(define-public hspec-discover
(package
(name "hspec-discover")
- (version "2.2.4")
+ (version "2.7.1")
(source
(origin
(method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/hspec-discover/hspec-discover-"
- version
- ".tar.gz"))
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "hspec-discover/hspec-discover-"
+ version ".tar.gz"))
(sha256
(base32
- "1bz7wb8v0bx1amiz4bpj34xq97d1ia29n3f654wcrh6lacydp3dv"))))
+ "0r47fm94wa6qrhp8cc1zzkjrxc32rnagfn9m9ga4dm6p6ydw4c8b"))))
(build-system haskell-build-system)
- (arguments `(#:haddock? #f)) ; Haddock phase fails because there are no
- ; documentation files.
- (inputs `(("ghc-hspec-meta" ,ghc-hspec-meta)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-hspec-meta" ,ghc-hspec-meta)))
(home-page "https://hspec.github.io/")
(synopsis "Automatically discover and run Hspec tests")
(description "hspec-discover is a tool which automatically discovers and
(define-public ghc-hspec-core
(package
(name "ghc-hspec-core")
- (version "2.2.4")
+ (version "2.7.1")
(source
(origin
(method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/hspec-core/hspec-core-"
- version
- ".tar.gz"))
+ (uri (string-append "https://hackage.haskell.org/package/hspec-core/"
+ "hspec-core-" version ".tar.gz"))
(sha256
(base32
- "0x845ngfl6vf65fnpb5mm3wj0ql45pz11bnm0x4gxc4ybd9c52ij"))))
+ "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.2.1")
+ (version "2.6.0")
(source
(origin
(method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/hspec-meta/hspec-meta-"
- version
- ".tar.gz"))
+ (uri (string-append "https://hackage.haskell.org/package/hspec-meta/"
+ "hspec-meta-" version ".tar.gz"))
(sha256
(base32
- "1m1pkrxiglxzwv8gdj5jr1bdbhxvvg6sbl9m61w4565d7k1m8yxa"))))
+ "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.2.4")
+ (version "2.7.1")
(source
(origin
(method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/hspec/hspec-"
- version
- ".tar.gz"))
+ (uri (string-append "https://hackage.haskell.org/package/hspec/"
+ "hspec-" version ".tar.gz"))
(sha256
(base32
- "1cf90gqvg1iknja6ymxqxyabpahcxni3blqllh81ywbir3whljvj"))))
+ "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.3.0")
+ (version "0.5.1")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
version ".tar.gz"))
(sha256
(base32
- "006syw8xagfhsx06ws9ywig1qx5lk4cgl7sq6pbid1s64c72mxn4"))))
+ "0hhzxaa3fxz5mk5qcsrnfr98a7bn3szx2ydgr0x9mbqmm1jg06rc"))))
(build-system haskell-build-system)
(inputs
`(("ghc-hspec-core" ,ghc-hspec-core)
(define-public ghc-hspec-expectations
(package
(name "ghc-hspec-expectations")
- (version "0.7.2")
+ (version "0.8.2")
(source
(origin
(method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/hspec-expectations/hspec-expectations-"
- version
- ".tar.gz"))
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "hspec-expectations/hspec-expectations-"
+ version ".tar.gz"))
(sha256
(base32
- "1w56jiqfyl237sr207gh3b0l8sr9layy0mdsgd5wknzb49mif6ip"))))
+ "1vxl9zazbaapijr6zmcj72j9wf7ka1pirrjbwddwwddg3zm0g5l1"))))
(build-system haskell-build-system)
+ ;; Tests depend on ghc-nanospec.
+ (arguments '(#:tests? #f))
(inputs `(("ghc-hunit" ,ghc-hunit)))
(home-page "https://github.com/sol/hspec-expectations")
(synopsis "Catchy combinators for HUnit")
"19wqignlq90qwpam01hnmmrxaxh5lkax9l1l6rlbi4a07nvp1dnz"))))
(build-system haskell-build-system)
(inputs `(("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-mtl" ,ghc-mtl)
("ghc-hunit" ,ghc-hunit)
("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
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
+ususal 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)))
HCoop / jackhill / guix / guix.git / blobdiff