bytestring-0.10.4.0: tests/builder/Data/ByteString/Builder/Prim/Tests.hs
{-# LANGUAGE CPP, ScopedTypeVariables #-}
-- |
-- Copyright : (c) 2011 Simon Meier
-- License : BSD3-style (see LICENSE)
--
-- Maintainer : Simon Meier <iridcode@gmail.com>
-- Stability : experimental
-- Portability : tested on GHC only
--
-- Testing all encodings provided by this library.
module Data.ByteString.Builder.Prim.Tests (tests) where
import Data.Char (ord)
import qualified Data.ByteString.Lazy as L
import Data.ByteString.Builder
import qualified Data.ByteString.Builder.Prim as BP
import Data.ByteString.Builder.Prim.TestUtils
#if defined(HAVE_TEST_FRAMEWORK)
import Test.Framework
#else
import TestFramework
#endif
tests :: [Test]
tests = concat [ testsBinary, testsASCII, testsChar8, testsUtf8
, testsCombinatorsB ]
------------------------------------------------------------------------------
-- Binary
------------------------------------------------------------------------------
testsBinary :: [Test]
testsBinary =
[ testBoundedF "word8" bigEndian_list BP.word8
, testBoundedF "int8" bigEndian_list BP.int8
-- big-endian
, testBoundedF "int16BE" bigEndian_list BP.int16BE
, testBoundedF "int32BE" bigEndian_list BP.int32BE
, testBoundedF "int64BE" bigEndian_list BP.int64BE
, testBoundedF "word16BE" bigEndian_list BP.word16BE
, testBoundedF "word32BE" bigEndian_list BP.word32BE
, testBoundedF "word64BE" bigEndian_list BP.word64BE
, testF "floatLE" (float_list littleEndian_list) BP.floatLE
, testF "doubleLE" (double_list littleEndian_list) BP.doubleLE
-- little-endian
, testBoundedF "int16LE" littleEndian_list BP.int16LE
, testBoundedF "int32LE" littleEndian_list BP.int32LE
, testBoundedF "int64LE" littleEndian_list BP.int64LE
, testBoundedF "word16LE" littleEndian_list BP.word16LE
, testBoundedF "word32LE" littleEndian_list BP.word32LE
, testBoundedF "word64LE" littleEndian_list BP.word64LE
, testF "floatBE" (float_list bigEndian_list) BP.floatBE
, testF "doubleBE" (double_list bigEndian_list) BP.doubleBE
-- host dependent
, testBoundedF "int16Host" hostEndian_list BP.int16Host
, testBoundedF "int32Host" hostEndian_list BP.int32Host
, testBoundedF "int64Host" hostEndian_list BP.int64Host
, testBoundedF "intHost" hostEndian_list BP.intHost
, testBoundedF "word16Host" hostEndian_list BP.word16Host
, testBoundedF "word32Host" hostEndian_list BP.word32Host
, testBoundedF "word64Host" hostEndian_list BP.word64Host
, testBoundedF "wordHost" hostEndian_list BP.wordHost
, testF "floatHost" (float_list hostEndian_list) BP.floatHost
, testF "doubleHost" (double_list hostEndian_list) BP.doubleHost
]
------------------------------------------------------------------------------
-- Latin-1 aka Char8
------------------------------------------------------------------------------
testsChar8 :: [Test]
testsChar8 =
[ testBoundedF "char8" char8_list BP.char8 ]
------------------------------------------------------------------------------
-- ASCII
------------------------------------------------------------------------------
testsASCII :: [Test]
testsASCII =
[ testBoundedF "char7" char7_list BP.char7
, testBoundedB "int8Dec" dec_list BP.int8Dec
, testBoundedB "int16Dec" dec_list BP.int16Dec
, testBoundedB "int32Dec" dec_list BP.int32Dec
, testBoundedB "int64Dec" dec_list BP.int64Dec
, testBoundedB "intDec" dec_list BP.intDec
, testBoundedB "word8Dec" dec_list BP.word8Dec
, testBoundedB "word16Dec" dec_list BP.word16Dec
, testBoundedB "word32Dec" dec_list BP.word32Dec
, testBoundedB "word64Dec" dec_list BP.word64Dec
, testBoundedB "wordDec" dec_list BP.wordDec
, testBoundedB "word8Hex" hex_list BP.word8Hex
, testBoundedB "word16Hex" hex_list BP.word16Hex
, testBoundedB "word32Hex" hex_list BP.word32Hex
, testBoundedB "word64Hex" hex_list BP.word64Hex
, testBoundedB "wordHex" hex_list BP.wordHex
, testBoundedF "word8HexFixed" wordHexFixed_list BP.word8HexFixed
, testBoundedF "word16HexFixed" wordHexFixed_list BP.word16HexFixed
, testBoundedF "word32HexFixed" wordHexFixed_list BP.word32HexFixed
, testBoundedF "word64HexFixed" wordHexFixed_list BP.word64HexFixed
, testBoundedF "int8HexFixed" int8HexFixed_list BP.int8HexFixed
, testBoundedF "int16HexFixed" int16HexFixed_list BP.int16HexFixed
, testBoundedF "int32HexFixed" int32HexFixed_list BP.int32HexFixed
, testBoundedF "int64HexFixed" int64HexFixed_list BP.int64HexFixed
, testF "floatHexFixed" floatHexFixed_list BP.floatHexFixed
, testF "doubleHexFixed" doubleHexFixed_list BP.doubleHexFixed
]
------------------------------------------------------------------------------
-- UTF-8
------------------------------------------------------------------------------
testsUtf8 :: [Test]
testsUtf8 =
[ testBoundedB "charUtf8" charUtf8_list BP.charUtf8 ]
------------------------------------------------------------------------------
-- BoundedPrim combinators
------------------------------------------------------------------------------
maybeB :: BP.BoundedPrim () -> BP.BoundedPrim a -> BP.BoundedPrim (Maybe a)
maybeB nothing just = maybe (Left ()) Right BP.>$< BP.eitherB nothing just
testsCombinatorsB :: [Test]
testsCombinatorsB =
[ compareImpls "mapMaybe (via BoundedPrim)"
(L.pack . concatMap encChar)
(toLazyByteString . encViaBuilder)
, compareImpls "filter (via BoundedPrim)"
(L.pack . filter (< 32))
(toLazyByteString . BP.primMapListBounded (BP.condB (< 32) (BP.liftFixedToBounded BP.word8) BP.emptyB))
, compareImpls "pairB"
(L.pack . concatMap (\(c,w) -> charUtf8_list c ++ [w]))
(toLazyByteString . BP.primMapListBounded
((\(c,w) -> (c,(w,undefined))) BP.>$<
BP.charUtf8 BP.>*< (BP.liftFixedToBounded BP.word8) BP.>*< (BP.liftFixedToBounded BP.emptyF)))
]
where
encChar = maybe [112] (hostEndian_list . ord)
encViaBuilder = BP.primMapListBounded $ maybeB (BP.liftFixedToBounded $ (\_ -> 112) BP.>$< BP.word8)
(ord BP.>$< (BP.liftFixedToBounded $ BP.intHost))