;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org>
;;; Copyright © 2015 Eric Bavier <bavier@member.fsf.org>
;;; Copyright © 2015 Federico Beffa <beffa@fbengineering.ch>
-;;; Copyright © 2015, 2016, 2017 Ricardo Wurmus <rekado@elephly.net>
-;;; Copyright © 2016 ng0 <ng0@infotropique.org>
+;;; Copyright © 2015, 2016, 2017, 2018 Ricardo Wurmus <rekado@elephly.net>
+;;; Copyright © 2016 ng0 <ng0@n0.is>
;;; Copyright © 2016 David Craven <david@craven.ch>
;;; Copyright © 2017 Danny Milosavljevic <dannym@scratchpost.org>
;;; Copyright © 2017 rsiddharth <s@ricketyspace.net>
-;;; Copyright © 2017 Tobias Geerinckx-Rice <me@tobias.gr>
+;;; Copyright © 2017, 2018 Tobias Geerinckx-Rice <me@tobias.gr>
+;;; Copyright © 2018 Tonton <tonton@riseup.net>
+;;; Copyright © 2018 Arun Isaac <arunisaac@systemreboot.net>
;;;
;;; 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 (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.4")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "0pgz2lclg2hp72ykljcbxd88pjanfdfk8m5vb2qzcyjr85kwrhxv"))))
+ "0v0gsb90kh6hwlgxbclzawsskywc6yf7n8xhiifia97l4y0yx2m8"))))
(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)))
(define-public ghc-tasty-smallcheck
(package
(name "ghc-tasty-smallcheck")
- (version "0.8.0.1")
+ (version "0.8.1")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "0yckfbz8na8ccyw2911i3a4hd3fdncclk3ng5343hs5cylw6y4sm"))))
+ "1n66ngzllf3xrlqykwszlkwsi96n5nkm7xbpfq7774vpvfnafjri"))))
(build-system haskell-build-system)
(inputs
`(("ghc-tasty" ,ghc-tasty)
("ghc-smallcheck" ,ghc-smallcheck)
("ghc-async" ,ghc-async)
("ghc-tagged" ,ghc-tagged)))
- (home-page "http://documentup.com/feuerbach/tasty")
+ (home-page "https://documentup.com/feuerbach/tasty")
(synopsis "SmallCheck support for the Tasty test framework")
(description "This package provides SmallCheck support for the Tasty
Haskell test framework.")
(define-public ghc-tasty-quickcheck
(package
(name "ghc-tasty-quickcheck")
- (version "0.8.4")
+ (version "0.10")
(source
(origin
(method url-fetch)
"tasty-quickcheck-" version ".tar.gz"))
(sha256
(base32
- "15rjxib5jmjq0hzj47x15kgp3awc73va4cy1pmpf7k3hvfv4qprn"))))
+ "0vr6szbbz3s5461i0zr8zpq347zfvidfzv5gf3xwxhm0yk731z8h"))))
(build-system haskell-build-system)
(inputs
`(("ghc-quickcheck" ,ghc-quickcheck)
(define-public ghc-tasty-golden
(package
(name "ghc-tasty-golden")
- (version "2.3.0.2")
+ (version "2.3.2")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "0n7nll1sx75n3lffwhgnjrxdn0jz1g0921z9mj193fxqw0wz8axh"))))
+ "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 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 contains
-the correct result for the test.")
+ "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
+contains the correct result for the test.")
(license license:expat)))
;; This package builds `clock` without tests, since the tests rely on tasty
(define-public ghc-tasty
(package
(name "ghc-tasty")
- (version "0.11.0.1")
+ (version "1.1.0.3")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "1chapivmmwsb1ghwagvdm80bfj3hdk75m94z4p212ng2i4ghpjkx"))))
+ "14riid753hjqr6lca1kgxpnvq0wykf0k3qc5jpag42hh8bszav22"))))
(build-system haskell-build-system)
(inputs
`(("ghc-stm" ,ghc-stm)
- ("ghc-mtl" ,ghc-mtl)
("ghc-tagged" ,ghc-tagged)
- ("ghc-regex-tdfa-rc" ,ghc-regex-tdfa-rc)
+ ("ghc-regex-tdfa" ,ghc-regex-tdfa)
("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
(define-public ghc-tasty-hunit
(package
(name "ghc-tasty-hunit")
- (version "0.9.2")
+ (version "0.10.0.1")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "08qnxaw34wfnzi9irs1jd4d0zczqm3k5ffkd4zwhkz0dflmgq7mf"))))
+ "0j3hgga6c3s8h5snzivb8a75h96207ia2rlbxzj07xbf4zpkp44g"))))
(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")
(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.7")
+ (version "1.1.12")
(source (origin
(method url-fetch)
(uri (string-append
"tasty-rerun-" version ".tar.gz"))
(sha256
(base32
- "18hz1xqinf59mzvd68ygj9333v0a32qxfcas7crn4iniq5zv71kj"))))
+ "05lp4zy6lwd916snq6hs43848n62j9vdfl3s8sfivqydrax0vvd8"))))
(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)
been added since previous test run.")
(license license:bsd-3)))
+(define-public ghc-tasty-expected-failure
+ (package
+ (name "ghc-tasty-expected-failure")
+ (version "0.11.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "tasty-expected-failure/tasty-expected-failure-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1i2s809m644b7hgiblqay9j364r3fjj1rwbrahsn1pgr5q6mr6ji"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-tagged" ,ghc-tagged)
+ ("ghc-tasty" ,ghc-tasty)))
+ (home-page "http://github.com/nomeata/tasty-expected-failure")
+ (synopsis "Mark tasty tests as failure expected")
+ (description
+ "With the function @code{Test.Tasty.ExpectedFailure.expectFail} in the
+provided module @code{Test.Tasty.ExpectedFailure}, you can mark that you
+expect test cases to fail, and not to pass. This can be used for test-driven
+development.")
+ (license license:expat)))
+
(define-public ghc-quickcheck-instances
(package
(name "ghc-quickcheck-instances")
- (version "0.3.12")
+ (version "0.3.18")
(source
(origin
(method url-fetch)
version ".tar.gz"))
(sha256
(base32
- "1wwvkzpams7i0j7nk5qj8vvhj8x5zcbgbgrpczszgvshva4bkmfx"))))
+ "1bh1pzz5fdcqvzdcirqxna6fnjms02min5md716299g5niz46w55"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("1" "1sngfq3v71bvgjsl8cj5kh65m3fziwy8dkvwjzs0kxfrzr87faly")))
(inputs
- `(("ghc-old-time" ,ghc-old-time)
- ("ghc-unordered-containers" ,ghc-unordered-containers)
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-base-compat" ,ghc-base-compat)
+ ("ghc-case-insensitive" ,ghc-case-insensitive)
("ghc-hashable" ,ghc-hashable)
- ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-old-time" ,ghc-old-time)
("ghc-scientific" ,ghc-scientific)
- ("ghc-vector" ,ghc-vector)
- ("ghc-text" ,ghc-text)))
- (home-page
- "https://github.com/aslatter/qc-instances")
+ ("ghc-tagged" ,ghc-tagged)
+ ("ghc-text" ,ghc-text)
+ ("ghc-transformers-compat" ,ghc-transformers-compat)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-uuid-types" ,ghc-uuid-types)
+ ("ghc-vector" ,ghc-vector)))
+ (home-page "https://github.com/aslatter/qc-instances")
(synopsis "Common quickcheck instances")
(description "This package provides QuickCheck instances for types
provided by the Haskell Platform.")
(define-public ghc-quickcheck-unicode
(package
(name "ghc-quickcheck-unicode")
- (version "1.0.0.1")
+ (version "1.0.1.0")
(source
(origin
(method url-fetch)
(uri (string-append
- "https://hackage.haskell.org/package/quickcheck-unicode/quickcheck-unicode-"
- version
- ".tar.gz"))
+ "https://hackage.haskell.org/package/quickcheck-unicode/"
+ "quickcheck-unicode-" version ".tar.gz"))
(sha256
(base32
- "1a8nl6x7l9b22yx61wm0bh2n1xzb1hd5i5zgg1w4fpaivjnrrhi4"))))
+ "0s43s1bzbg3gwsjgm7fpyksd1339f0m26dlw2famxwyzgvm0a80k"))))
(build-system haskell-build-system)
(inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
(home-page
(define-public ghc-quickcheck-io
(package
(name "ghc-quickcheck-io")
- (version "0.1.2")
+ (version "0.2.0")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "1kf1kfw9fsmly0rvzvdf6jvdw10qhkmikyj0wcwciw6wad95w9sh"))))
+ "08k4v7pkgjf30pv5j2dfv1gqv6hclxlniyq2sps8zq4zswcr2xzv"))))
(build-system haskell-build-system)
(inputs
`(("ghc-quickcheck" ,ghc-quickcheck)
(define-public ghc-quickcheck
(package
(name "ghc-quickcheck")
- (version "2.8.2")
+ (version "2.11.3")
(outputs '("out" "doc"))
(source
(origin
".tar.gz"))
(sha256
(base32
- "1ai6k5v0bibaxq8xffcblc6rwmmk6gf8vjyd9p2h3y6vwbhlvilq"))))
+ "0xhqk35fkzlbjcqbabg6962jkv8d688nzmz7ng4bm84x2d95d328"))))
(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-tf-random" ,ghc-tf-random)))
- (home-page
- "https://github.com/nick8325/quickcheck")
- (synopsis
- "Automatic testing of Haskell programs")
+ `(("ghc-random" ,ghc-random)
+ ("ghc-tf-random" ,ghc-tf-random)))
+ (home-page "https://github.com/nick8325/quickcheck")
+ (synopsis "Automatic testing of Haskell programs")
(description
- "QuickCheck is a library for random testing of program properties.")
+ "QuickCheck is a library for random testing of program properties. The
+programmer provides a specification of the program, in the form of properties
+which functions should satisfy, and QuickCheck then tests that the properties
+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-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
+ `(#: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")))))))
(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
(define-public ghc-test-framework-hunit
(package
(name "ghc-test-framework-hunit")
- (version "0.3.0.1")
+ (version "0.3.0.2")
(source
(origin
(method url-fetch)
version ".tar.gz"))
(sha256
(base32
- "1h0h55kf6ff25nbfx1mhliwyknc0glwv3zi78wpzllbjbs7gvyfk"))))
+ "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.3")
+ (version "0.3.0.4")
(source
(origin
(method url-fetch)
"test-framework-quickcheck2-" version ".tar.gz"))
(sha256
(base32
- "12p1zwrsz35r3j5gzbvixz9z1h5643rhihf5gqznmc991krwd5nc"))
- (modules '((guix build utils)))
- (snippet
- ;; The Hackage page and the cabal file linked there for this package
- ;; both list 2.9 as the upper version limit, but the source tarball
- ;; specifies 2.8. Assume the Hackage page is correct.
- '(substitute* "test-framework-quickcheck2.cabal"
- (("QuickCheck >= 2.4 && < 2.8") "QuickCheck >= 2.4 && < 2.9")))))
+ "0vj834337r6jzr3258cv68ly2sv5999mklpsrfngyk51kywsyqyp"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("1" "147ngmfdkskyg7mwsp5w73a4dbx3rp5s38bci3z03kn1m093lxff")))
(inputs
`(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
("ghc-quickcheck" ,ghc-quickcheck)
(define-public ghc-hunit
(package
(name "ghc-hunit")
- (version "1.2.5.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
- "0hcs6qh8bqhip1kkjjnw7ccgcsmawdz5yvffjj5y8zd2vcsavx8a"))))
+ "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.0")
+ (version "2.5.5")
(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
- "0w3awzbljf4hqhxrjrxqa1lfcclg92bhmq641gz2q80vycspapzx"))))
+ "04aidzi91ccr9bygmfkjzshz34z9vh8wvqj4zinx2clxq6r7gqfz"))))
(build-system haskell-build-system)
- (arguments `(#:haddock? #f)) ; Haddock phase fails because there are no
- ; documentation files.
- (inputs `(("ghc-hspec-meta" ,ghc-hspec-meta)))
- (home-page "http://hspec.github.io/")
+ (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
runs Hspec tests.")
(define-public ghc-hspec-core
(package
(name "ghc-hspec-core")
- (version "2.2.0")
+ (version "2.5.5")
(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
- "1wgd55k652jaf81nkvciyqi67ycj7zamr4nd9z1cqf8nr9fc3sa4"))))
+ "1vfrqlpn32s9wiykmkxbnrnd5p56yznw20pf8fwzw78ar4wpz55x"))))
(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)))
- (home-page "http://hspec.github.io/")
+ (home-page "https://hspec.github.io/")
(synopsis "Testing framework for Haskell")
(description "This library exposes internal types and functions that can
be used to extend Hspec's functionality.")
(define-public ghc-hspec-meta
(package
(name "ghc-hspec-meta")
- (version "2.2.0")
+ (version "2.4.6")
(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
- "1fmqmgrzp135cxhmxxbaswkk4bqbpgfml00cmcz0d39n11vzpa5z"))))
+ "0qmvk01n79j6skn79r6zalg2pd0x0nqqn9qn8mhg0pgyzcdnfc9b"))))
(build-system haskell-build-system)
(inputs
`(("ghc-quickcheck" ,ghc-quickcheck)
("ghc-setenv" ,ghc-setenv)
("ghc-random" ,ghc-random)
("ghc-quickcheck-io" ,ghc-quickcheck-io)))
- (home-page "http://hspec.github.io/")
+ (home-page "https://hspec.github.io/")
(synopsis "Version of Hspec to test Hspec itself")
(description "This library provides a stable version of Hspec which is
used to test the in-development version of Hspec.")
(define-public ghc-hspec
(package
(name "ghc-hspec")
- (version "2.2.0")
+ (version "2.5.5")
(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
- "0zqisxznlbszivsgy3irvf566zhcr6ipqqj3x9i7pj5hy913jwqf"))))
+ "1yv4k5b5kkig2q3waj28587sq28wms7wfav5a3lq4dra6jybimfm"))))
(build-system haskell-build-system)
(inputs
`(("ghc-hspec-core" ,ghc-hspec-core)
("ghc-hunit" ,ghc-hunit)
("ghc-stringbuilder" ,ghc-stringbuilder)
("ghc-hspec-meta" ,ghc-hspec-meta)))
- (home-page "http://hspec.github.io/")
+ (home-page "https://hspec.github.io/")
(synopsis "Testing Framework for Haskell")
(description "This library provides the Hspec testing framework for
Haskell, inspired by the Ruby library RSpec.")
(define-public ghc-hspec-contrib
(package
(name "ghc-hspec-contrib")
- (version "0.3.0")
+ (version "0.5.0")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
version ".tar.gz"))
(sha256
(base32
- "006syw8xagfhsx06ws9ywig1qx5lk4cgl7sq6pbid1s64c72mxn4"))))
+ "13579xdqwbsy8k0vxdcvgy932d4p76mij1rzkzbpqbspfn7399yv"))))
(build-system haskell-build-system)
(inputs
`(("ghc-hspec-core" ,ghc-hspec-core)
("ghc-quickcheck" ,ghc-quickcheck)))
(native-inputs
`(("hspec-discover" ,hspec-discover)))
- (home-page "http://hspec.github.io/")
+ (home-page "https://hspec.github.io/")
(synopsis "Contributed functionality for Hspec")
(description
"This package provides contributed Hspec extensions.")
(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")
(description "This library provides catchy combinators for HUnit, see
@uref{https://github.com/sol/hspec-expectations#readme, the README}.")
(license license:expat)))
+
+(define-public ghc-nanospec
+ (package
+ (name "ghc-nanospec")
+ (version "0.2.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "nanospec/nanospec-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1rcmhl9bhyfvanalnf1r86wkx6rq6wdvagnw1h011jcnnb1cq56g"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("ghc-silently" ,ghc-silently)))
+ (home-page "https://github.com/hspec/nanospec#readme")
+ (synopsis "Lightweight implementation of a subset of Hspec's API")
+ (description
+ "Nanospec is a lightweight implementation of a subset of Hspec's API with
+minimal dependencies.")
+ (license license:expat)))
+
+(define-public ghc-crypto-cipher-tests
+ (package
+ (name "ghc-crypto-cipher-tests")
+ (version "0.0.11")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "crypto-cipher-tests-" version "/"
+ "crypto-cipher-tests-" version ".tar.gz"))
+ (sha256
+ (base32
+ "19wqignlq90qwpam01hnmmrxaxh5lkax9l1l6rlbi4a07nvp1dnz"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ("ghc-byteable" ,ghc-byteable)
+ ("ghc-securemem" ,ghc-securemem)
+ ("ghc-crypto-cipher-types" ,ghc-crypto-cipher-types)))
+ (home-page "https://github.com/vincenthz/hs-crypto-cipher")
+ (synopsis "Generic cryptography cipher tests for Haskell")
+ (description " This Haskell package contains generic tests for
+cryptographic ciphers, and is used by the test runners of various Haskell
+implementations of cryptographic ciphers.")
+ (license license:bsd-3)))
HCoop / jackhill / guix / guix.git / blobdiff