diff --git a/Control/Monad/Exception.hs b/Control/Monad/Exception.hs
--- a/Control/Monad/Exception.hs
+++ b/Control/Monad/Exception.hs
@@ -1,16 +1,17 @@
--- |
--- Module      :  Control.Monad.Exception
--- Copyright   :  (c) Harvard University 2008-2011
---                (c) Geoffrey Mainland 2011-2012
--- License     :  BSD-style
--- Maintainer  :  mainland@eecs.harvard.edu
-
 {-# LANGUAGE CPP #-}
 {-# LANGUAGE MagicHash #-}
 {-# LANGUAGE RankNTypes #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE UnboxedTuples #-}
+{-# OPTIONS_GHC -fno-warn-warnings-deprecations #-}
 
+-- |
+-- Module      :  Control.Monad.Exception
+-- Copyright   :  (c) Harvard University 2008-2011
+--                (c) Geoffrey Mainland 2011-2014
+-- License     :  BSD-style
+-- Maintainer  :  mainland@cs.drexel.edu
+
 module Control.Monad.Exception (
     E.Exception(..),
     E.SomeException,
@@ -27,7 +28,9 @@
     liftException
   ) where
 
+#if defined(__GLASGOW_HASKELL__) && (__GLASGOW_HASKELL__ < 706)
 import Prelude hiding (catch)
+#endif
 
 import Control.Applicative
 import qualified Control.Exception as E (Exception(..),
@@ -50,6 +53,11 @@
                                   ErrorT(..),
                                   mapErrorT,
                                   runErrorT)
+#if MIN_VERSION_transformers(0,4,0)
+import Control.Monad.Trans.Except (ExceptT(..),
+                                   mapExceptT,
+                                   runExceptT)
+#endif /* MIN_VERSION_transformers(0,4,0) */
 import Control.Monad.Trans.Identity (IdentityT(..),
                                      mapIdentityT,
                                      runIdentityT)
@@ -295,7 +303,17 @@
     act `finally` sequel =
         mapErrorT (\act' -> act' `finally` runErrorT sequel) act
 
+#if MIN_VERSION_transformers(0,4,0)
 instance (MonadException m) =>
+    MonadException (ExceptT e' m) where
+    throw       = lift . throw
+    m `catch` h = mapExceptT (\m' -> m' `catch` \e -> runExceptT (h e)) m
+
+    act `finally` sequel =
+        mapExceptT (\act' -> act' `finally` runExceptT sequel) act
+#endif /* MIN_VERSION_transformers(0,4,0) */
+
+instance (MonadException m) =>
     MonadException (IdentityT m) where
     throw       = lift . throw
     m `catch` h = mapIdentityT (\m' -> m' `catch` \e -> runIdentityT (h e)) m
@@ -363,6 +381,13 @@
     MonadAsyncException (ErrorT e m) where
     mask act = ErrorT $ mask $ \restore ->
                runErrorT $ act (mapErrorT restore)
+
+#if MIN_VERSION_transformers(0,4,0)
+instance (MonadAsyncException m) =>
+    MonadAsyncException (ExceptT e' m) where
+    mask act = ExceptT $ mask $ \restore ->
+               runExceptT $ act (mapExceptT restore)
+#endif /* MIN_VERSION_transformers(0,4,0) */
 
 instance (MonadAsyncException m) =>
     MonadAsyncException (IdentityT m) where
diff --git a/exception-transformers.cabal b/exception-transformers.cabal
--- a/exception-transformers.cabal
+++ b/exception-transformers.cabal
@@ -1,14 +1,14 @@
 name:           exception-transformers
-version:        0.3.0.3
+version:        0.3.0.4
 cabal-version:  >= 1.10
 license:        BSD3
 license-file:   LICENSE
 copyright:      (c) 2009-2010 Harvard University
-		(c) 2011-2012 Geoffrey Mainland
-author:         Geoffrey Mainland <mainland@eecs.harvard.edu>
-maintainer:     mainland@eecs.harvard.edu
+		(c) 2011-2014 Geoffrey Mainland
+author:         Geoffrey Mainland <mainland@cs.drexel.edu>
+maintainer:     Geoffrey Mainland <mainland@cs.drexel.edu>
 stability:      alpha
-homepage:       http://www.eecs.harvard.edu/~mainland/
+homepage:       http://www.cs.drexel.edu/~mainland/
 category:       Control, Monad, Error Handling, Failure
 synopsis:       Type classes and monads for unchecked extensible exceptions.
 description:    This package provides type classes, a monad and a monad
@@ -25,9 +25,9 @@
     Control.Monad.Exception
 
   build-depends:
-    base         >=4   && <5,
-    stm          >=2.1 && <2.5,
-    transformers >=0.2 && <0.4
+    base         >= 4   && < 5,
+    stm          >= 2.1 && < 2.5,
+    transformers >= 0.2 && < 0.5
 
   ghc-options:
     -Wall
@@ -39,10 +39,12 @@
   default-language: Haskell98
 
   build-depends:
-    HUnit                  >= 1.2 && <1.3,
-    base                   >= 4   && <5,
-    exception-transformers >= 0.3 && <0.4,
-    transformers           >= 0.2 && <0.4
+    HUnit                  >= 1.2 && < 1.3,
+    base                   >= 4   && < 5,
+    exception-transformers >= 0.3 && < 0.5,
+    test-framework         >= 0.8 && < 0.9,
+    test-framework-hunit   >= 0.3 && < 0.4,
+    transformers           >= 0.2 && < 0.5
 
   ghc-options:
     -Wall
diff --git a/tests/unit/Main.hs b/tests/unit/Main.hs
--- a/tests/unit/Main.hs
+++ b/tests/unit/Main.hs
@@ -1,49 +1,90 @@
-{-# LANGUAGE ScopedTypeVariables #-}
-
-module Main where
-
-import Prelude hiding (catch)
-
-import Control.Monad.Exception
-import Control.Monad.Trans.Error
-import Control.Monad.IO.Class
-import Data.IORef
-import System.Exit (exitFailure, exitSuccess)
-import Test.HUnit
-
-main :: IO ()
-main = do
-    count <- runTestTT tests
-    case failures count of
-      0 -> exitSuccess
-      _ -> exitFailure
-
-
-tests :: Test
-tests = TestList [mkTest (conl ++ " " ++ whatl) con what | (conl, con) <- cons, (whatl, what) <- whats]
-  where
-    whats :: [(String, ErrorT String IO ())]
-    whats = [("return",     return ()),
-             ("error",      error "error"),
-             ("throwError", throwError "throwError")]
-
-    cons :: [(String, ErrorT String IO () -> ErrorT String IO () -> ErrorT String IO ())]
-    cons = [("finally",  \what sequel -> what `finally` sequel),
-            ("bracket_", \what sequel -> bracket_ (return ()) sequel what)]
-
-mkTest :: String
-       -> (ErrorT String IO () -> ErrorT String IO () -> ErrorT String IO ())
-       -> ErrorT String IO ()
-       -> Test
-mkTest label con what =
-    label ~: tst
-  where
-    tst = do
-        ref <- newIORef "sequel not called"
-        let sequel = liftIO $ writeIORef ref expected
-        _ <- runErrorT (con what sequel) `catch` \(e :: SomeException) -> return (Left (show e))
-        actual <- readIORef ref
-        return $ assertEqual "" expected actual
-
-    expected :: String
-    expected = "sequel called"
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# OPTIONS_GHC -fno-warn-warnings-deprecations #-}
+
+-- |
+-- Module      :  Main
+-- Copyright   :  (c) Geoffrey Mainland 2011-2014
+-- License     :  BSD-style
+-- Maintainer  :  mainland@cs.drexel.edu
+
+module Main where
+
+#if defined(__GLASGOW_HASKELL__) && (__GLASGOW_HASKELL__ < 706)
+import Prelude hiding (catch)
+#endif
+
+import Control.Monad.Exception
+import Control.Monad.Trans.Error
+#if MIN_VERSION_transformers(0,4,0)
+import Control.Monad.Trans.Except
+#endif /* MIN_VERSION_transformers(0,4,0) */
+import Control.Monad.IO.Class
+import Data.IORef
+import Test.Framework
+import Test.Framework.Providers.HUnit
+import Test.HUnit (Assertion, (@?=))
+
+main :: IO ()
+main = defaultMain tests
+
+tests :: [Test]
+tests = [ errorTests
+        , exceptTests
+        ]
+
+errorTests :: Test
+errorTests = testGroup "ErrorT tests"
+    [testCase (conl ++ " " ++ whatl) (mkErrorTest con what) | (conl, con) <- cons, (whatl, what) <- whats]
+  where
+    whats :: [(String, ErrorT String IO ())]
+    whats = [("return",     return ()),
+             ("error",      error "error"),
+             ("throwError", throwError "throwError")]
+
+    cons :: [(String, ErrorT String IO () -> ErrorT String IO () -> ErrorT String IO ())]
+    cons = [("finally",  \what sequel -> what `finally` sequel),
+            ("bracket_", \what sequel -> bracket_ (return ()) sequel what)]
+
+    mkErrorTest :: (ErrorT String IO () -> ErrorT String IO () -> ErrorT String IO ())
+                -> ErrorT String IO ()
+                -> Assertion
+    mkErrorTest con what = do
+        ref <- newIORef "sequel not called"
+        let sequel = liftIO $ writeIORef ref expected
+        _ <- runErrorT (con what sequel) `catch` \(e :: SomeException) -> return (Left (show e))
+        actual <- readIORef ref
+        expected @?= actual
+      where
+        expected :: String
+        expected = "sequel called"
+
+exceptTests :: Test
+exceptTests = testGroup "ExceptT tests"
+#if MIN_VERSION_transformers(0,4,0)
+    [testCase (conl ++ " " ++ whatl) (mkExceptTest con what) | (conl, con) <- cons, (whatl, what) <- whats]
+  where
+    whats :: [(String, ExceptT String IO ())]
+    whats = [("return", return ()),
+             ("error",  error "error"),
+             ("throwE", throwE "throwE")]
+
+    cons :: [(String, ExceptT String IO () -> ExceptT String IO () -> ExceptT String IO ())]
+    cons = [("finally",  \what sequel -> what `finally` sequel),
+            ("bracket_", \what sequel -> bracket_ (return ()) sequel what)]
+
+    mkExceptTest :: (ExceptT String IO () -> ExceptT String IO () -> ExceptT String IO ())
+                -> ExceptT String IO ()
+                -> Assertion
+    mkExceptTest con what = do
+        ref <- newIORef "sequel not called"
+        let sequel = liftIO $ writeIORef ref expected
+        _ <- runExceptT (con what sequel) `catch` \(e :: SomeException) -> return (Left (show e))
+        actual <- readIORef ref
+        expected @?= actual
+      where
+        expected :: String
+        expected = "sequel called"
+#else /* !MIN_VERSION_transformers(0,4,0) */
+    []
+#endif /* !MIN_VERSION_transformers(0,4,0) */