;;; Copyright © 2015 Eric Bavier <bavier@member.fsf.org>
;;; Copyright © 2015 Federico Beffa <beffa@fbengineering.ch>
;;; Copyright © 2015, 2016, 2017, 2018 Ricardo Wurmus <rekado@elephly.net>
-;;; Copyright © 2016 ng0 <ng0@n0.is>
+;;; Copyright © 2016 Nikita <nikita@n0.is>
;;; Copyright © 2016 David Craven <david@craven.ch>
;;; Copyright © 2017 Danny Milosavljevic <dannym@scratchpost.org>
;;; Copyright © 2017 rsiddharth <s@ricketyspace.net>
;;; Copyright © 2017, 2018 Tobias Geerinckx-Rice <me@tobias.gr>
;;; Copyright © 2018 Tonton <tonton@riseup.net>
;;; Copyright © 2018 Arun Isaac <arunisaac@systemreboot.net>
+;;; Copyright © 2019 Timothy Sample <samplet@ngyro.com>
+;;; Copyright © 2020 John Soo <jsoo1@asu.edu>
+;;; Copyright © 2020 Carlo Holl <carloholl@gmail.com>
;;;
;;; This file is part of GNU Guix.
;;;
(define-public ghc-tasty-ant-xml
(package
(name "ghc-tasty-ant-xml")
- (version "1.1.4")
+ (version "1.1.6")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "0v0gsb90kh6hwlgxbclzawsskywc6yf7n8xhiifia97l4y0yx2m8"))))
+ "13qqpl1prr9dda87dp45mqybay24n8rhxxgvpc9j34kh72g8j5qw"))))
(build-system haskell-build-system)
(inputs
`(("ghc-generic-deriving" ,ghc-generic-deriving)
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")
tasty.")
(license license:expat)))
+(define-public ghc-tasty-lua
+ (package
+ (name "ghc-tasty-lua")
+ (version "0.2.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "tasty-lua/tasty-lua-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0xlj36rrhkx312h7smx6ay20rhlhxvw2ma2ckdnzv1pvmdn6p5qx"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-file-embed" ,ghc-file-embed)
+ ("ghc-hslua" ,ghc-hslua)
+ ("ghc-tasty" ,ghc-tasty)))
+ (native-inputs
+ `(("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+ (home-page "https://github.com/hslua/tasty-lua")
+ (synopsis "Write tests in Lua, integrate into tasty")
+ (description "This package gives users the ability to define tasty tests
+from Lua.")
+ (license license:expat)))
+
(define-public ghc-tasty-th
(package
(name "ghc-tasty-th")
(define-public ghc-tasty-rerun
(package
(name "ghc-tasty-rerun")
- (version "1.1.12")
+ (version "1.1.14")
(source (origin
(method url-fetch)
(uri (string-append
"tasty-rerun-" version ".tar.gz"))
(sha256
(base32
- "05lp4zy6lwd916snq6hs43848n62j9vdfl3s8sfivqydrax0vvd8"))))
+ "0s0zj8ds4g1w2cjzm2lh25ivg962jigqdrbj08v3dbz64lx4mlzr"))))
(build-system haskell-build-system)
(inputs
`(("ghc-optparse-applicative" ,ghc-optparse-applicative)
(inputs
`(("ghc-tagged" ,ghc-tagged)
("ghc-tasty" ,ghc-tasty)))
- (home-page "http://github.com/nomeata/tasty-expected-failure")
+ (home-page "https://github.com/nomeata/tasty-expected-failure")
(synopsis "Mark tasty tests as failure expected")
(description
"With the function @code{Test.Tasty.ExpectedFailure.expectFail} in the
(define-public ghc-quickcheck-instances
(package
(name "ghc-quickcheck-instances")
- (version "0.3.18")
+ (version "0.3.22")
(source
(origin
(method url-fetch)
version ".tar.gz"))
(sha256
(base32
- "1bh1pzz5fdcqvzdcirqxna6fnjms02min5md716299g5niz46w55"))))
+ "14asr9r7da3w7p4hjj51w2yb002nz8x0np8hdz9z4yjvi60vyrax"))))
(build-system haskell-build-system)
(arguments
`(#:cabal-revision
- ("1" "1sngfq3v71bvgjsl8cj5kh65m3fziwy8dkvwjzs0kxfrzr87faly")))
+ ("2" "1ia5fjhpg7rz793552v88gv2iqx7hl9mi2g09m0llasy1cpzc9jr")))
(inputs
`(("ghc-quickcheck" ,ghc-quickcheck)
("ghc-base-compat" ,ghc-base-compat)
("ghc-old-time" ,ghc-old-time)
("ghc-scientific" ,ghc-scientific)
("ghc-tagged" ,ghc-tagged)
+ ("ghc-time-compat" ,ghc-time-compat)
("ghc-transformers-compat" ,ghc-transformers-compat)
("ghc-unordered-containers" ,ghc-unordered-containers)
("ghc-uuid-types" ,ghc-uuid-types)
(package
(name "ghc-quickcheck")
(version "2.13.2")
- (outputs '("out" "doc"))
+ (outputs '("out" "static" "doc"))
(source
(origin
(method url-fetch)
(base32
"0426j43af8v3qmdjjqxivazsvr3a2brac8yw09vpgpjkb2m0nmkv"))))
(build-system haskell-build-system)
- (arguments
- `(#: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)))
+ ("ghc-splitmix" ,ghc-splitmix-bootstrap)))
(home-page "https://github.com/nick8325/quickcheck")
(synopsis "Automatic testing of Haskell programs")
(description
(package
(name "ghc-hunit")
(version "1.6.0.0")
- (outputs '("out" "doc"))
+ (outputs '("out" "static" "doc"))
(source
(origin
(method url-fetch)
(define-public ghc-hspec
(package
(name "ghc-hspec")
- (version "2.5.5")
+ (version "2.7.1")
(source
(origin
(method url-fetch)
"hspec-" version ".tar.gz"))
(sha256
(base32
- "1yv4k5b5kkig2q3waj28587sq28wms7wfav5a3lq4dra6jybimfm"))))
+ "1x8rcr7j1azcaw0fg1xzp8j0gr4ias36z09aj24i4xp8pnyfp341"))))
(build-system haskell-build-system)
+ (outputs '("out" "static" "doc"))
(inputs
`(("ghc-hspec-core" ,ghc-hspec-core)
("hspec-discover" ,hspec-discover)
(define-public ghc-hspec-contrib
(package
(name "ghc-hspec-contrib")
- (version "0.5.0")
+ (version "0.5.1")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
version ".tar.gz"))
(sha256
(base32
- "13579xdqwbsy8k0vxdcvgy932d4p76mij1rzkzbpqbspfn7399yv"))))
+ "0hhzxaa3fxz5mk5qcsrnfr98a7bn3szx2ydgr0x9mbqmm1jg06rc"))))
(build-system haskell-build-system)
(inputs
`(("ghc-hspec-core" ,ghc-hspec-core)
(define-public ghc-hedgehog
(package
(name "ghc-hedgehog")
- (version "0.6.1")
+ (version "1.0.1")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "0xz10ycdm5vk9nrcym1fi83k19frfwqz18bz8bnpzwvaj0j41yfj"))))
+ "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)
configuration. This library provides the common bits for writing custom
@file{Setup.hs} files.")
(license license:bsd-3)))
+
+(define-public ghc-testing-type-modifiers
+ (package
+ (name "ghc-testing-type-modifiers")
+ (version "0.1.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "testing-type-modifiers/testing-type-modifiers-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1wh2n95n39ivv6kbqn42vbzrj8zagsmk6f2al2qj40bg5kgdl2q5"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/testing-type-modifiers")
+ (synopsis "Data type modifiers for property based testing")
+ (description "Property based testing libraries such as QuickCheck tend to
+include type modifiers. Most of them are used to quantify over subsets of a
+type. This library is intended to supply these modifiers to be used by
+testing libraries, in an effort to make properties more portable between
+testing frameworks.")
+ (license license:unlicense)))
+
+(define-public ghc-testing-feat
+ (package
+ (name "ghc-testing-feat")
+ (version "1.1.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "testing-feat/testing-feat-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1v2qzzpf1s008g7q6q67glf7vbm1pkpq4rc3ii74f4g6vhfx610r"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-size-based" ,ghc-size-based)
+ ("ghc-testing-type-modifiers" ,ghc-testing-type-modifiers)
+ ("ghc-semigroups" ,ghc-semigroups)))
+ (home-page "https://github.com/JonasDuregard/testing-feat")
+ (synopsis "Functional Enumeration of Algebraic Types")
+ (description "Feat (Functional Enumeration of Algebraic Types)
+provides enumerations as functions from natural numbers to
+values (similar to @code{toEnum} but for any algebraic data type). This
+can be used for SmallCheck-style systematic testing, QuickCheck-style
+random testing, and hybrids of the two.")
+ (license license:bsd-3)))
+
+(define-public ghc-inspection-testing
+ (package
+ (name "ghc-inspection-testing")
+ (version "0.4.2.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/inspection-testing/"
+ "inspection-testing-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1bppz99p6ix6hah8lbr9mapl2zxgmkg9i7h6hk8wq6zf54hwz3yp"))))
+ (build-system haskell-build-system)
+ (home-page
+ "https://github.com/nomeata/inspection-testing")
+ (synopsis "GHC plugin to do inspection testing")
+ (description
+ "Some carefully crafted libraries make promises to their users beyond
+functionality and performance.
+
+Examples are: Fusion libraries promise intermediate data structures to be
+eliminated. Generic programming libraries promise that the generic
+implementation is identical to the hand-written one. Some libraries may
+promise allocation-free or branch-free code.
+
+Conventionally, the modus operandi in all these cases is that the library
+author manually inspects the (intermediate or final) code produced by the
+compiler. This is not only tedious, but makes it very likely that some change,
+either in the library itself or the surrounding eco-system, breaks the
+library's promised without anyone noticing.
+
+This package provides a disciplined way of specifying such properties, and
+have them checked by the compiler. This way, this checking can be part of the
+regular development cycle and regressions caught early.
+
+See the documentation in \"Test.Inspection\" or the project webpage for more
+examples and more information.")
+ (license license:expat)))
+
+(define-public ghc-easytest
+ (package
+ (name "ghc-easytest")
+ (version "0.2.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/easytest/easytest-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0gdyawzlw6d15yz7ji599xjgfr0g7l1iq11ffr4aw3j6g3dc6m8i"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-async" ,ghc-async)
+ ("ghc-random" ,ghc-random)
+ ("ghc-call-stack" ,ghc-call-stack)))
+ (home-page "https://github.com/joelburget/easytest")
+ (synopsis "Testing library for Haskell")
+ (description "EasyTest is a testing toolkit, meant to replace most uses of
+QuickCheck, SmallCheck, HUnit, and frameworks like Tasty, etc. Tests can be
+written with ordinary Haskell code, with control flow explicit and under
+programmer control.")
+ (license license:expat)))