{-# LANGUAGE OverloadedStrings #-} module Blocking (tests) where import Distribution.TestSuite import Base (simpleTest) import Control.Concurrent(forkIO) import System.IO.Uniform.Network import qualified System.IO.Uniform.Streamline as S import System.Timeout (timeout) import Data.ByteString (ByteString) import qualified Data.ByteString as BS import qualified Data.ByteString.Char8 as C8 import qualified Data.Attoparsec.ByteString as A --import Control.Monad.IO.Class (liftIO) tests :: IO [Test] tests = return [ simpleTest "recieveLine" (successTimeout "A test\n" (restoreLine S.receiveLine)), simpleTest "runAttoparsec with successful parser" (successTimeout "abcde" (parseBS (A.string "abcde"))), simpleTest "runAttoparsec with failed parser" (failTimeout "abcde" (parseBS (A.string "c"))), simpleTest "lazyRecieveLine" (successTimeout "Another test\n" (concatLine S.lazyRecieveLine)), simpleTest "lazyReceiveN" (failTimeout "abcde" (concatLine (S.lazyReceiveN 5))) ] parseBS :: A.Parser ByteString -> S.Streamline IO ByteString parseBS p = do t <- S.runAttoparsec p case t of Left e -> return . C8.pack $ e Right s -> return s restoreLine :: S.Streamline IO ByteString -> S.Streamline IO ByteString restoreLine f = do l <- f return $ BS.concat [l, "\n"] concatLine :: S.Streamline IO [ByteString] -> S.Streamline IO ByteString concatLine f = do l <- f return . BS.concat $ l -- | Tests the given command, by sending a string to an echo and running the command. -- the command must not block. successTimeout :: ByteString -> S.Streamline IO ByteString -> IO Progress successTimeout txt f = do recv <- bindPort 8888 forkIO $ S.withClient (\_ _ -> do l <- f S.send l return () ) recv r' <- timeout 1000000 $ S.withServer (do S.send txt t <- f if t == txt then return . Finished $ Pass else return . Finished . Fail . C8.unpack $ t ) "127.0.0.1" 8888 closePort recv case r' of Just r -> return r Nothing -> return . Finished . Fail $ "Execution blocked" -- | Tests the given command, by sending text trough the network and running it. -- Does not care about the result of the command, just wether it blocks. failTimeout :: ByteString -> S.Streamline IO ByteString -> IO Progress failTimeout txt f = do recv <- bindPort 8888 forkIO $ S.withClient (\_ _ -> do f S.send "\n" return () ) recv r' <- timeout 1000000 $ S.withServer (do S.send txt S.receiveLine return . Finished $ Pass ) "127.0.0.1" 8888 closePort recv case r' of Just r -> return r Nothing -> return . Finished . Fail $ "Execution blocked"