word8-0.1.4: test/Word8Spec.hs

module Word8Spec where

import qualified Data.Char as C
import Data.Word8
import Test.Hspec

allWord8 :: [Word8]
allWord8 = [0 .. 255]

spec :: Spec
spec = do
    describe "isControl" $ do
        it "behaves like model" $
            (isControl <$> allWord8)
                == (C.isControl . word8ToChar <$> allWord8)

    describe "isSpace" $ do
        it "behaves like model" $
            (isSpace <$> allWord8)
                == (C.isSpace . word8ToChar <$> allWord8)

    describe "isLower" $ do
        it "behaves like model" $
            (isLower <$> allWord8)
                == (C.isLower . word8ToChar <$> allWord8)

    describe "isUpper" $ do
        it "behaves like model" $
            (isUpper <$> allWord8)
                == (C.isUpper . word8ToChar <$> allWord8)

    describe "isAlpha" $ do
        it "behaves like model" $
            (isAlpha <$> allWord8)
                == (C.isAlpha . word8ToChar <$> allWord8)

    describe "isAlphaNum" $ do
        it "behaves like model" $
            (isAlphaNum <$> allWord8)
                == (C.isAlphaNum . word8ToChar <$> allWord8)

    describe "isPrint" $ do
        it "behaves like model" $
            (isPrint <$> allWord8)
                == (C.isPrint . word8ToChar <$> allWord8)

    describe "isDigit" $ do
        it "behaves like model" $
            (isDigit <$> allWord8)
                == (C.isDigit . word8ToChar <$> allWord8)

    describe "isOctDigit" $ do
        it "behaves like model" $
            (isOctDigit <$> allWord8)
                == (C.isOctDigit . word8ToChar <$> allWord8)

    describe "isHexDigit" $ do
        it "behaves like model" $
            (isHexDigit <$> allWord8)
                == (C.isHexDigit . word8ToChar <$> allWord8)

    describe "isLetter" $ do
        it "behaves like model" $
            (isLetter <$> allWord8)
                == (C.isLetter . word8ToChar <$> allWord8)

    describe "isMark" $ do
        it "behaves like model" $
            (isMark <$> allWord8)
                == (C.isMark . word8ToChar <$> allWord8)

    describe "isNumber" $ do
        it "behaves like model" $
            (isNumber <$> allWord8)
                == (C.isNumber . word8ToChar <$> allWord8)

    describe "isPunctuation" $ do
        it "behaves like model" $
            (isPunctuation <$> allWord8)
                == (C.isPunctuation . word8ToChar <$> allWord8)

    describe "isSymbol" $ do
        it "behaves like model" $
            (isSymbol <$> allWord8)
                == (C.isSymbol . word8ToChar <$> allWord8)

    describe "isSeparator" $ do
        it "behaves like model" $
            (isSeparator <$> allWord8)
                == (C.isSeparator . word8ToChar <$> allWord8)

    describe "isAscii" $ do
        it "behaves like model" $
            (isAscii <$> allWord8)
                == (C.isAscii . word8ToChar <$> allWord8)

    describe "isLatin1" $ do
        it "behaves like model" $
            (isLatin1 <$> allWord8)
                == (C.isLatin1 . word8ToChar <$> allWord8)

    describe "isAsciiUpper" $ do
        it "behaves like model" $
            (isAsciiUpper <$> allWord8)
                == (C.isAsciiUpper . word8ToChar <$> allWord8)

    describe "isAsciiLower" $ do
        it "behaves like model" $
            (isAsciiLower <$> allWord8)
                == (C.isAsciiLower . word8ToChar <$> allWord8)

    describe "toUpper" $ do
        it "behaves like model" $
            (word8ToChar . toUpper <$> allWord8)
                == (latin1Model C.toUpper . word8ToChar <$> allWord8)

    describe "toLower" $ do
        it "behaves like model" $
            (word8ToChar . toLower <$> allWord8)
                == (latin1Model C.toLower . word8ToChar <$> allWord8)

    describe "toTitle" $ do
        it "behaves like model" $
            (word8ToChar . toTitle <$> allWord8)
                == (latin1Model C.toTitle . word8ToChar <$> allWord8)

----------------------------------------------------------------

word8ToChar :: Word8 -> Char
word8ToChar = C.chr . fromIntegral

-- Characters mapped outside Latin-1 by Data.Char must remain unchanged.
latin1Model :: (Char -> Char) -> Char -> Char
latin1Model f c = let c' = f c in if C.isLatin1 c' then c' else c