X-Git-Url: https://git.hcoop.net/jackhill/guix/guix.git/blobdiff_plain/3b8e47745d045afd36eadc83eb0a6289ceabc9e5..5cd9cd644ca493b230cb229e7c46641e94a4e2fa:/gnu/packages/haskell-check.scm diff --git a/gnu/packages/haskell-check.scm b/gnu/packages/haskell-check.scm index ef07748daa..bb7f57b49d 100644 --- a/gnu/packages/haskell-check.scm +++ b/gnu/packages/haskell-check.scm @@ -3,12 +3,15 @@ ;;; Copyright © 2015 Eric Bavier ;;; Copyright © 2015 Federico Beffa ;;; Copyright © 2015, 2016, 2017, 2018 Ricardo Wurmus -;;; Copyright © 2016 Nils Gillmann +;;; Copyright © 2016 Nikita ;;; Copyright © 2016 David Craven ;;; Copyright © 2017 Danny Milosavljevic ;;; Copyright © 2017 rsiddharth ;;; Copyright © 2017, 2018 Tobias Geerinckx-Rice ;;; Copyright © 2018 Tonton +;;; Copyright © 2018 Arun Isaac +;;; Copyright © 2019 Timothy Sample +;;; Copyright © 2020 John Soo ;;; ;;; This file is part of GNU Guix. ;;; @@ -27,8 +30,8 @@ (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:) @@ -38,7 +41,7 @@ (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) @@ -48,13 +51,11 @@ ".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 @@ -96,7 +97,7 @@ Haskell test framework.") (define-public ghc-tasty-quickcheck (package (name "ghc-tasty-quickcheck") - (version "0.8.4") + (version "0.10.1") (source (origin (method url-fetch) @@ -105,7 +106,7 @@ Haskell test framework.") "tasty-quickcheck-" version ".tar.gz")) (sha256 (base32 - "15rjxib5jmjq0hzj47x15kgp3awc73va4cy1pmpf7k3hvfv4qprn")))) + "0k4vvd5vmrncv1s6gdf03l4xijwlk428sb9jfx8n1zaz02971msh")))) (build-system haskell-build-system) (inputs `(("ghc-quickcheck" ,ghc-quickcheck) @@ -124,7 +125,7 @@ Haskell test framework.") (define-public ghc-tasty-golden (package (name "ghc-tasty-golden") - (version "2.3.1.1") + (version "2.3.2") (source (origin (method url-fetch) @@ -134,12 +135,11 @@ Haskell test framework.") ".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) @@ -149,40 +149,16 @@ Haskell test framework.") "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) @@ -192,19 +168,17 @@ timer functions of different operating systems via a unified API.") ".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 @@ -212,10 +186,73 @@ you combine your unit tests, golden tests, QuickCheck/SmallCheck properties, 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) @@ -225,10 +262,11 @@ and any other types of tests into a single test suite.") ".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 @@ -249,7 +287,6 @@ test framework.") (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") @@ -259,10 +296,35 @@ test framework.") 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) @@ -271,10 +333,12 @@ tasty.") 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 @@ -287,7 +351,7 @@ test-framework.") (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 @@ -295,14 +359,12 @@ test-framework.") "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") @@ -316,7 +378,7 @@ been added since previous test run.") (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) @@ -325,7 +387,7 @@ been added since previous test run.") version ".tar.gz")) (sha256 (base32 - "0r555f18d2gj96pjyc13chn1nxaxl81am4xgip3mvvjhw8s5mva1")))) + "175gdk1mkslcwjxajkbl4zmaigzf8h4svzd7va5qb519y0dxk28n")))) (build-system haskell-build-system) (inputs `(("ghc-tagged" ,ghc-tagged) @@ -342,7 +404,7 @@ development.") (define-public ghc-quickcheck-instances (package (name "ghc-quickcheck-instances") - (version "0.3.16.1") + (version "0.3.22") (source (origin (method url-fetch) @@ -352,8 +414,11 @@ development.") 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) @@ -362,7 +427,7 @@ development.") ("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) @@ -423,7 +488,7 @@ use HUnit assertions as QuickCheck properties.") (define-public ghc-quickcheck (package (name "ghc-quickcheck") - (version "2.10.1") + (version "2.13.2") (outputs '("out" "doc")) (source (origin @@ -434,13 +499,13 @@ use HUnit assertions as QuickCheck properties.") ".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") @@ -452,37 +517,10 @@ hold in a large number of randomly generated cases. Specifications are 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) @@ -490,10 +528,12 @@ expressed in Haskell, using combinators defined in the QuickCheck library.") "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))) @@ -505,7 +545,8 @@ expressed in Haskell, using combinators defined in the QuickCheck library.") ("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 @@ -530,6 +571,9 @@ reporting and test statistics output.") (base32 "1y0b6vg8nfm43v90lxxcydhi6qlxhfy4vpxbzm5ic2w55bh8xjwm")))) (build-system haskell-build-system) + (arguments + `(#:cabal-revision + ("3" "0i9mlalv7cl1iq43ld5myrnpszq5rxmd79hk495dcb08rglhgl3z"))) (inputs `(("ghc-extensible-exceptions" ,ghc-extensible-exceptions) ("ghc-hunit" ,ghc-hunit) @@ -543,7 +587,7 @@ reporting and test statistics output.") (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) @@ -552,8 +596,11 @@ reporting and test statistics output.") "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) @@ -562,7 +609,7 @@ reporting and test statistics output.") (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))) @@ -603,19 +650,21 @@ using Template Haskell") (define-public ghc-hunit (package (name "ghc-hunit") - (version "1.3.1.2") + (version "1.6.0.0") (outputs '("out" "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 @@ -626,7 +675,7 @@ JUnit tool for Java.") (define-public hspec-discover (package (name "hspec-discover") - (version "2.5.5") + (version "2.7.1") (source (origin (method url-fetch) @@ -635,7 +684,7 @@ JUnit tool for Java.") version ".tar.gz")) (sha256 (base32 - "04aidzi91ccr9bygmfkjzshz34z9vh8wvqj4zinx2clxq6r7gqfz")))) + "0r47fm94wa6qrhp8cc1zzkjrxc32rnagfn9m9ga4dm6p6ydw4c8b")))) (build-system haskell-build-system) (native-inputs `(("ghc-quickcheck" ,ghc-quickcheck) @@ -649,7 +698,7 @@ runs Hspec tests.") (define-public ghc-hspec-core (package (name "ghc-hspec-core") - (version "2.5.5") + (version "2.7.1") (source (origin (method url-fetch) @@ -657,19 +706,19 @@ runs Hspec tests.") "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 @@ -679,23 +728,21 @@ be used to extend Hspec's functionality.") (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) @@ -709,17 +756,15 @@ used to test the in-development version of Hspec.") (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) (inputs `(("ghc-hspec-core" ,ghc-hspec-core) @@ -738,7 +783,7 @@ Haskell, inspired by the Ruby library RSpec.") (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/" @@ -746,7 +791,7 @@ Haskell, inspired by the Ruby library RSpec.") version ".tar.gz")) (sha256 (base32 - "006syw8xagfhsx06ws9ywig1qx5lk4cgl7sq6pbid1s64c72mxn4")))) + "0hhzxaa3fxz5mk5qcsrnfr98a7bn3szx2ydgr0x9mbqmm1jg06rc")))) (build-system haskell-build-system) (inputs `(("ghc-hspec-core" ,ghc-hspec-core) @@ -764,18 +809,19 @@ Haskell, inspired by the Ruby library RSpec.") (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") @@ -822,7 +868,6 @@ minimal dependencies.") "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) @@ -836,3 +881,159 @@ minimal dependencies.") 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)))