Hello community, here is the log from the commit of package ghc-tasty-dejafu for openSUSE:Factory checked in at 2017-08-31 21:00:14 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/ghc-tasty-dejafu (Old) and /work/SRC/openSUSE:Factory/.ghc-tasty-dejafu.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "ghc-tasty-dejafu" Thu Aug 31 21:00:14 2017 rev:3 rq:513509 version:0.6.0.0 Changes: -------- --- /work/SRC/openSUSE:Factory/ghc-tasty-dejafu/ghc-tasty-dejafu.changes 2017-04-18 13:51:00.393305099 +0200 +++ /work/SRC/openSUSE:Factory/.ghc-tasty-dejafu.new/ghc-tasty-dejafu.changes 2017-08-31 21:00:15.543419287 +0200 @@ -1,0 +2,5 @@ +Thu Jul 27 14:07:02 UTC 2017 - psimons@suse.com + +- Update to version 0.6.0.0. + +------------------------------------------------------------------- Old: ---- tasty-dejafu-0.3.0.2.tar.gz New: ---- tasty-dejafu-0.6.0.0.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ ghc-tasty-dejafu.spec ++++++ --- /var/tmp/diff_new_pack.ImStsy/_old 2017-08-31 21:00:16.487286671 +0200 +++ /var/tmp/diff_new_pack.ImStsy/_new 2017-08-31 21:00:16.487286671 +0200 @@ -18,7 +18,7 @@ %global pkg_name tasty-dejafu Name: ghc-%{pkg_name} -Version: 0.3.0.2 +Version: 0.6.0.0 Release: 0 Summary: Deja Fu support for the Tasty test framework License: MIT @@ -27,6 +27,7 @@ Source0: https://hackage.haskell.org/package/%{pkg_name}-%{version}/%{pkg_name}-%{version}.tar.gz BuildRequires: ghc-Cabal-devel BuildRequires: ghc-dejafu-devel +BuildRequires: ghc-random-devel BuildRequires: ghc-rpm-macros BuildRequires: ghc-tagged-devel BuildRequires: ghc-tasty-devel @@ -38,8 +39,6 @@ tasty>. This lets you easily incorporate concurrency testing into your existing test suites. -See the <https://github.com/barrucadu/dejafu README> for more details. - %package devel Summary: Haskell %{pkg_name} library development files Group: Development/Libraries/Other @@ -72,5 +71,6 @@ %files devel -f %{name}-devel.files %defattr(-,root,root,-) +%doc CHANGELOG.markdown README.markdown %changelog ++++++ tasty-dejafu-0.3.0.2.tar.gz -> tasty-dejafu-0.6.0.0.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/tasty-dejafu-0.3.0.2/CHANGELOG.markdown new/tasty-dejafu-0.6.0.0/CHANGELOG.markdown --- old/tasty-dejafu-0.3.0.2/CHANGELOG.markdown 1970-01-01 01:00:00.000000000 +0100 +++ new/tasty-dejafu-0.6.0.0/CHANGELOG.markdown 2017-06-07 18:08:42.000000000 +0200 @@ -0,0 +1,163 @@ +Release Notes +============= + +All notable changes to this project will be documented in this file. + +This project is versioned according to the [Package Versioning Policy](https://pvp.haskell.org), the +*de facto* standard Haskell versioning scheme. + + +0.6.0.0 [2017-04-08] (git tag: [tasty-dejafu-0.6.0.0][]) +------- + +https://hackage.haskell.org/package/tasty-dejafu-0.6.0.0 + +### Test.Tasty.DejaFu + +- The refinement property testing functionality of dejafu is exposed in the new `testProperty` + function, and re-exported values. +- Due to changes in dejafu, the `Way` type is now abstract and exposes smart constructor functions: + - `systematically`, corresponding to the old `Systematically`. + - `randomly`, corresponding to the old `Randomly`. + - `uniformly`, a new uniform random (as opposed to weighted random) scheduler. + - `swarmy`, corresponding to the old `Randomly` and specifying how many executions to use the + same weights for. +- The `defaultWay`, `defaultMemType`, and `defaultBounds` values are all now re-exported. + +### Miscellaneous + +- Only dejafu 0.7 is supported. + +[tasty-dejafu-0.6.0.0]: https://github.com/barrucadu/dejafu/releases/tag/tasty-dejafu-0.6.0.0 + + +--------------------------------------------------------------------------------------------------- + + +0.5.0.0 [2017-04-08] (git tag: [tasty-dejafu-0.5.0.0][]) +------- + +https://hackage.haskell.org/package/tasty-dejafu-0.5.0.0 + +### Test.Tasty.DejaFu + +- Due to changes in dejafu, the `Way` type no longer takes a parameter; it is now a GADT. + +### Miscellaneous + +- There is now a changelog. +- Every definition and instance now has a Haddock "@since" annotation. +- Only dejafu 0.6 is supported. + +[tasty-dejafu-0.5.0.0]: https://github.com/barrucadu/dejafu/releases/tag/tasty-dejafu-0.5.0.0 + + +--------------------------------------------------------------------------------------------------- + + +0.4.0.0 [2017-02-21] (git tag: [tasty-dejafu-0.4.0.0][]) +------- + +https://hackage.haskell.org/package/tasty-dejafu-0.4.0.0 + +### Test.Tasty.DejaFu + +- All the functions which did take a `Bounds` now take a `Way` instead and support random scheduling + as well. +- The `Way` type from dejafu is now re-exported. +- The `IsOption` instance (and so corresponding command-line argument) for `Bounds` is gone. +- A new `IsOption` instance for `Way` (and so corresponding command-line argument): + - "systematically": systematic testing with the default bounds. + - "randomly": 100 executions with a fixed random seed. + +### Miscellaneous + +- The minimum supported version of dejafu has been increased to 0.5 (from 0.2) + +[tasty-dejafu-0.4.0.0]: https://github.com/barrucadu/dejafu/releases/tag/tasty-dejafu-0.4.0.0 + + +--------------------------------------------------------------------------------------------------- + + +0.3.0.2 [2016-09-10] (git tag: [tasty-dejafu-0.3.0.2][]) +------- + +https://hackage.haskell.org/package/tasty-dejafu-0.3.0.2 + +### Miscellaneous + +- Now supports concurrency 1.0.0.0 and dejafu 0.4.0.0 + +[tasty-dejafu-0.3.0.2]: https://github.com/barrucadu/dejafu/releases/tag/tasty-dejafu-0.3.0.2 + + +--------------------------------------------------------------------------------------------------- + + +0.3.0.1 [2016-05-26] (git tag: [tasty-dejafu-0.3.0.1][]) +------- + +https://hackage.haskell.org/package/tasty-dejafu-0.3.0.1 + +### Miscellaneous + +- Now supports GHC 8. + +[tasty-dejafu-0.3.0.1]: https://github.com/barrucadu/dejafu/releases/tag/tasty-dejafu-0.3.0.1 + + +--------------------------------------------------------------------------------------------------- + + +0.3.0.0 [2016-04-28] (git tag: [tasty-dejafu-0.3.0.0][]) +------- + +https://hackage.haskell.org/package/tasty-dejafu-0.3.0.0 + +### Test.Tasty.DejaFu + +- New `IsTest` instances for `ConcST t (Maybe String)` and `ConcIO (Maybe String)`, with a `Just + String` result being a test failure with an error message. +- The `Bounds` type from dejafu is now re-exported. +- New `IsOption` instances for `Bounds` and `MemType`. +- New command-line parameter to set the `MemType` parameter: + - "sc": sequential consistency. + - "tso": total store order. + - "pso": partial store order. + +### Miscellaneous + +- Now supports dejafu 0.2 (again). + +[tasty-dejafu-0.3.0.0]: https://github.com/barrucadu/dejafu/releases/tag/tasty-dejafu-0.3.0.0 + + +--------------------------------------------------------------------------------------------------- + + +0.1.1.0 [2016-04-03] (git tag: [tasty-dejafu-0.1.1.0][]) +------- + +**This version was never pushed to hackage, whoops!** + +**This version was misnumbered! It should have been 0.2.1.0!** + +### Miscellaneous + +- Now supports dejafu 0.3, but drops support for dejafu 0.2. + +[tasty-dejafu-0.1.1.0]: https://github.com/barrucadu/dejafu/releases/tag/tasty-dejafu-0.1.1.0 + + +--------------------------------------------------------------------------------------------------- + + +0.2.0.0 [2015-12-01] (git tag: [0.2.0.0][]) +------- + +https://hackage.haskell.org/package/tasty-dejafu-0.2.0.0 + +Initial release. Go read the API docs. + +[0.2.0.0]: https://github.com/barrucadu/dejafu/releases/tag/0.2.0.0 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/tasty-dejafu-0.3.0.2/README.markdown new/tasty-dejafu-0.6.0.0/README.markdown --- old/tasty-dejafu-0.3.0.2/README.markdown 1970-01-01 01:00:00.000000000 +0100 +++ new/tasty-dejafu-0.6.0.0/README.markdown 2016-05-26 17:52:10.000000000 +0200 @@ -0,0 +1,21 @@ +tasty-dejafu +============ + +Integration between the [dejafu][] library for concurrency testing and +[tasty][]. This lets you easily incorporate concurrency testing into +your existing test suites. + +The documentation of the latest developmental version is +[available online][docs]. + +Contributing +------------ + +Bug reports, pull requests, and comments are very welcome! + +Feel free to contact me on GitHub, through IRC (#haskell on freenode), +or email (mike@barrucadu.co.uk). + +[docs]: https://docs.barrucadu.co.uk/tasty-dejafu +[dejafu]: https://hackage.haskell.org/package/dejafu +[tasty]: https://hackage.haskell.org/package/tasty diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/tasty-dejafu-0.3.0.2/Setup.hs new/tasty-dejafu-0.6.0.0/Setup.hs --- old/tasty-dejafu-0.3.0.2/Setup.hs 2016-04-13 01:32:08.000000000 +0200 +++ new/tasty-dejafu-0.6.0.0/Setup.hs 2017-04-08 06:43:07.000000000 +0200 @@ -1,2 +1,2 @@ -import Distribution.Simple +import Distribution.Simple main = defaultMain diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/tasty-dejafu-0.3.0.2/Test/Tasty/DejaFu.hs new/tasty-dejafu-0.6.0.0/Test/Tasty/DejaFu.hs --- old/tasty-dejafu-0.3.0.2/Test/Tasty/DejaFu.hs 2016-08-28 15:57:25.000000000 +0200 +++ new/tasty-dejafu-0.6.0.0/Test/Tasty/DejaFu.hs 2017-06-07 18:08:50.000000000 +0200 @@ -1,4 +1,5 @@ {-# LANGUAGE CPP #-} +{-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE RankNTypes #-} @@ -16,7 +17,7 @@ -- License : MIT -- Maintainer : Michael Walker <mike@barrucadu.co.uk> -- Stability : stable --- Portability : CPP, FlexibleInstances, GADTs, ImpredicativeTypes, RankNTypes, TypeSynonymInstances +-- Portability : CPP, FlexibleContexts, FlexibleInstances, GADTs, ImpredicativeTypes, RankNTypes, TypeSynonymInstances -- -- This module allows using Deja Fu predicates with Tasty to test the -- behaviour of concurrent systems. @@ -37,90 +38,102 @@ , testDejafu , testDejafus - , testAuto' - , testDejafu' - , testDejafus' + , testAutoWay + , testDejafuWay + , testDejafusWay -- ** @IO@ , testAutoIO , testDejafuIO , testDejafusIO - , testAutoIO' - , testDejafuIO' - , testDejafusIO' - - -- * Re-exports + , testAutoWayIO + , testDejafuWayIO + , testDejafusWayIO + + -- ** Re-exports + , Way + , defaultWay + , systematically + , randomly + , uniformly + , swarmy , Bounds(..) + , defaultBounds , MemType(..) + , defaultMemType + + -- * Refinement property testing + , testProperty + + -- ** Re-exports + , R.Sig(..) + , R.RefinementProperty + , R.Testable(..) + , R.Listable(..) + , R.expectFailure + , R.refines, (R.=>=) + , R.strictlyRefines, (R.->-) + , R.equivalentTo, (R.===) ) where -import Control.Monad.ST (runST) -import Data.Char (toUpper) -import Data.List (intercalate, intersperse) -import Data.Proxy (Proxy(..)) -import Data.Tagged (Tagged(..)) -import Data.Typeable (Typeable) -import Test.DejaFu -import qualified Test.DejaFu.SCT as SCT -import Test.Tasty (TestName, TestTree, testGroup) -import Test.Tasty.Options (OptionDescription(..), IsOption(..), lookupOption) -import Test.Tasty.Providers (IsTest(..), singleTest, testPassed, testFailed) - -#if MIN_VERSION_dejafu(0,4,0) -import qualified Test.DejaFu.Conc as Conc -#else -import qualified Test.DejaFu.Deterministic as Conc -#endif +import Control.Monad.ST (runST) +import Data.Char (toUpper) +import qualified Data.Foldable as F +import Data.List (intercalate, intersperse) +import Data.Proxy (Proxy(..)) +import Data.Tagged (Tagged(..)) +import Data.Typeable (Typeable) +import System.Random (mkStdGen) +import Test.DejaFu hiding (Testable(..)) +import qualified Test.DejaFu.Conc as Conc +import qualified Test.DejaFu.Refinement as R +import qualified Test.DejaFu.SCT as SCT +import Test.Tasty (TestName, TestTree, testGroup) +import Test.Tasty.Options (IsOption(..), OptionDescription(..), + lookupOption) +import Test.Tasty.Providers (IsTest(..), singleTest, testFailed, + testPassed) -- Can't put the necessary forall in the @IsTest ConcST t@ -- instance :( -import Unsafe.Coerce (unsafeCoerce) +import Unsafe.Coerce (unsafeCoerce) -#if MIN_VERSION_dejafu(0,3,0) -type Trc = Conc.Trace Conc.ThreadId Conc.ThreadAction Conc.Lookahead -#else -type Trc = Conc.Trace -#endif +runSCTst :: Way -> MemType -> (forall t. Conc.ConcST t a) -> [(Either Failure a, Conc.Trace)] +runSCTst way memtype conc = runST (SCT.runSCT way memtype conc) -sctBoundST :: MemType -> Bounds -> (forall t. Conc.ConcST t a) -> [(Either Failure a, Trc)] -sctBoundIO :: MemType -> Bounds -> Conc.ConcIO a -> IO [(Either Failure a, Trc)] - -#if MIN_VERSION_dejafu(0,4,0) -sctBoundST memtype cb conc = runST (SCT.sctBound memtype cb conc) -sctBoundIO = SCT.sctBound -#else -sctBoundST = SCT.sctBound -sctBoundIO = SCT.sctBoundIO -#endif +runSCTio :: Way -> MemType -> Conc.ConcIO a -> IO [(Either Failure a, Conc.Trace)] +runSCTio = SCT.runSCT -------------------------------------------------------------------------------- --- Unit testing +-- Tasty-style unit testing +-- | @since 0.3.0.0 instance Typeable t => IsTest (Conc.ConcST t (Maybe String)) where testOptions = Tagged concOptions run options conc callback = do let memtype = lookupOption options :: MemType - let bounds = lookupOption options :: Bounds - let sctBound' :: Conc.ConcST t (Maybe String) -> [(Either Failure (Maybe String), Trc)] - sctBound' = unsafeCoerce $ sctBoundST memtype bounds - let traces = sctBound' conc + let way = lookupOption options :: Way + let runSCTst' :: Conc.ConcST t (Maybe String) -> [(Either Failure (Maybe String), Conc.Trace)] + runSCTst' = unsafeCoerce $ runSCTst way memtype + let traces = runSCTst' conc run options (ConcTest traces assertableP) callback +-- | @since 0.3.0.0 instance IsTest (Conc.ConcIO (Maybe String)) where testOptions = Tagged concOptions run options conc callback = do let memtype = lookupOption options - let bounds = lookupOption options - let traces = sctBoundIO memtype bounds conc + let way = lookupOption options + let traces = runSCTio way memtype conc run options (ConcIOTest traces assertableP) callback concOptions :: [OptionDescription] concOptions = - [ Option (Proxy :: Proxy Bounds) - , Option (Proxy :: Proxy MemType) + [ Option (Proxy :: Proxy MemType) + , Option (Proxy :: Proxy Way) ] assertableP :: Predicate (Maybe String) @@ -128,54 +141,72 @@ Right (Just _) -> False _ -> True -instance IsOption Bounds where - defaultValue = defaultBounds - parseValue = const Nothing - optionName = Tagged "schedule-bounds" - optionHelp = Tagged "The schedule bounds to use. This cannot be set on the command line." - +-- | @since 0.3.0.0 instance IsOption MemType where defaultValue = defaultMemType - parseValue str = shortName (map toUpper str) where + parseValue = shortName . map toUpper where shortName "SC" = Just SequentialConsistency shortName "TSO" = Just TotalStoreOrder shortName "PSO" = Just PartialStoreOrder shortName _ = Nothing optionName = Tagged "memory-model" - optionHelp = Tagged "The memory model to use. This should be one of \"SC\", \"TSO\", or \"PSO\"." + optionHelp = Tagged "The memory model to use. This should be one of \"sc\", \"tso\", or \"pso\"." + +-- | @since 0.5.0.0 +instance IsOption Way where + defaultValue = defaultWay + parseValue = shortName . map toUpper where + shortName "SYSTEMATICALLY" = Just (systematically defaultBounds) + shortName "RANDOMLY" = Just (randomly (mkStdGen 42) 100) + shortName _ = Nothing + optionName = Tagged "way" + optionHelp = Tagged "The execution method to use. This should be one of \"systematically\" or \"randomly\"." + -------------------------------------------------------------------------------- --- Property testing +-- DejaFu-style unit testing -- | Automatically test a computation. In particular, look for -- deadlocks, uncaught exceptions, and multiple return values. --- +-- -- This uses the 'Conc' monad for testing, which is an instance of -- 'MonadConc'. If you need to test something which also uses -- 'MonadIO', use 'testAutoIO'. +-- +-- @since 0.2.0.0 testAuto :: (Eq a, Show a) => (forall t. Conc.ConcST t a) -- ^ The computation to test -> TestTree -testAuto = testAuto' defaultMemType +testAuto = testAutoWay defaultWay defaultMemType -- | Variant of 'testAuto' which tests a computation under a given --- memory model. -testAuto' :: (Eq a, Show a) - => MemType +-- execution way and memory model. +-- +-- @since 0.5.0.0 +testAutoWay :: (Eq a, Show a) + => Way + -- ^ How to execute the concurrent program. + -> MemType -- ^ The memory model to use for non-synchronised @CRef@ operations. -> (forall t. Conc.ConcST t a) -- ^ The computation to test -> TestTree -testAuto' memtype conc = testDejafus' memtype defaultBounds conc autocheckCases +testAutoWay way memtype conc = testDejafusWay way memtype conc autocheckCases -- | Variant of 'testAuto' for computations which do 'IO'. +-- +-- @since 0.2.0.0 testAutoIO :: (Eq a, Show a) => Conc.ConcIO a -> TestTree -testAutoIO = testAutoIO' defaultMemType +testAutoIO = testAutoWayIO defaultWay defaultMemType --- | Variant of 'testAuto'' for computations which do 'IO'. -testAutoIO' :: (Eq a, Show a) => MemType -> Conc.ConcIO a -> TestTree -testAutoIO' memtype concio = testDejafusIO' memtype defaultBounds concio autocheckCases +-- | Variant of 'testAutoWay' for computations which do 'IO'. +-- +-- @since 0.5.0.0 +testAutoWayIO :: (Eq a, Show a) + => Way -> MemType -> Conc.ConcIO a -> TestTree +testAutoWayIO way memtype concio = + testDejafusWayIO way memtype concio autocheckCases -- | Predicates for the various autocheck functions. autocheckCases :: Eq a => [(TestName, Predicate a)] @@ -186,6 +217,8 @@ ] -- | Check that a predicate holds. +-- +-- @since 0.2.0.0 testDejafu :: Show a => (forall t. Conc.ConcST t a) -- ^ The computation to test @@ -194,15 +227,17 @@ -> Predicate a -- ^ The predicate to check -> TestTree -testDejafu = testDejafu' defaultMemType defaultBounds +testDejafu = testDejafuWay defaultWay defaultMemType --- | Variant of 'testDejafu' which takes a memory model and --- pre-emption bound. -testDejafu' :: Show a - => MemType +-- | Variant of 'testDejafu' which takes a way to execute the program +-- and a memory model. +-- +-- @since 0.5.0.0 +testDejafuWay :: Show a + => Way + -- ^ How to execute the concurrent program. + -> MemType -- ^ The memory model to use for non-synchronised @CRef@ operations. - -> Bounds - -- ^ The schedule bounds. -> (forall t. Conc.ConcST t a) -- ^ The computation to test -> TestName @@ -210,89 +245,143 @@ -> Predicate a -- ^ The predicate to check -> TestTree -testDejafu' memtype cb conc name p = testDejafus' memtype cb conc [(name, p)] +testDejafuWay way memtype conc name p = + testDejafusWay way memtype conc [(name, p)] -- | Variant of 'testDejafu' which takes a collection of predicates to -- test. This will share work between the predicates, rather than -- running the concurrent computation many times for each predicate. +-- +-- @since 0.2.0.0 testDejafus :: Show a => (forall t. Conc.ConcST t a) -- ^ The computation to test -> [(TestName, Predicate a)] -- ^ The list of predicates (with names) to check -> TestTree -testDejafus = testDejafus' defaultMemType defaultBounds +testDejafus = testDejafusWay defaultWay defaultMemType --- | Variant of 'testDejafus' which takes a memory model and pre-emption --- bound. -testDejafus' :: Show a - => MemType +-- | Variant of 'testDejafus' which takes a way to execute the program +-- and a memory model. +-- +-- @since 0.5.0.0 +testDejafusWay :: Show a + => Way + -- ^ How to execute the concurrent program. + -> MemType -- ^ The memory model to use for non-synchronised @CRef@ operations. - -> Bounds - -- ^ The schedule bounds. -> (forall t. Conc.ConcST t a) -- ^ The computation to test -> [(TestName, Predicate a)] -- ^ The list of predicates (with names) to check -> TestTree -testDejafus' = testst +testDejafusWay = testst -- | Variant of 'testDejafu' for computations which do 'IO'. +-- +-- @since 0.2.0.0 testDejafuIO :: Show a => Conc.ConcIO a -> TestName -> Predicate a -> TestTree -testDejafuIO = testDejafuIO' defaultMemType defaultBounds +testDejafuIO = testDejafuWayIO defaultWay defaultMemType --- | Variant of 'testDejafu'' for computations which do 'IO'. -testDejafuIO' :: Show a => MemType -> Bounds -> Conc.ConcIO a -> TestName -> Predicate a -> TestTree -testDejafuIO' memtype cb concio name p = testDejafusIO' memtype cb concio [(name, p)] +-- | Variant of 'testDejafuWay' for computations which do 'IO'. +-- +-- @since 0.5.0.0 +testDejafuWayIO :: Show a + => Way -> MemType -> Conc.ConcIO a -> TestName -> Predicate a -> TestTree +testDejafuWayIO way memtype concio name p = + testDejafusWayIO way memtype concio [(name, p)] -- | Variant of 'testDejafus' for computations which do 'IO'. +-- +-- @since 0.2.0.0 testDejafusIO :: Show a => Conc.ConcIO a -> [(TestName, Predicate a)] -> TestTree -testDejafusIO = testDejafusIO' defaultMemType defaultBounds +testDejafusIO = testDejafusWayIO defaultWay defaultMemType + +-- | Variant of 'dejafusWay' for computations which do 'IO'. +-- +-- @since 0.5.0.0 +testDejafusWayIO :: Show a + => Way -> MemType -> Conc.ConcIO a -> [(TestName, Predicate a)] -> TestTree +testDejafusWayIO = testio + + +------------------------------------------------------------------------------- +-- Refinement property testing + +-- | Check a refinement property with a variety of seed values and +-- variable assignments. +-- +-- @since 0.6.0.0 +testProperty :: (R.Testable p, R.Listable (R.X p), Eq (R.X p), Show (R.X p), Show (R.O p)) + => TestName + -- ^ The name of the test. + -> p + -- ^ The property to check. + -> TestTree +testProperty = testprop --- | Variant of 'dejafus'' for computations which do 'IO'. -testDejafusIO' :: Show a => MemType -> Bounds -> Conc.ConcIO a -> [(TestName, Predicate a)] -> TestTree -testDejafusIO' = testio -------------------------------------------------------------------------------- -- Tasty integration data ConcTest where - ConcTest :: Show a => [(Either Failure a, Trc)] -> Predicate a -> ConcTest + ConcTest :: Show a => [(Either Failure a, Conc.Trace)] -> Predicate a -> ConcTest deriving Typeable data ConcIOTest where - ConcIOTest :: Show a => IO [(Either Failure a, Trc)] -> Predicate a -> ConcIOTest + ConcIOTest :: Show a => IO [(Either Failure a, Conc.Trace)] -> Predicate a -> ConcIOTest + deriving Typeable + +data PropTest where + PropTest :: (R.Testable p, R.Listable (R.X p), Eq (R.X p), Show (R.X p), Show (R.O p)) => p -> PropTest deriving Typeable instance IsTest ConcTest where - testOptions = return [] + testOptions = pure [] run _ (ConcTest traces p) _ = let err = showErr $ p traces - in return $ if null err then testPassed "" else testFailed err + in pure (if null err then testPassed "" else testFailed err) instance IsTest ConcIOTest where - testOptions = return [] + testOptions = pure [] run _ (ConcIOTest iotraces p) _ = do traces <- iotraces let err = showErr $ p traces - return $ if null err then testPassed "" else testFailed err + pure (if null err then testPassed "" else testFailed err) + +instance IsTest PropTest where + testOptions = pure [] + + run _ (PropTest p) _ = do + ce <- R.check' p + pure $ case ce of + Just c -> testFailed . init $ unlines + [ "*** Failure: " ++ + (if null (R.failingArgs c) then "" else unwords (R.failingArgs c) ++ " ") ++ + "(seed " ++ show (R.failingSeed c) ++ ")" + , " left: " ++ show (F.toList $ R.leftResults c) + , " right: " ++ show (F.toList $ R.rightResults c) + ] + Nothing -> testPassed "" -- | Produce a Tasty 'TestTree' from a Deja Fu test. -testst :: Show a => MemType -> Bounds -> (forall t. Conc.ConcST t a) -> [(TestName, Predicate a)] -> TestTree -testst memtype cb conc tests = case map toTest tests of +testst :: Show a + => Way -> MemType -> (forall t. Conc.ConcST t a) -> [(TestName, Predicate a)] -> TestTree +testst way memtype conc tests = case map toTest tests of [t] -> t ts -> testGroup "Deja Fu Tests" ts where toTest (name, p) = singleTest name $ ConcTest traces p - traces = sctBoundST memtype cb conc + traces = runSCTst way memtype conc -- | Produce a Tasty 'Test' from an IO-using Deja Fu test. -testio :: Show a => MemType -> Bounds -> Conc.ConcIO a -> [(TestName, Predicate a)] -> TestTree -testio memtype cb concio tests = case map toTest tests of +testio :: Show a + => Way -> MemType -> Conc.ConcIO a -> [(TestName, Predicate a)] -> TestTree +testio way memtype concio tests = case map toTest tests of [t] -> t ts -> testGroup "Deja Fu Tests" ts @@ -301,7 +390,12 @@ -- As with HUnit, constructing a test is side-effect free, so -- sharing of traces can't happen here. - traces = sctBoundIO memtype cb concio + traces = runSCTio way memtype concio + +-- | Produce a Tasty 'TestTree' from a Deja Fu refinement property test. +testprop :: (R.Testable p, R.Listable (R.X p), Eq (R.X p), Show (R.X p), Show (R.O p)) + => TestName -> p -> TestTree +testprop name = singleTest name . PropTest -- | Convert a test result into an error message on failure (empty -- string on success). diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/tasty-dejafu-0.3.0.2/tasty-dejafu.cabal new/tasty-dejafu-0.6.0.0/tasty-dejafu.cabal --- old/tasty-dejafu-0.3.0.2/tasty-dejafu.cabal 2016-08-28 15:57:25.000000000 +0200 +++ new/tasty-dejafu-0.6.0.0/tasty-dejafu.cabal 2017-06-07 18:08:05.000000000 +0200 @@ -2,7 +2,7 @@ -- documentation, see http://haskell.org/cabal/users-guide/ name: tasty-dejafu -version: 0.3.0.2 +version: 0.6.0.0 synopsis: Deja Fu support for the Tasty test framework. description: @@ -11,9 +11,6 @@ <https://hackage.haskell.org/package/tasty tasty>. This lets you easily incorporate concurrency testing into your existing test suites. - . - See the <https://github.com/barrucadu/dejafu README> for more - details. homepage: https://github.com/barrucadu/dejafu license: MIT @@ -23,7 +20,7 @@ -- copyright: category: Testing build-type: Simple --- extra-source-files: +extra-source-files: README.markdown CHANGELOG.markdown cabal-version: >=1.10 source-repository head @@ -33,14 +30,15 @@ source-repository this type: git location: https://github.com/barrucadu/dejafu.git - tag: tasty-dejafu-0.3.0.1 + tag: tasty-dejafu-0.6.0.0 library exposed-modules: Test.Tasty.DejaFu -- other-modules: -- other-extensions: build-depends: base >=4.8 && <5 - , dejafu >=0.2 && <0.5 + , dejafu >=0.7 && <0.8 + , random >=1.0 && <1.2 , tagged >=0.8 && <0.9 , tasty >=0.10 && <0.12 -- hs-source-dirs: