diff --git a/lzma-conduit.cabal b/lzma-conduit.cabal
--- a/lzma-conduit.cabal
+++ b/lzma-conduit.cabal
@@ -1,5 +1,5 @@
 name:                lzma-conduit
-version:             1.0.8
+version:             1.1.0
 synopsis:            Conduit interface for lzma/xz compression.
 description:
   High level bindings to xz-utils.
@@ -30,8 +30,8 @@
     base              >= 3      && < 5,
     bindings-DSL      >= 1.0    && < 1.1,
     bytestring        >= 0.9.1  && < 0.11,
-    conduit           >= 0.4    && < 1.1,
-    resourcet         >= 0.3    && < 0.5,
+    conduit           >= 0.4    && < 1.2,
+    resourcet         >= 0.3    && < 1.2,
     transformers      >= 0.2    && < 0.4
   ghc-options:
     -Wall
@@ -39,6 +39,29 @@
     lzma.h
   extra-libraries:
     lzma
+
+test-suite lzma-test
+  default-language:
+    Haskell2010
+  hs-source-dirs:
+    tests
+  type:
+    exitcode-stdio-1.0
+  main-is:
+    Main.hs
+  ghc-options:
+    -threaded
+  build-depends:
+    lzma-conduit,
+    base                       >= 3      && < 5,
+    bytestring,
+    conduit,
+    resourcet,
+    test-framework,
+    test-framework-hunit,
+    test-framework-quickcheck2,
+    HUnit,
+    QuickCheck
 
 source-repository head
   type:     git
diff --git a/tests/Main.hs b/tests/Main.hs
--- a/tests/Main.hs
+++ b/tests/Main.hs
@@ -3,13 +3,14 @@
 import Test.Framework.Providers.QuickCheck2 (testProperty)
 import Test.QuickCheck
 import Test.QuickCheck.Monadic
+import Control.Monad.Trans.Resource
 
 import qualified Data.ByteString as B
-import qualified Data.Enumerator as E
-import qualified Data.Enumerator.List as EL
+import qualified Data.Conduit as C
+import qualified Data.Conduit.List as Cl
 import Data.List
 import Data.Word
-import Codec.Compression.Lzma.Enumerator
+import Data.Conduit.Lzma
 
 main = defaultMain tests
 
@@ -36,52 +37,48 @@
 
 someString :: Gen B.ByteString
 someString = do
-  val <- listOf $ elements [0..255::Word8] 
+  val <- listOf $ elements [0..255::Word8]
   return $ B.pack val
 
 someBigString :: Gen B.ByteString
 someBigString = resize (8*1024) someString
 
-dropAll :: Monad m => E.Iteratee a m ()
-dropAll = EL.dropWhile (const True)
-
 prop_compressAndDiscard :: Property
-prop_compressAndDiscard = monadicIO $ forAllM someBigString $ \ str -> do
-  run $ E.run_ $ E.enumList 2 [str] E.$$ E.joinI (compress Nothing E.$$ dropAll)
+prop_compressAndDiscard = monadicIO . forAllM someBigString $ \ str -> do
+  run . runResourceT $ Cl.sourceList [str] C.$$ compress Nothing C.=$= Cl.sinkNull
 
 prop_compressAndCheckLength :: Property
-prop_compressAndCheckLength = monadicIO $ forAllM someBigString $ \ str -> do
-  len <- run $ E.run_ $ E.enumList 2 [str] E.$$ E.joinI (compress Nothing E.$$ EL.fold (\ acc el -> acc + B.length el) 0)
+prop_compressAndCheckLength = monadicIO . forAllM someBigString $ \ str -> do
+  len <- run . runResourceT $ Cl.sourceList [str] C.$$ compress Nothing C.=$= Cl.fold (\ acc el -> acc + B.length el) 0
   assert (len - 32 > B.length str `div` 2) -- random strings don't compress very well
 
 prop_chain :: Property
-prop_chain = monadicIO $ forAllM someBigString $ \ str -> do
-  str' <- run $ E.run_ $ E.enumList 2 [str] E.$$ E.joinI (compress Nothing E.$$ E.joinI (decompress Nothing E.$$ EL.consume))
+prop_chain = monadicIO . forAllM someBigString $ \ str -> do
+  str' <- run . runResourceT $ Cl.sourceList [str] C.$$ compress Nothing C.=$= decompress Nothing C.=$= Cl.consume
   return $ str == B.concat str'
 
 prop_compressThenDecompress :: Property
-prop_compressThenDecompress = monadicIO $ forAllM someBigString $ \ str -> do
-  blob <- run $ E.run_ $ E.enumList 2 [str] E.$$ E.joinI (compress Nothing E.$$ EL.consume)
+prop_compressThenDecompress = monadicIO . forAllM someBigString $ \ str -> do
+  blob <- run . runResourceT $ Cl.sourceList [str] C.$$ compress Nothing C.=$= Cl.consume
   let blob' = B.concat blob
   randIdx <- pick $ elements [0..B.length blob'-1]
   let resplit = let (x,y) = B.splitAt randIdx blob' in [x,y]
-  str' <- run $ E.run_ $ E.enumList 2 resplit E.$$ E.joinI (decompress Nothing E.$$ EL.consume)
+  str' <- run . runResourceT $ Cl.sourceList resplit C.$$ decompress Nothing C.=$= Cl.consume
   return $ str == B.concat str'
 
 prop_decompressRandom :: Property
-prop_decompressRandom = monadicIO $ forAllM someBigString $ \ str -> do
-  header <- run $ E.run_ $ E.enumList 2 [] E.$$ E.joinI (compress Nothing E.$$ EL.consume)
+prop_decompressRandom = expectFailure . monadicIO . forAllM someBigString $ \ str -> do
+  header <- run . runResourceT $ Cl.sourceList [] C.$$ compress Nothing C.=$= Cl.consume
   let blob = header ++ [str]
-  run $ E.run_ $ E.enumList 2 blob E.$$ E.joinI (decompress Nothing E.$$ dropAll)
+  run $ runResourceT $ Cl.sourceList blob C.$$ decompress Nothing C.=$= Cl.sinkNull
 
 prop_decompressCorrupt :: Property
-prop_decompressCorrupt = expectFailure $ monadicIO $ forAllM someBigString $ \ str -> do
-  header <- run $ E.run_ $ E.enumList 2 [] E.$$ E.joinI (compress Nothing E.$$ EL.consume)
+prop_decompressCorrupt = expectFailure . monadicIO . forAllM someBigString $ \ str -> do
+  header <- run . runResourceT $ Cl.sourceList [] C.$$ compress Nothing C.=$= Cl.consume
   let header' = B.concat header
   randVal <- pick $ elements [0..255::Word8]
   randIdx <- pick $ elements [0..B.length header'-1]
   let (left, right) = B.splitAt randIdx header'
       updated = left `B.append` (randVal `B.cons` B.tail right)
       blob = [updated, str]
-  run $ E.run_ $ E.enumList 2 blob E.$$ E.joinI (decompress Nothing E.$$ dropAll)
-
+  run $ runResourceT $ Cl.sourceList blob C.$$ decompress Nothing C.=$= Cl.sinkNull