diff --git a/haskoin-util.cabal b/haskoin-util.cabal
--- a/haskoin-util.cabal
+++ b/haskoin-util.cabal
@@ -1,5 +1,5 @@
 name:                  haskoin-util
-version:               0.0.1
+version:               0.0.1.1
 synopsis:              Utility functions for the Network.Haskoin project
 description:           
     This package contains utility functions used across the Network.Haskoin
@@ -40,6 +40,7 @@
 Test-Suite test-haskoin-util
     type:              exitcode-stdio-1.0
     main-is:           Main.hs
+    other-modules:     Network.Haskoin.Util.Tests
     build-depends:     base                       == 4.6.*,
                        binary                     == 0.7.*,
                        bytestring                 == 0.10.*,
diff --git a/tests/Network/Haskoin/Util/Tests.hs b/tests/Network/Haskoin/Util/Tests.hs
new file mode 100644
--- /dev/null
+++ b/tests/Network/Haskoin/Util/Tests.hs
@@ -0,0 +1,116 @@
+module Network.Haskoin.Util.Tests (tests) where
+
+import Test.Framework (Test, testGroup)
+import Test.Framework.Providers.QuickCheck2 (testProperty)
+
+import Data.List (permutations)
+import Data.Maybe (fromJust, catMaybes)
+import Data.Foldable (toList)
+import qualified Data.Sequence as Seq (update, fromList)
+import qualified Data.ByteString as BS (ByteString)
+
+import Network.Haskoin.Util 
+import Network.Haskoin.Util.BuildMonad
+import Network.Haskoin.Util.Arbitrary()
+
+tests :: [Test]
+tests = 
+    [ testGroup "Utility functions"
+        [ testProperty "toStrict( toLazy(bs) ) = bs" fromToLazy
+        , testProperty "get( put(Integer) ) = Integer" getPutInteger
+        , testProperty "stringToBS( bsToString(s) ) = s" fromToString
+        , testProperty "decode'( encode'(s) ) = s" decEncBS
+        , testProperty "decodeOrFail'( encode'(s) ) = s" decEncFailBS
+        , testProperty "fromHex( toHex(bs) ) = bs" fromToHex
+        , testProperty "testing decodeEither" testFromDecode
+        , testProperty "compare updateIndex with Data.Sequence" testUpdateIndex
+        , testProperty "testing matchTemplate" testMatchTemplate
+        , testProperty 
+            "testing matchTemplate with two lists" testMatchTemplateLen
+        , testProperty "Testing either helper functions" testEither
+        ]
+    , testGroup "Build Monad"
+        [ testProperty "Build monadic composition" testBuildCompose
+        , testProperty "Testing guardPartial" testGuardPartial
+        ]
+    ]
+
+{- Various utilities -}
+
+fromToLazy :: BS.ByteString -> Bool
+fromToLazy bs = (toStrictBS $ toLazyBS bs) == bs
+
+fromToString :: BS.ByteString -> Bool
+fromToString bs = (stringToBS $ bsToString bs) == bs
+
+decEncBS :: BS.ByteString -> Bool
+decEncBS bs = (decode' $ encode' bs) == bs
+
+decEncFailBS :: BS.ByteString -> Bool
+decEncFailBS bs = case (decodeOrFail' $ encode' bs) of
+    (Left _)            -> False
+    (Right (_, _, res)) -> res == bs
+
+getPutInteger :: Integer -> Bool
+getPutInteger i = (bsToInteger $ integerToBS p) == p
+  where 
+    p = abs i
+
+fromToHex :: BS.ByteString -> Bool
+fromToHex bs = (fromJust $ hexToBS $ bsToHex bs) == bs
+
+testFromDecode :: BS.ByteString -> Integer -> Integer -> Bool
+testFromDecode bs def v = case decodeOrFail' bs of
+    (Left _)          -> fromDecode bs def (*v) == def 
+    (Right (_,_,res)) -> fromDecode bs def (*v) == res*v 
+
+testUpdateIndex :: [Int] -> Int -> Int -> Bool 
+testUpdateIndex xs v i = 
+    (updateIndex i xs $ const v) == (toList $ Seq.update i v s)
+  where 
+    s = Seq.fromList xs
+
+testMatchTemplate :: [Int] -> Int -> Bool
+testMatchTemplate as i = catMaybes res == bs
+  where 
+    res = matchTemplate as bs (==)
+    idx = if length as == 0 then 0 else i `mod` length as 
+    bs  = (permutations as) !! idx
+
+testMatchTemplateLen :: [Int] -> [Int] -> Bool
+testMatchTemplateLen as bs = length bs == length res
+  where 
+    res = matchTemplate as bs (==)
+
+testEither :: Either String Int -> Bool
+testEither e = case e of
+    (Right v) -> (isRight e)
+              && (not $ isLeft e) 
+              && (fromRight e == v)
+              && (eitherToMaybe e == Just v)
+    (Left v)  -> (isLeft e)
+              && (not $ isRight e)
+              && (fromLeft e == v)
+              && (eitherToMaybe e == Nothing)
+
+{- Build Monad -}
+
+testBuildCompose :: Build Int -> Build Int -> Bool
+testBuildCompose ma mb
+    | isBroken ma || isBroken mb   = isBroken res
+    | isPartial ma || isPartial mb = isPartial res
+    | otherwise                    = isComplete res
+  where 
+    res = ma >>= (\a -> mb >>= (\b -> return $ a + b ))
+
+testGuardPartial :: Build Int -> Build Int -> Bool
+testGuardPartial ma mb
+    | isBroken ma || isBroken mb   = isBroken res
+    | otherwise                    = isPartial res
+  where 
+    res = do
+        a <- ma
+        guardPartial False
+        b <- mb
+        return $ a + b
+