;;; 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 Nils Gillmann <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, 2018 Tobias Geerinckx-Rice <me@tobias.gr>
+;;; Copyright © 2018 Tonton <tonton@riseup.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-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-golden
(package
(name "ghc-tasty-golden")
- (version "2.3.0.2")
+ (version "2.3.1.1")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "0n7nll1sx75n3lffwhgnjrxdn0jz1g0921z9mj193fxqw0wz8axh"))))
+ "0pcf5hsyp5mmbqn7krdm49jxpkjm6rb4j83j28f76h7q55dzm1wy"))))
(build-system haskell-build-system)
(inputs
`(("ghc-temporary" ,ghc-temporary)
"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 "0.11.0.4")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "1chapivmmwsb1ghwagvdm80bfj3hdk75m94z4p212ng2i4ghpjkx"))))
+ "05pxjzgbgjdn7477xry0ssjrnmnsydqiq6nm6ck8n2da1baliqp0"))))
(build-system haskell-build-system)
(inputs
`(("ghc-stm" ,ghc-stm)
("ghc-mtl" ,ghc-mtl)
("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)
(define-public ghc-tasty-rerun
(package
(name "ghc-tasty-rerun")
- (version "1.1.6")
+ (version "1.1.8")
(source (origin
(method url-fetch)
(uri (string-append
"tasty-rerun-" version ".tar.gz"))
(sha256
(base32
- "0ycxg7whabgcxyzy6gr536x8ykzx45whh1wrbsc7c58zi862fczd"))))
+ "0yg8cicfn3qaazvp4rbanzy3dyk95k3y1kkd4bykvkl9v4076788"))))
(build-system haskell-build-system)
(inputs
`(("ghc-mtl" ,ghc-mtl)
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.0.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "tasty-expected-failure/tasty-expected-failure-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0r555f18d2gj96pjyc13chn1nxaxl81am4xgip3mvvjhw8s5mva1"))))
+ (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.16.1")
(source
(origin
(method url-fetch)
version ".tar.gz"))
(sha256
(base32
- "1wwvkzpams7i0j7nk5qj8vvhj8x5zcbgbgrpczszgvshva4bkmfx"))))
+ "01v5bs7r9yvhkvb4yc9bqnacy8r6cy2gr9lnmwx40n5apgi0gcbz"))))
(build-system haskell-build-system)
(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.10.1")
(outputs '("out" "doc"))
(source
(origin
".tar.gz"))
(sha256
(base32
- "1ai6k5v0bibaxq8xffcblc6rwmmk6gf8vjyd9p2h3y6vwbhlvilq"))))
+ "1rfmns3lj3hl93k1jws85ajkkw7z9ll8cw292n9m7zald1w5dfqx"))))
(build-system haskell-build-system)
(arguments
`(#:tests? #f ; FIXME: currently missing libraries used for tests.
#:configure-flags '("-f base4")))
(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-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")
(base32
"0wxjgdvb1c4ykazw774zlx86550848wbsvgjgcrdzcgbb9m650vq"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:configure-flags (list "--allow-newer=time")))
(native-inputs
`(("ghc-hunit" ,ghc-hunit)
("ghc-quickcheck" ,ghc-quickcheck)))
(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)
(inputs
`(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
(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)
(inputs
`(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
(define-public ghc-hunit
(package
(name "ghc-hunit")
- (version "1.2.5.2")
+ (version "1.3.1.2")
(outputs '("out" "doc"))
(source
(origin
".tar.gz"))
(sha256
(base32
- "0hcs6qh8bqhip1kkjjnw7ccgcsmawdz5yvffjj5y8zd2vcsavx8a"))))
+ "10akdh4fl615rrshxi3m5gf414il1q42z4zqyb6q4jasmscvzpms"))))
(build-system haskell-build-system)
(home-page "http://hunit.sourceforge.net/")
(synopsis "Unit testing framework for Haskell")
(define-public hspec-discover
(package
(name "hspec-discover")
- (version "2.2.0")
+ (version "2.2.4")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "0w3awzbljf4hqhxrjrxqa1lfcclg92bhmq641gz2q80vycspapzx"))))
+ "1bz7wb8v0bx1amiz4bpj34xq97d1ia29n3f654wcrh6lacydp3dv"))))
(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/")
+ (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.2.4")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "1wgd55k652jaf81nkvciyqi67ycj7zamr4nd9z1cqf8nr9fc3sa4"))))
+ "0x845ngfl6vf65fnpb5mm3wj0ql45pz11bnm0x4gxc4ybd9c52ij"))))
(build-system haskell-build-system)
(arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
(inputs
("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.2.1")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "1fmqmgrzp135cxhmxxbaswkk4bqbpgfml00cmcz0d39n11vzpa5z"))))
+ "1m1pkrxiglxzwv8gdj5jr1bdbhxvvg6sbl9m61w4565d7k1m8yxa"))))
(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.2.4")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "0zqisxznlbszivsgy3irvf566zhcr6ipqqj3x9i7pj5hy913jwqf"))))
+ "1cf90gqvg1iknja6ymxqxyabpahcxni3blqllh81ywbir3whljvj"))))
(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.")
("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.")
(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-mtl" ,ghc-mtl)
+ ("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