netlines-1.0.0: Test.hs

-- |
-- Module:     Main
-- Copyright:  (c) 2010 Ertugrul Soeylemez
-- License:    BSD3
-- Maintainer: Ertugrul Soeylemez <es@ertes.de>
-- Stability:  experimental
--
-- Test program.

{-# LANGUAGE OverloadedStrings, ScopedTypeVariables #-}
{-# OPTIONS_GHC -F -pgmF htfpp #-}

module Main where

import qualified Data.ByteString.Char8 as BC
import qualified Data.Enumerator as E
import qualified Data.Enumerator.List as EL
import qualified Data.Text as T
import Control.ContStuff
import Data.ByteString (ByteString)
import Data.Enumerator (Iteratee, enumList, ($$), (=$))
import Data.Enumerator.NetLines
import Data.Enumerator.NetLines.Class (Splittable)
import Data.Text (Text)
import System.Environment
import System.Exit
import System.Random
import Test.Framework


type Bs = ByteString
type MBs = Maybe ByteString
type MT = Maybe Text


iterEqual ::
    (Eq b, Show b, Splittable str) => b -> Iteratee str IO b -> Assertion
iterEqual expectedResult iter = do
    mLine <- E.run iter
    case mLine of
      Right actualResult -> assertEqual actualResult expectedResult
      Left exp           -> assertFailure ("Iteratee exception: " ++ show exp)


test_netLine_empty :: Assertion
test_netLine_empty = do
    iterEqual (Nothing :: MBs) (netLine 512)
    iterEqual (Nothing :: MT) (netLine 512)


test_netLine_single :: Assertion
test_netLine_single = do
    iterEqual (Just "abc") (enumList 1 ["abc" :: Bs] $$ netLine 8)
    iterEqual (Just "abc") (enumList 1 ["abc\nabc" :: Bs] $$ netLine 8)
    iterEqual (Just "12345678") (enumList 1 ["12345678" :: Bs] $$ netLine 8)
    iterEqual (Just "12345678") (enumList 1 ["12345678\n123" :: Bs] $$ netLine 8)
    iterEqual (Just "12345678") (enumList 1 ["123456789" :: Bs] $$ netLine 8)
    iterEqual (Just "12345678") (enumList 1 ["123456789\n123" :: Bs] $$ netLine 8)

    iterEqual (Just "abc") (enumList 1 ["abc" :: Text] $$ netLine 8)
    iterEqual (Just "abc") (enumList 1 ["abc\nabc" :: Text] $$ netLine 8)
    iterEqual (Just "12345678") (enumList 1 ["12345678" :: Text] $$ netLine 8)
    iterEqual (Just "12345678") (enumList 1 ["12345678\n123" :: Text] $$ netLine 8)
    iterEqual (Just "12345678") (enumList 1 ["123456789" :: Text] $$ netLine 8)
    iterEqual (Just "12345678") (enumList 1 ["123456789\n123" :: Text] $$ netLine 8)


test_netLine_multiple :: Assertion
test_netLine_multiple = do
    iterEqual [Just "abc" :: MBs, Just "def", Nothing, Nothing]
        (enumList 2 ["abc\n", "defghi\n"] $$ replicateM 4 (netLine 3))

    iterEqual [Just "abc" :: MT, Just "def", Nothing, Nothing]
        (enumList 2 ["abc\n", "defghi\n"] $$ replicateM 4 (netLine 3))
    iterEqual [Just "äöü" :: MT, Just "üßa", Nothing, Nothing]
        (enumList 2 ["äöü\n", "üßabc\n"] $$ replicateM 4 (netLine 3))


test_netLine_longStream :: Assertion
test_netLine_longStream = do
    input <- replicateM 100000 (randomRIO ('\0', '\300'))

    let bsInputs = takeWhile (not . BC.null) . map (BC.pack . take 32) . iterate (drop 32) . filter (<= '\255') $ input
        txInputs = takeWhile (not . T.null) . map (T.pack . take 32) . iterate (drop 32) $ input

        bsExpected = map BC.pack . filter (not . null) . map (take 16) . asciiLines . filter (/= '\r') . filter (<= '\255') $ input
        txExpected = map T.pack . filter (not . null) . map (take 16) . asciiLines . filter (/= '\r') $ input

        asciiLines xs =
            case break (== '\n') xs of
              ("", "") -> []
              (pfx, "") -> [pfx]
              (pfx, '\n':sfx) -> pfx : asciiLines sfx
              _ -> undefined

    iterEqual bsExpected (enumList 16 bsInputs $$ netLines 16 =$ EL.consume)
    iterEqual txExpected (enumList 16 txInputs $$ netLines 16 =$ EL.consume)


main :: IO ()
main =
    getArgs >>=
    flip runTestWithArgs allHTFTests >>=
    exitWith