haskoin-util 0.0.1 → 0.0.1.1

raw patch · 2 files changed

+118/−1 lines, 2 files

Files

• haskoin-util.cabal +2/−1
• tests/Network/Haskoin/Util/Tests.hs +116/−0

@@ -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.*,

@@ -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+