[Pkg-haskell-commits] [package-plan] 368/457: Import patches for exceptions

[Joachim Breitner]

This is an automated email from the git hooks/post-receive script.

nomeata pushed a commit to branch master
in repository package-plan.

commit 396e866311f976216b998284030f351c2b3d8ba5
Author: Clint Adams <clint at debian.org>
Date:   Tue Dec 31 15:43:00 2013 +0000

    Import patches for exceptions
---
 all-packages.cabal                              |  0
 packages.txt                                    |  2 +-
 patches/exceptions/0.3.2/missing-testsuite.diff | 95 +++++++++++++++++++++++++
 patches/exceptions/0.3.2/newer-quickcheck.diff  |  8 +++
 patches/exceptions/0.3.2/series                 |  2 +
 5 files changed, 106 insertions(+), 1 deletion(-)

diff --git a/all-packages.cabal b/all-packages.cabal
new file mode 100644
index 0000000..e69de29
diff --git a/packages.txt b/packages.txt
index 54e69e7..e5de458 100644
--- a/packages.txt
+++ b/packages.txt
@@ -177,7 +177,7 @@ erf 2.0.0.0
 errors 1.4.4
 esqueleto 1.3.4.2
 event-list 0.1.0.2
-exceptions 0.3.2 patched for newer QuickCheck
+exceptions 0.3.2
 exception-transformers 0.3.0.3
 executable-path 0.0.3
 explicit-exception 0.1.7.1
diff --git a/patches/exceptions/0.3.2/missing-testsuite.diff b/patches/exceptions/0.3.2/missing-testsuite.diff
new file mode 100644
index 0000000..21bf92e
--- /dev/null
+++ b/patches/exceptions/0.3.2/missing-testsuite.diff
@@ -0,0 +1,95 @@
+--- /dev/null
++++ b/tests/Control/Monad/Catch/Tests.hs
+@@ -0,0 +1,92 @@
++{-# LANGUAGE DeriveDataTypeable #-}
++{-# LANGUAGE ScopedTypeVariables #-}
++{-# LANGUAGE ExistentialQuantification #-}
++{-# LANGUAGE NamedFieldPuns #-}
++{-# LANGUAGE CPP #-}
++
++module Control.Monad.Catch.Tests (tests) where
++
++#if defined(__GLASGOW_HASKELL__) && (__GLASGOW_HASKELL__ < 706)
++import Prelude hiding (catch)
++#endif
++
++import Control.Applicative ((<*>))
++import Data.Data (Data, Typeable)
++
++import Control.Monad.Trans.Identity (IdentityT(..))
++import Control.Monad.Reader (ReaderT(..))
++import Test.Framework (Test, testGroup)
++import Test.Framework.Providers.QuickCheck2 (testProperty)
++import Test.QuickCheck (Property, once)
++import Test.QuickCheck.Monadic (monadic, run, assert)
++import Test.QuickCheck.Property (morallyDubiousIOProperty)
++import qualified Control.Monad.State.Lazy as LazyState
++import qualified Control.Monad.State.Strict as StrictState
++import qualified Control.Monad.Writer.Lazy as LazyWriter
++import qualified Control.Monad.Writer.Strict as StrictWriter
++import qualified Control.Monad.RWS.Lazy as LazyRWS
++import qualified Control.Monad.RWS.Strict as StrictRWS
++
++import Control.Monad.Catch
++import Control.Monad.Catch.Pure
++
++data TestException = TestException String
++    deriving (Show, Eq, Data, Typeable)
++
++instance Exception TestException
++
++data MSpec = forall m. (MonadCatch m) => MSpec
++    { mspecName :: String
++    , mspecRunner :: (m Property -> Property)
++    }
++
++testMonadCatch :: MSpec -> Property
++testMonadCatch MSpec { mspecRunner } = monadic mspecRunner $
++    run $ catch failure handler
++  where
++    failure = throwM (TestException "foo") >> error "testMonadCatch"
++    handler (_ :: TestException) = return ()
++
++testCatchJust :: MSpec -> Property
++testCatchJust MSpec { mspecRunner } = monadic mspecRunner $ do
++    nice <- run $ catchJust testException posFailure posHandler
++    assert $ nice == ("pos", True)
++    bad <- run $ catch (catchJust testException negFailure posHandler) negHandler
++    assert $ bad == ("neg", True)
++  where
++    testException (TestException s) = if s == "pos" then Just True else Nothing
++    posHandler x = return ("pos", x)
++    negHandler (_ :: TestException) = return ("neg", True)
++    posFailure = throwM (TestException "pos") >> error "testCatchJust pos"
++    negFailure = throwM (TestException "neg") >> error "testCatchJust neg"
++
++tests :: Test
++tests = testGroup "Control.Monad.Catch.Tests" $
++    [ mkMonadCatch
++    , mkCatchJust
++    ] <*> mspecs
++  where
++    mspecs =
++        [ MSpec "IO" io
++        , MSpec "IdentityT IO" $ io . runIdentityT
++        , MSpec "LazyState.StateT IO" $ io . flip LazyState.evalStateT ()
++        , MSpec "StrictState.StateT IO" $ io . flip StrictState.evalStateT ()
++        , MSpec "ReaderT IO" $ io . flip runReaderT ()
++        , MSpec "LazyWriter.WriterT IO" $ io . fmap tfst . LazyWriter.runWriterT
++        , MSpec "StrictWriter.WriterT IO" $ io . fmap tfst . StrictWriter.runWriterT
++        , MSpec "LazyRWS.RWST IO" $ \m -> io $ fmap tfst $ LazyRWS.evalRWST m () ()
++        , MSpec "StrictRWS.RWST IO" $ \m -> io $ fmap tfst $ StrictRWS.evalRWST m () ()
++
++        , MSpec "CatchT Indentity" $ fromRight . runCatch
++        ]
++
++    tfst :: (Property, ()) -> Property = fst
++    fromRight (Left _) = error "fromRight"
++    fromRight (Right a) = a
++    io = morallyDubiousIOProperty
++
++    mkMonadCatch = mkTestType "MonadCatch" testMonadCatch
++    mkCatchJust = mkTestType "catchJust" testCatchJust
++
++    mkTestType name test = \spec ->
++        testProperty (name ++ " " ++ mspecName spec) $ once $ test spec
diff --git a/patches/exceptions/0.3.2/newer-quickcheck.diff b/patches/exceptions/0.3.2/newer-quickcheck.diff
new file mode 100644
index 0000000..2790eb6
--- /dev/null
+++ b/patches/exceptions/0.3.2/newer-quickcheck.diff
@@ -0,0 +1,8 @@
+--- a/exceptions.cabal
++++ b/exceptions.cabal
+@@ -56,4 +56,4 @@
+ 
+     test-framework             >= 0.8      && < 0.9,
+     test-framework-quickcheck2 >= 0.3      && < 0.4,
+-    QuickCheck                 >= 2.5      && < 2.6
++    QuickCheck                 >= 2.5      && < 2.7
diff --git a/patches/exceptions/0.3.2/series b/patches/exceptions/0.3.2/series
new file mode 100644
index 0000000..2be1e06
--- /dev/null
+++ b/patches/exceptions/0.3.2/series
@@ -0,0 +1,2 @@
+newer-quickcheck.diff
+missing-testsuite.diff

-- 
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-haskell/package-plan.git