libasterix 0.17.2 → 0.18.0
raw patch · 8 files changed
+211/−76 lines, 8 filesdep +base16dep −base16-bytestringPVP ok
version bump matches the API change (PVP)
Dependencies added: base16
Dependencies removed: base16-bytestring
API changes (from Hackage documentation)
- Asterix.BitString: hexlify :: ByteString -> String
- Asterix.BitString: unhexlify :: String -> Maybe ByteString
+ Asterix.BitString: byteStringToSBuilder :: ByteString -> SBuilder
+ Asterix.BitString: lazyByteStringToSBuilder :: ByteString -> SBuilder
- Asterix.BitString: debugBits :: ToBits t => t -> String
+ Asterix.BitString: debugBits :: ToBits t => t -> Text
Files
- README.md +138/−30
- libasterix.cabal +3/−2
- src/Asterix/BitString.hs +20/−13
- test/Common.hs +17/−6
- test/TestAsterix.hs +17/−16
- test/TestBits.hs +5/−2
- test/TestCoding.hs +2/−1
- test/TestRawDatablock.hs +9/−6
README.md view
@@ -23,9 +23,15 @@ -- | file: readme-samples/example0.hs {-# LANGUAGE DataKinds #-} {-# LANGUAGE LambdaCase #-}+{-# LANGUAGE OverloadedStrings #-} import Data.Maybe import Data.ByteString (ByteString)+import Data.Text (Text)+import qualified Data.Text.IO as T+import qualified Data.ByteString as BS+import qualified Data.ByteString.Base16 as B16+import Data.Base16.Types (assertBase16, extractBase16) import Asterix.Coding import Asterix.Generated as Gen @@ -33,6 +39,14 @@ assert True = pure () assert False = error "Assertion error" +-- | Convert bytestring to hex representation.+hexlify :: BS.ByteString -> Text+hexlify = extractBase16 . B16.encodeBase16++-- | Convert hex representation back to a bytestring.+unhexlify :: Text -> BS.ByteString+unhexlify = B16.decodeBase16' . assertBase16+ -- Select particular asterix categories and editions type Cat034 = Gen.Cat_034_1_29 type Cat048 = Gen.Cat_048_1_32@@ -131,7 +145,7 @@ ssr = asString $ getItem @"MODE3A" i070 expected :: ByteString-expected = fromJust $ unhexlify "220007c0010201220008d00102020030000c9801020a0020000fff220008d001020220"+expected = unhexlify "220007c0010201220008d00102020030000c9801020a0020000fff220008d001020220" main :: IO () main = do@@ -139,7 +153,7 @@ print ("sending message: " <> show txMessage) let datablocks = fmap encode txMessage tx = toByteString $ mconcat datablocks- putStrLn ("bytes on the wire: " <> hexlify tx)+ T.putStrLn ("bytes on the wire: " <> hexlify tx) assert (tx == expected) -- decode bytes back to message, expect the same message@@ -353,22 +367,34 @@ ```haskell -- | file: readme-samples/catflt.hs {-# LANGUAGE DataKinds #-}+{-# LANGUAGE OverloadedStrings #-} import Control.Monad-import Data.Maybe import Data.ByteString (ByteString)+import Data.Text (Text)+import qualified Data.ByteString.Base16 as B16+import Data.Base16.Types (assertBase16, extractBase16)+import qualified Data.Text.IO as T import Asterix.Coding +-- | Convert bytestring to hex representation.+hexlify :: ByteString -> Text+hexlify = extractBase16 . B16.encodeBase16++-- | Convert hex representation back to a bytestring.+unhexlify :: Text -> ByteString+unhexlify = B16.decodeBase16' . assertBase16+ -- UDP rx test function receiveFromUdp :: IO ByteString-receiveFromUdp = pure $ fromJust $ unhexlify $ join+receiveFromUdp = pure $ unhexlify $ mconcat [ "01000401" -- cat1 datablock , "02000402" -- cat2 datablock ] -- UDP tx test function sendToUdp :: SBuilder -> IO ()-sendToUdp = putStrLn . hexlify . toByteString+sendToUdp = T.putStrLn . hexlify . toByteString main :: IO () main = do@@ -392,11 +418,15 @@ -- | file: readme-samples/rewrite-sacsic.hs {-# LANGUAGE DataKinds #-} {-# LANGUAGE MonoLocalBinds #-}+{-# LANGUAGE OverloadedStrings #-} import GHC.TypeLits-import Data.Maybe import Data.Either import Data.ByteString (ByteString)+import qualified Data.ByteString.Base16 as B16+import Data.Base16.Types (assertBase16, extractBase16)+import Data.Text (Text)+import qualified Data.Text.IO as T import Asterix.Coding import Asterix.Generated as Gen@@ -409,6 +439,14 @@ -- All of the following types have the same item "010" type TSacSic = SameType '[ Cat048 ~> "010", Cat062 ~> "010", Cat063 ~> "010"] +-- | Convert bytestring to hex representation.+hexlify :: ByteString -> Text+hexlify = extractBase16 . B16.encodeBase16++-- | Convert hex representation back to a bytestring.+unhexlify :: Text -> ByteString+unhexlify = B16.decodeBase16' . assertBase16+ handleDatablock :: forall cat. ( Schema (RecordOf cat) VRecord , SetItem "010" (Record (RecordOf cat)) (NonSpare TSacSic)@@ -453,7 +491,7 @@ -- Dummy tx function txBytesToTheNetwork :: SBuilder -> IO ()-txBytesToTheNetwork = putStrLn . hexlify . toByteString+txBytesToTheNetwork = T.putStrLn . hexlify . toByteString main :: IO () main = do@@ -461,11 +499,11 @@ let newSacSic :: NonSpare TSacSic newSacSic = group (1 *: 2 *: nil) sOutput = rewriteSacSic newSacSic sInput- expected = fromJust $ unhexlify+ expected = unhexlify "300011900102000000009001020000000030000a90010200000000" txBytesToTheNetwork sOutput case expected == toByteString sOutput of- True -> print "OK"+ True -> putStrLn "OK" False -> error "unexpected output" ``` @@ -541,15 +579,24 @@ ```haskell -- | file: readme-samples/ref.hs {-# LANGUAGE DataKinds #-}+{-# LANGUAGE OverloadedStrings #-} import Data.Either import Data.Maybe+import Data.Text (Text)+import qualified Data.ByteString as BS+import qualified Data.ByteString.Base16 as B16+import Data.Base16.Types (assertBase16) import Asterix.Coding import Asterix.Generated as Gen type Spec = Gen.Cat_062_1_20 type Ref = Gen.Ref_062_1_3 +-- | Convert hex representation back to a bytestring.+unhexlify :: Text -> BS.ByteString+unhexlify = B16.decodeBase16' . assertBase16+ assert :: Bool -> IO () assert True = pure () assert False = error "Assertion error"@@ -578,7 +625,7 @@ main = do let s = unparse @SBuilder db bs = toByteString s- expected = fromJust $ unhexlify+ expected = unhexlify "3e001b8101010104010211c8010000000000020000010000028000" assert (bs == expected) @@ -631,17 +678,24 @@ -- | file: readme-samples/generic-names.hs {-# LANGUAGE DataKinds #-} {-# LANGUAGE LambdaCase #-}+{-# LANGUAGE OverloadedStrings #-} import Control.Monad import Data.Word-import Data.Maybe import Data.Either import Data.Map as Map+import Data.Text (Text) import Data.ByteString (ByteString)+import qualified Data.ByteString.Base16 as B16+import Data.Base16.Types (assertBase16) import Asterix.Coding import Asterix.Generated as Gen +-- | Convert hex representation back to a bytestring.+unhexlify :: Text -> ByteString+unhexlify = B16.decodeBase16' . assertBase16+ specs :: Map Word8 VRecord specs = Map.fromList [ (48, schema @(RecordOf Cat_048_1_31) Proxy)@@ -652,7 +706,7 @@ -- some test input bytes s :: ByteString-s = mconcat $ fmap (fromJust . unhexlify)+s = mconcat $ fmap unhexlify [ "3e00a5254327d835a95a0d0a2baf256af940e8a8d0caa1a594e1e525f2e32bc0448b" , "0e34c0b6211b5847038319d1b88d714b990a6e061589a414209d2e1d00ba5602248e" , "64092c2a0410138b2c030621c2043080fe06182ee40d2fa51078192cce70e9af5435"@@ -676,7 +730,7 @@ forM_ rawDatablocks $ \db -> do let cat = rawDatablockCategory db case Map.lookup cat specs of- Nothing -> print ("unsupported category", cat)+ Nothing -> print ("unsupported category" :: String, cat) Just (GRecord sch) -> do let act = parseRecords (GRecord sch) records = fromRight (error "unexpected")@@ -691,11 +745,24 @@ -- | file: readme-samples/generic-zero.hs {-# LANGUAGE DataKinds #-} {-# LANGUAGE LambdaCase #-}+{-# LANGUAGE OverloadedStrings #-} -import Data.Maybe+import Data.Text (Text)+import qualified Data.Text.IO as T+import qualified Data.ByteString as BS+import qualified Data.ByteString.Base16 as B16+import Data.Base16.Types (assertBase16, extractBase16) import Asterix.Coding import Asterix.Generated as Gen +-- | Convert bytestring to hex representation.+hexlify :: BS.ByteString -> Text+hexlify = extractBase16 . B16.encodeBase16++-- | Convert hex representation back to a bytestring.+unhexlify :: Text -> BS.ByteString+unhexlify = B16.decodeBase16' . assertBase16+ assert :: Bool -> IO () assert True = pure () assert False = error "Assertion error"@@ -757,10 +824,10 @@ main :: IO () main = do- let expected = fromJust $ unhexlify+ let expected = unhexlify "3e0038bfe9bd5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" result = toByteString $ unparse @SBuilder db- putStrLn $ hexlify result+ T.putStrLn $ hexlify result assert (result == expected) ``` @@ -880,12 +947,24 @@ ```haskell -- | file: readme-samples/construct1.hs {-# LANGUAGE DataKinds #-}--import Data.Maybe+{-# LANGUAGE OverloadedStrings #-} +import Data.Text (Text)+import qualified Data.Text.IO as T+import qualified Data.ByteString as BS+import qualified Data.ByteString.Base16 as B16+import Data.Base16.Types (assertBase16, extractBase16) import Asterix.Coding import Asterix.Generated as Gen +-- | Convert bytestring to hex representation.+hexlify :: BS.ByteString -> Text+hexlify = extractBase16 . B16.encodeBase16++-- | Convert hex representation back to a bytestring.+unhexlify :: Text -> BS.ByteString+unhexlify = B16.decodeBase16' . assertBase16+ assert :: Bool -> IO () assert True = pure () assert False = error "Assertion error"@@ -909,10 +988,10 @@ main = do let sb :: SBuilder = unparse db062 result = toByteString sb- expected = fromJust $ unhexlify+ expected = unhexlify "3e0015911101100102003db34024304f820820029c" assert (result == expected)- putStrLn $ hexlify result+ T.putStrLn $ hexlify result ``` ### Parsing@@ -1032,17 +1111,26 @@ ```haskell -- | file: readme-samples/dep-content.hs {-# LANGUAGE DataKinds #-}+{-# LANGUAGE OverloadedStrings #-} import Control.Monad import Data.Maybe import Data.Either import Data.ByteString (ByteString)+import Data.Text (Text)+import qualified Data.ByteString as BS+import qualified Data.ByteString.Base16 as B16+import Data.Base16.Types (assertBase16) import Asterix.Coding import Asterix.Generated as Gen type Spec = Gen.Cat_062_1_20 +-- | Convert hex representation back to a bytestring.+unhexlify :: Text -> BS.ByteString+unhexlify = B16.decodeBase16' . assertBase16+ assert :: Bool -> IO () assert True = pure () assert False = error "Assertion error"@@ -1099,7 +1187,7 @@ db0 = datablock (rec0 *: rec1 *: rec2 *: rec3 *: nil) expected :: ByteString-expected = fromJust $ unhexlify "3e0017011010000101101000010110104ccd0110108320"+expected = unhexlify "3e0017011010000101101000010110104ccd0110108320" main :: IO () main = do@@ -1127,10 +1215,10 @@ 1 -> unQuantity $ asQuantity @"Mach" @('Just 1) iIAS2 _ -> error "unexpected value" - print ("--- record", cnt, "---")- print ("I062/380/IAS/IM raw value:", asUint @Integer iIM)- print ("I062/380/IAS/IAS raw value:", asUint @Integer iIAS2)- print ("converted value", value)+ print ("--- record" :: String, cnt, "---" :: String)+ print ("I062/380/IAS/IM raw value:" :: String, asUint @Integer iIM)+ print ("I062/380/IAS/IAS raw value:" :: String, asUint @Integer iIAS2)+ print ("converted value" :: String, value) ``` #### Handling **variation dependency**@@ -1141,16 +1229,26 @@ ```haskell -- | file: readme-samples/dep-variation.hs {-# LANGUAGE DataKinds #-}+{-# LANGUAGE OverloadedStrings #-} import Control.Monad import Data.Maybe import Data.Either import Data.ByteString (ByteString)+import Data.Text (Text)+import qualified Data.ByteString as BS+import qualified Data.ByteString.Base16 as B16+import Data.Base16.Types (assertBase16)+ import Asterix.Coding import Asterix.Generated as Gen type Spec = Gen.Cat_004_1_13 -- Cat 004, edition 1.13 +-- | Convert hex representation back to a bytestring.+unhexlify :: Text -> BS.ByteString+unhexlify = B16.decodeBase16' . assertBase16+ -- Item 'I004/120/CC/CPC' depends on I004/000 and I004/120/CC/TID values -- Default case is: element3, raw, but there are many other cases. -- See asterix specification for details.@@ -1209,7 +1307,7 @@ db0 = datablock (rec0 *: rec1 *: rec2 *: nil) expected :: ByteString-expected = fromJust $ unhexlify "040012412000400041200540104120094028"+expected = unhexlify "040012412000400041200540104120094028" main :: IO () main = do@@ -1225,7 +1323,7 @@ records = either (const (error "unexpected")) (fmap Record) (parse @StrictParsing act (getRawRecords db)) forM_ (zip [0::Int ..] records) $ \(cnt, rec) -> do- print ("--- record", cnt, "---")+ print ("--- record" :: String, cnt, "---" :: String) let i000 = fromJust $ getItem @"000" rec i120 = fromJust $ getItem @"120" rec iCC = fromJust $ getItem @"CC" $ getVariation i120@@ -1413,6 +1511,7 @@ import Control.Monad import Data.Maybe+import qualified Data.Text.IO as T import Asterix.Coding import Asterix.Generated as Gen @@ -1439,13 +1538,13 @@ main = do -- extract regular item 010 let i010Regular = fromJust $ getItem @"010" rec1- putStrLn $ debugBits $ unparse @Bits i010Regular+ T.putStrLn $ debugBits $ unparse @Bits i010Regular -- extract RFS items 010, expecting 2 such items let i010Rfs = getRfsItem @"010" rec1 assert (length i010Rfs == 2) forM_ i010Rfs $ \i -> do- putStrLn $ debugBits $ unparse @Bits i+ T.putStrLn $ debugBits $ unparse @Bits i -- but item '000' is not present in RFS assert (null $ getRfsItem @"000" rec1)@@ -1492,10 +1591,15 @@ ```haskell -- | file: readme-samples/parsing-partial-mode.hs {-# LANGUAGE DataKinds #-}+{-# LANGUAGE OverloadedStrings #-} import Data.Maybe import Data.Either import Data.ByteString (ByteString)+import Data.Text (Text)+import qualified Data.ByteString as BS+import qualified Data.ByteString.Base16 as B16+import Data.Base16.Types (assertBase16) import Asterix.Coding import Asterix.Generated as Gen@@ -1503,6 +1607,10 @@ type SpecOld = Gen.Cat_063_1_6 type SpecNew = Gen.Cat_063_1_7 +-- | Convert hex representation back to a bytestring.+unhexlify :: Text -> BS.ByteString+unhexlify = B16.decodeBase16' . assertBase16+ assert :: Bool -> IO () assert True = pure () assert False = error "Assertion error"@@ -1523,7 +1631,7 @@ main :: IO () main = do- let expected = fromJust $ unhexlify "c8010203030506"+ let expected = unhexlify "c8010203030506" assert (bs == expected) -- We should be able to parse the record, using the new spec
libasterix.cabal view
@@ -1,6 +1,6 @@ cabal-version: 3.0 name: libasterix-version: 0.17.2+version: 0.18.0 synopsis: Asterix data processing library description: This library provides features to process asterix data format, including@@ -58,7 +58,6 @@ build-depends: , text ^>= 2.1.3 , bytestring ^>= 0.12.2.0- , base16-bytestring ^>= 1.0.2.0 , transformers ^>= 0.6.1.1 , containers ^>= 0.7 @@ -77,6 +76,8 @@ main-is: Main.hs build-depends: , libasterix+ , text ^>= 2.1.3+ , base16 ^>= 1.0 , bytestring , tasty , tasty-quickcheck
src/Asterix/BitString.hs view
@@ -3,7 +3,8 @@ -- -- Bits and bytes manipulation module. -{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE OverloadedStrings #-} module Asterix.BitString where @@ -12,14 +13,14 @@ import Data.Bool import Data.ByteString (ByteString) import qualified Data.ByteString as BS-import qualified Data.ByteString.Base16 as B16 import Data.ByteString.Builder as BSB-import qualified Data.ByteString.Char8 as BS8 import qualified Data.ByteString.Lazy as BSL import Data.Coerce import qualified Data.List as L import Data.List.NonEmpty (NonEmpty (..), uncons) import Data.Maybe+import Data.Text (Text)+import qualified Data.Text as T import Data.Word import GHC.Stack @@ -88,14 +89,6 @@ toByteString :: t -> ByteString fromByteString :: ByteString -> t --- | Convert bytestring to hex representation.-hexlify :: BS.ByteString -> String-hexlify = BS8.unpack . B16.encode---- | Convert hex representation back to a bytestring.-unhexlify :: String -> Maybe BS.ByteString-unhexlify = either (const Nothing) Just . B16.decode . BS8.pack- -- | Helper function for expression evaluation. withAssumption :: HasCallStack => Bool -> a -> a withAssumption False _ =@@ -269,9 +262,19 @@ word8ToSBuilder :: Word8 -> SBuilder word8ToSBuilder = SBuilder 1 . BSB.word8 +-- | Convert 'ByteString' to 'SBuilder'.+byteStringToSBuilder :: ByteString -> SBuilder+byteStringToSBuilder bs = SBuilder (BS.length bs) (byteString bs)++-- | Convert 'LazyByteString' to 'SBuilder'.+lazyByteStringToSBuilder :: BSL.ByteString -> SBuilder+lazyByteStringToSBuilder bs = SBuilder+ (fromIntegral $ BSL.length bs)+ (lazyByteString bs)+ -- | Show value as binary string.-debugBits :: ToBits t => t -> String-debugBits val = mconcat $ L.intersperse " " (goOctet <$> octets)+debugBits :: ToBits t => t -> Text+debugBits val = mconcat $ L.intersperse " " (T.pack . goOctet <$> octets) where Bits bs o n' = toBits val n = numBitsToInt n'@@ -279,7 +282,11 @@ (m, b) = requiredBytes o8 n k = bool m (pred m) (b == 0) a = numBytes o++ octets :: [Int] octets = [a .. (a+k)]++ goOctet :: Int -> String goOctet ix = let w = BS.index bs ix in do
test/Common.hs view
@@ -2,15 +2,26 @@ module Common where +import Data.Base16.Types (assertBase16, extractBase16) import Data.Bool+import qualified Data.ByteString as BS+import qualified Data.ByteString.Base16 as B16 import Data.Char-import qualified Data.List.NonEmpty as NE-import Data.Maybe+import qualified Data.List.NonEmpty as NE+import Data.Text (Text) import Test.Tasty.HUnit import Asterix.Base import Asterix.Coding +-- | Convert bytestring to hex representation.+hexlify :: BS.ByteString -> Text+hexlify = extractBase16 . B16.encodeBase16++-- | Convert hex representation to bytestring.+unhexlify :: Text -> BS.ByteString+unhexlify = B16.decodeBase16' . assertBase16+ approximately :: (Ord a, Fractional a) => a -> a -> a -> Bool approximately err a b = abs (b - a) / a < err @@ -22,9 +33,9 @@ assertUint :: Unparsing Bits t => Integer -> t -> Assertion assertUint n obj = assertEqual "uint" n (asUint obj) -assertUnparse :: Unparsing Bits t => String -> t -> Assertion+assertUnparse :: Unparsing Bits t => Text -> t -> Assertion assertUnparse s obj = assertEqual "unparse"- (debugBits @Bits $ byteStringToBits (fromJust $ unhexlify s))+ (debugBits @Bits $ byteStringToBits (unhexlify s)) (debugBits @Bits $ unparse obj) assertOne :: [a] -> IO a@@ -32,8 +43,8 @@ assertOne _ = assertFailure "expecting list of length 1" data StResult- = Bin String- | Hex String+ = Bin Text+ | Hex Text checkBits :: Unparsing Bits a => String -> a -> StResult -> Assertion checkBits name x = \case
test/TestAsterix.hs view
@@ -2,8 +2,9 @@ -- Remark: Keep asterix test scenarios synchronized between implementations. -{-# LANGUAGE DataKinds #-}-{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE OverloadedStrings #-} module TestAsterix ( tests@@ -323,7 +324,7 @@ testExtended1 :: Assertion testExtended1 = do let act = parseNonSpare (schema @(RecordOf Cat_000_1_0 ~> "053") Proxy)- bs = fromJust $ unhexlify "80"+ bs = unhexlify "80" env = Env parsingStore bs result = runParsing act env 0 (_obj, o) <- either (assertFailure . show) pure result@@ -374,7 +375,7 @@ testExtended2 :: Assertion testExtended2 = do let act = parseNonSpare (schema @(RecordOf Cat_000_1_0 ~> "054") Proxy)- bs = fromJust $ unhexlify "80"+ bs = unhexlify "80" env = Env parsingStore bs result = runParsing act env 0 (_obj, o) <- either (assertFailure . show) pure result@@ -447,7 +448,7 @@ -- Create extended sample with last FX bit set to '1' (wrong). -- Parsing shall fail in this case. let act = parseNonSpare (schema @(RecordOf Cat_000_1_0 ~> "053") Proxy)- bs = fromJust $ unhexlify "010101"+ bs = unhexlify "010101" env = Env parsingStore bs result = runParsing act env 0 assertEqual "failure" True (isLeft result)@@ -497,7 +498,7 @@ testExplicit0 :: Assertion testExplicit0 = do- let bs = fromJust $ unhexlify "00"+ let bs = unhexlify "00" act = parseNonSpare (schema @(RecordOf Cat_000_1_0 ~> "071") Proxy) result = parse @StrictParsing act bs assertEqual "result" True (isLeft result)@@ -505,10 +506,10 @@ testExplicit1 :: Assertion testExplicit1 = do let obj :: NonSpare (RecordOf Cat_000_1_0 ~> "071")- obj = explicit $ fromJust $ unhexlify "010203"+ obj = explicit $ unhexlify "010203" assertUnparse "04010203" obj assertEqual "data"- (byteStringToBits (fromJust $ unhexlify "010203"))+ (byteStringToBits (unhexlify "010203")) (getExplicitData $ getVariation obj) testExplicit2 :: Assertion@@ -628,7 +629,7 @@ testCompound0 :: Assertion testCompound0 = do- let bs = fromJust $ unhexlify "0100"+ let bs = unhexlify "0100" act = parseNonSpare (schema @(RecordOf Cat_000_1_0 ~> "091") Proxy) result = parse @StrictParsing act bs assertEqual "result" True (isLeft result)@@ -636,9 +637,9 @@ testCompoundFspecError :: Assertion testCompoundFspecError = do let -- error: fspec bit is set between 'I1' and 'I2'- bs1 = fromJust $ unhexlify "c01122"+ bs1 = unhexlify "c01122" -- error: fspec bit is set between 'I1' and 'I2'- bs2 = fromJust $ unhexlify "a21122"+ bs2 = unhexlify "a21122" act = parseNonSpare (schema @(RecordOf Cat_000_1_0 ~> "092") Proxy) result1 = parse @StrictParsing act bs1 result2 = parse @StrictParsing act bs2@@ -728,7 +729,7 @@ testRecordEmpty :: Assertion testRecordEmpty = do- let bs = fromJust $ unhexlify "0101010100"+ let bs = unhexlify "0101010100" env = Env parsingStore bs actStrict = parseRecord @StrictParsing (schema @(RecordOf Cat_000_1_0) Proxy) actPartial = parseRecord @PartialParsing (schema @(RecordOf Cat_000_1_0) Proxy)@@ -808,7 +809,7 @@ *: nil ) *: nil ) bs = "410104030602AA02550112340A03040B03040C01FF"- bs' = fromJust $ unhexlify bs+ bs' = unhexlify bs assertUnparse bs withRfs let _i000 = fromJust $ getItem @"000" withRfs@@ -832,7 +833,7 @@ let check r expected = do assertUnparse expected r let act = parseRecord (schema @(RecordOf Cat_003_1_0) Proxy)- bs = fromJust $ unhexlify expected+ bs = unhexlify expected result = parse @StrictParsing act bs readback <- either (assertFailure . show) pure result assertEqual "readback" (toBits bs) (unparse readback)@@ -931,13 +932,13 @@ *: nil ) datagram :: SBuilder = unparse db0 <> unparse db1 assertEqual "unparse"- (fromJust $ unhexlify "000009800001800002010009800001800002")+ (unhexlify "000009800001800002010009800001800002") (toByteString datagram) testParse1 :: Assertion testParse1 = forM_ samples $ \sample -> do let act = parseRecord (schema @(RecordOf Cat_000_1_0) Proxy)- bs = fromJust $ unhexlify sample+ bs = unhexlify sample env = Env @StrictParsing parsingStore bs result = runParsing act env 0 (r, o) <- either (assertFailure . show) pure result
test/TestBits.hs view
@@ -1,14 +1,17 @@-{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE OverloadedStrings #-} module TestBits (tests) where import qualified Data.ByteString as BS+import qualified Data.Text as T import Test.Tasty import Test.Tasty.HUnit import Test.Tasty.QuickCheck as QC import Asterix.BitString+import Common tests :: TestTree tests = testGroup "Bits"@@ -69,7 +72,7 @@ testBsToBools :: TestTree testBsToBools = testGroup "BsToBools" (fmap check samples) where- check (x, y) = testCase (hexlify $ BS.pack x) $+ check (x, y) = testCase (T.unpack . hexlify $ BS.pack x) $ bitsToBools (byteStringToBits $ BS.pack x) @?= y samples = [ ([], [])
test/TestCoding.hs view
@@ -1,4 +1,5 @@-{-# LANGUAGE DataKinds #-}+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE OverloadedStrings #-} -- | Unsorted Coding tests
test/TestRawDatablock.hs view
@@ -1,10 +1,12 @@+{-# LANGUAGE OverloadedStrings #-}+ module TestRawDatablock (tests) where import Data.ByteString (ByteString) import qualified Data.ByteString as BS import Data.ByteString.Builder as BSB import Data.Either-import Data.Maybe+import Data.Text (Text) import Data.Word import Test.Tasty import Test.Tasty.HUnit@@ -12,6 +14,7 @@ import Asterix.Base import Asterix.BitString+import Common allowCategory :: Word8 -> RawDatablock -> Bool allowCategory n db = rawDatablockCategory db == n@@ -27,18 +30,18 @@ Right lst -> mconcat (unparseRawDatablock <$> reverse lst) -- e.g.: received from the network-samples :: [String]+samples :: [Text] samples = [ "01000401" -- cat1 , "01000401" -- cat1 , "02000402" -- cat2 ] -allZeros :: String+allZeros :: Text allZeros = "00000000000000000000" datagramIn :: ByteString-datagramIn = fromJust $ unhexlify $ mconcat samples+datagramIn = unhexlify $ mconcat samples tests :: TestTree tests = testGroup "RawDatablock"@@ -49,10 +52,10 @@ , testCase "filter 1" $ checkFilter 1 cat1 , testCase "filter 2" $ checkFilter 2 cat2 , testCase "reverse" $ assertEqual "sample"- (fromJust $ unhexlify $ mconcat $ reverse samples)+ (unhexlify $ mconcat $ reverse samples) (builderToByteStringSlow $ reverseDatablocks datagramIn) , testCase "all zeros" $ assertEqual "sample"- True (isLeft $ parseRawDatablocks $ fromJust $ unhexlify allZeros)+ True (isLeft $ parseRawDatablocks $ unhexlify allZeros) , testProperty "random input" $ withMaxSuccess 10_000 $ \(lst :: [Word8]) -> let bs = BS.pack lst result = parseRawDatablocks bs