circe 0.1.0.0 → 0.2.0.0

raw patch · 14 files changed

+571/−319 lines, 14 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• CHANGELOG.md +6/−0
• README.md +3/−4
• circe.cabal +3/−10
• exe/Main.hs +98/−41
• lib/Codec/Circe.hs +291/−16
• lib/Codec/Circe/CRC16.hs +0/−48
• lib/Codec/Circe/CRC32.hs +0/−50
• lib/Codec/Circe/Cfg.hs +0/−43
• lib/Codec/Circe/Pretty.hs +26/−7
• lib/Codec/Circe/Reflect.hs +55/−10
• test/Test/Circe.hs +89/−6
• test/Test/Circe/CRC16.hs +0/−27
• test/Test/Circe/CRC32.hs +0/−27
• test/Test/Circe/Reflect.hs +0/−30

@@ -1,5 +1,11 @@ # Revision history for circe +## 0.2.0.0 -- 8-14-26++* CRC8 and CRC64 support+* Additional CRC predefined configs+* Update & generalize API+ ## 0.1.0.0 -- 8-12-26  * First version. Released on an unsuspecting world.

@@ -2,15 +2,14 @@  CRC cyclic redundancy check -Support CRC16 & CRC32+Support CRC8, CRC16, CRC32, and CRC64  Usage  ```-crc 16 --help                  # crc options-crc 32 --help+crc (8|16|32|64) --help        # crc options echo -n "hello world" | crc 16 # stream stdin-crc 16 100gb.bin               # stream file+crc 32 100gb.bin               # stream file ```  Development

@@ -1,8 +1,8 @@ cabal-version:      3.0 name:               circe-version:            0.1.0.0+version:            0.2.0.0 synopsis:           CRC-description:        Cyclic redundancy check CRC16 CRC32+description:        Cyclic redundancy check CRC8 CRC16 CRC32 CRC64 homepage:           https://github.com/dopamane/circe license:            MIT license-file:       LICENSE@@ -24,9 +24,6 @@   hs-source-dirs:   lib   exposed-modules:     Codec.Circe,-    Codec.Circe.CRC16,-    Codec.Circe.CRC32,-    Codec.Circe.Cfg,     Codec.Circe.Pretty,     Codec.Circe.Reflect   build-depends:@@ -53,11 +50,7 @@   hs-source-dirs:   test   type:             exitcode-stdio-1.0   main-is:          Main.hs-  other-modules:-    Test.Circe-    Test.Circe.CRC16-    Test.Circe.CRC32-    Test.Circe.Reflect+  other-modules:    Test.Circe   build-depends:     base,     circe,

@@ -1,8 +1,6 @@ module Main (main) where -import Codec.Circe.CRC16-import Codec.Circe.CRC32-import Codec.Circe.Cfg+import Codec.Circe import Codec.Circe.Pretty import qualified Data.ByteString.Lazy as BS import Data.Version@@ -14,19 +12,28 @@ main = do   cli <- circeCLI $ showVersion version   case cli of+    CRC8Table  p -> putStrLn $ table $ w8  <$> crc8Table  p     CRC16Table p -> putStrLn $ table $ w16 <$> crc16Table p     CRC32Table p -> putStrLn $ table $ w32 <$> crc32Table p+    CRC64Table p -> putStrLn $ table $ w64 <$> crc64Table p+    CRC8  cfg (Just f) -> putStrLn . w8  . crc8  cfg =<< BS.readFile f+    CRC8  cfg Nothing  -> putStrLn . w8  . crc8  cfg =<< BS.getContents     CRC16 cfg (Just f) -> putStrLn . w16 . crc16 cfg =<< BS.readFile f     CRC16 cfg Nothing  -> putStrLn . w16 . crc16 cfg =<< BS.getContents     CRC32 cfg (Just f) -> putStrLn . w32 . crc32 cfg =<< BS.readFile f     CRC32 cfg Nothing  -> putStrLn . w32 . crc32 cfg =<< BS.getContents+    CRC64 cfg (Just f) -> putStrLn . w64 . crc64 cfg =<< BS.readFile f+    CRC64 cfg Nothing  -> putStrLn . w64 . crc64 cfg =<< BS.getContents  data CirceCLI-  = CRC16 CRC16Cfg (Maybe String)+  = CRC8 CRC8Cfg (Maybe String)+  | CRC16 CRC16Cfg (Maybe String)   | CRC32 CRC32Cfg (Maybe String)-  | -- | poly-    CRC16Table Word16+  | CRC64 CRC64Cfg (Maybe String)+  | CRC8Table  Word8+  | CRC16Table Word16   | CRC32Table Word32+  | CRC64Table Word64  -- | run CLI, specify version string circeCLI :: String -> IO CirceCLI@@ -41,73 +48,123 @@  parser :: Parser CirceCLI parser = hsubparser $ mconcat-  [ command "16" $ info crc16Parser $ progDesc "CRC16"+  [ command "8"  $ info crc8Parser  $ progDesc "CRC8"+  , command "16" $ info crc16Parser $ progDesc "CRC16"   , command "32" $ info crc32Parser $ progDesc "CRC32"+  , command "64" $ info crc64Parser $ progDesc "CRC64"   ] +crc8Parser :: Parser CirceCLI+crc8Parser = asum+  [ CRC8 <$> crc8CfgParser <*> optional fileArg+  , CRC8Table <$> tableOpt 8+  ]+ crc16Parser :: Parser CirceCLI crc16Parser = asum-  [ CRC16Table <$> tableOpt 16-  , CRC16 <$> crc16CfgParser <*> optional fileArg+  [ CRC16 <$> crc16CfgParser <*> optional fileArg+  , CRC16Table <$> tableOpt 16   ]  crc32Parser :: Parser CirceCLI crc32Parser = asum-  [ CRC32Table <$> tableOpt 32-  , CRC32 <$> crc32CfgParser <*> optional fileArg+  [ CRC32 <$> crc32CfgParser <*> optional fileArg+  , CRC32Table <$> tableOpt 32   ] +crc64Parser :: Parser CirceCLI+crc64Parser = asum+  [ CRC64 <$> crc64CfgParser <*> optional fileArg+  , CRC64Table <$> tableOpt 64+  ]+ tableOpt :: (Num a, Read a) => Int -> Parser a tableOpt n = option auto $ mconcat   [ short 't' <> long "table" <> metavar "POLY"   , help $ "Generate CRC" <> show n <> " lookup table with polynomial"   ] +crc8CfgParser :: Parser CRC8Cfg+crc8CfgParser = asum+  [ flag' crc8Cfg $ long "crc8" <> help ("DEFAULT " ++ showCRC8Cfg crc8Cfg)+  , flag' crc88H2F $ long "8h2f" <> help (showCRC8Cfg crc88H2F)+  , flag' crc8CDMA2k $ long "cdma2k" <> help (showCRC8Cfg crc8CDMA2k)+  , flag' crc8DARC $ long "darc" <> help (showCRC8Cfg crc8DARC)+  , flag' crc8DVBS2 $ long "dvbs2" <> help (showCRC8Cfg crc8DVBS2)+  , flag' crc8EBU $ long "ebu" <> help (showCRC8Cfg crc8EBU)+  , flag' crc8ICode $ long "icode" <> help (showCRC8Cfg crc8ICode)+  , flag' crc8ITU $ long "itu" <> help (showCRC8Cfg crc8ITU)+  , flag' crc8Maxim $ long "maxim" <> help (showCRC8Cfg crc8Maxim)+  , flag' crc8ROHC $ long "rohc" <> help (showCRC8Cfg crc8ROHC)+  , flag' crc8WCDMA $ long "wcdma" <> help (showCRC8Cfg crc8WCDMA)+  , crcCfgParser+  , pure crc8Cfg+  ]+ crc16CfgParser :: Parser CRC16Cfg crc16CfgParser = asum-  [ flag' crc16CCITZero $ long "ccit-zero"-  , flag' crc16Modbus $ long "modbus"-  , CRCCfg-      <$> polyOpt-      <*> initOpt-      <*> refinSwitch-      <*> refoutSwitch-      <*> finXorOpt+  [ flag' crc16CCITZero $ long "ccit-zero" <> help ("DEFAULT " ++ showCRC16Cfg crc16CCITZero)+  , flag' crc16Arc $ long "arc" <> help (showCRC16Cfg crc16Arc)+  , flag' crc16AugCCITT $ long "aug-ccit" <> help (showCRC16Cfg crc16AugCCITT)+  , flag' crc16Buypass $ long "buypass" <> help (showCRC16Cfg crc16Buypass)+  , flag' crc16CCITTFalse $ long "ccitt-false" <> help (showCRC16Cfg crc16CCITTFalse)+  , flag' crc16CDMA2k $ long "cdma2k" <> help (showCRC16Cfg crc16CDMA2k)+  , flag' crc16DDS110 $ long "dds110" <> help (showCRC16Cfg crc16DDS110)+  , flag' crc16DECTR $ long "dectr" <> help (showCRC16Cfg crc16DECTR)+  , flag' crc16DECTX $ long "dectx" <> help (showCRC16Cfg crc16DECTX)+  , flag' crc16DNP $ long "dnp" <> help (showCRC16Cfg crc16DNP)+  , flag' crc16EN13757 $ long "en13757" <> help (showCRC16Cfg crc16EN13757)+  , flag' crc16Genibus $ long "genibus" <> help (showCRC16Cfg crc16Genibus)+  , flag' crc16Maxim $ long "maxim" <> help (showCRC16Cfg crc16Maxim)+  , flag' crc16MCRF4XX $ long "mcrf4xx" <> help (showCRC16Cfg crc16MCRF4XX)+  , flag' crc16Riello $ long "riello" <> help (showCRC16Cfg crc16Riello)+  , flag' crc16T10DIF $ long "t10dif" <> help (showCRC16Cfg crc16T10DIF)+  , flag' crc16Teledisk $ long "teledisk" <> help (showCRC16Cfg crc16Teledisk)+  , flag' crc16TMS37157 $ long "tms37157" <> help (showCRC16Cfg crc16TMS37157)+  , flag' crc16USB $ long "usb" <> help (showCRC16Cfg crc16USB)+  , flag' crc16CRCA $ long "crca" <> help (showCRC16Cfg crc16CRCA)+  , flag' crc16Kermit $ long "kermit" <> help (showCRC16Cfg crc16Kermit)+  , flag' crc16Modbus $ long "modbus" <> help (showCRC16Cfg crc16Modbus)+  , flag' crc16X25 $ long "x25" <> help (showCRC16Cfg crc16X25)+  , flag' crc16XModem $ long "xmodem" <> help (showCRC16Cfg crc16XModem)+  , crcCfgParser+  , pure crc16CCITZero   ]  crc32CfgParser :: Parser CRC32Cfg crc32CfgParser = asum-  [ CRCCfg-      <$> option auto (short 'p' <> long "poly" <> metavar "WORD32" <> help "polynomial")-      <*> option auto (short 'i' <> long "init" <> metavar "WORD32" <> help "initial value")-      <*> refinSwitch-      <*> refoutSwitch-      <*> option auto (short 'x' <> long "xor" <> metavar "WORD32" <> help "final xor")-  , flag crc32IEEE crc32IEEE $ long "ieee"-      <> help ("Default CRC32 config "-                 <> "POLY=0x4C11DB7 INIT=0xFFFFFFFF REFL-IN REFL-OUT FIN-XOR=0xFFFFFFFF")+  [ flag' crc32IEEE $ long "ieee" <> help ("DEFAULT " ++ showCRC32Cfg crc32IEEE)+  , flag' crc32BZIP2 $ long "bzip2" <> help (showCRC32Cfg crc32BZIP2)+  , flag' crc32MPEG2 $ long "mpeg2" <> help (showCRC32Cfg crc32MPEG2)+  , flag' crc32POSIX $ long "posix" <> help (showCRC32Cfg crc32POSIX)+  , crcCfgParser+  , pure crc32IEEE   ] -polyOpt :: Parser Word16-polyOpt = option auto $-  short 'p' <> long "poly" <> metavar "WORD16" <> help "polynomial"-    <> value 0x1021 <> showDefaultWith w16+crc64CfgParser :: Parser CRC64Cfg+crc64CfgParser = asum+  [ flag' crc64ECMA182 $ long "ecma-182" <> help ("DEFAULT " ++ showCRC64Cfg crc64ECMA182)+  , flag' crc64GoISO $ long "go-iso" <> help (showCRC64Cfg crc64GoISO)+  , flag' crc64WE $ long "we" <> help (showCRC64Cfg crc64WE)+  , flag' crc64XZ $ long "xz" <> help (showCRC64Cfg crc64XZ)+  , crcCfgParser+  , pure crc64ECMA182+  ] -initOpt :: Parser Word16-initOpt = option auto $-  short 'i' <> long "init" <> metavar "WORD16" <> help "inital value"-    <> value 0 <> showDefaultWith w16+crcCfgParser :: Read a => Parser (CRCCfg a)+crcCfgParser =+  CRCCfg+    <$> option auto (short 'p' <> long "poly" <> help "polynomial")+    <*> option auto (short 'i' <> long "init" <> help "initial value")+    <*> refinSwitch+    <*> refoutSwitch+    <*> option auto (short 'x' <> long "xor" <> help "final xor")  refinSwitch :: Parser Bool refinSwitch = switch $ long "ri" <> long "refin" <> help "reflect input"  refoutSwitch :: Parser Bool refoutSwitch = switch $ long "ro" <> long "refout" <> help "reflect output"--finXorOpt :: Parser Word16-finXorOpt = option auto $-  short 'x' <> long "xor" <> metavar "WORD16"-    <> value 0 <> showDefaultWith w16 <> help "final xor"  fileArg :: Parser String fileArg = strArgument $

@@ -1,20 +1,295 @@--- | CRC high-level utilities.--- See "Codec.Circe.CRC16" and "Codec.Circe.CRC32" for low-level functions.+-- | CRC utilities. module Codec.Circe-  ( -- ** CRC-    crc16-  , crc32-  , -- ** CONFIG+  ( -- ** CRC8+    crc8, crc8WithTable, crc8Table+  , CRC8Cfg, showCRC8Cfg+  , crc8Cfg, crc88H2F, crc8CDMA2k, crc8DARC, crc8DVBS2, crc8EBU, crc8ICode+  , crc8ITU, crc8Maxim, crc8ROHC, crc8WCDMA+  , -- ** CRC16+    crc16, crc16WithTable, crc16Table+  , CRC16Cfg, showCRC16Cfg+  , crc16CCITZero, crc16Arc, crc16AugCCITT, crc16Buypass, crc16CCITTFalse+  , crc16CDMA2k, crc16DDS110, crc16DECTR, crc16DECTX, crc16DNP, crc16EN13757+  , crc16Genibus, crc16Maxim, crc16MCRF4XX, crc16Riello, crc16T10DIF+  , crc16Teledisk, crc16TMS37157, crc16USB, crc16CRCA, crc16Kermit+  , crc16Modbus, crc16X25, crc16XModem+  , -- ** CRC32+    crc32, crc32WithTable, crc32Table+  , CRC32Cfg, showCRC32Cfg+  , crc32IEEE, crc32BZIP2, crc32MPEG2, crc32POSIX+  , -- ** CRC64+    crc64, crc64WithTable, crc64Table+  , CRC64Cfg, showCRC64Cfg+  , crc64ECMA182, crc64GoISO, crc64WE, crc64XZ+  , -- ** CRCCfg     CRCCfg(..)-  , -- **** CRC16-    CRC16Cfg-  , crc16CCITZero-  , crc16Modbus-  , -- **** CRC32-    CRC32Cfg-  , crc32IEEE+  , -- ** Unsafe+    crc, crcWithTable, crcUnsafe, crcTable   ) where -import Codec.Circe.CRC16-import Codec.Circe.CRC32-import Codec.Circe.Cfg+import Codec.Circe.Pretty+import Codec.Circe.Reflect+import Data.Bits+import Data.ByteString.Lazy (ByteString)+import qualified Data.ByteString.Lazy as BS+import Data.Vector.Storable (Vector)+import qualified Data.Vector.Storable as V+import Data.Function+import Data.Word++-- | calculate CRC8 using lookup table generated from config+crc8 :: CRC8Cfg -> ByteString -> Word8+crc8 = crc ref8+-- | calculate CRC16 using lookup table generated from config+crc16 :: CRC16Cfg -> ByteString -> Word16+crc16 = crc ref16+-- | calculate CRC32 using lookup table generated from config+crc32 :: CRC32Cfg -> ByteString -> Word32+crc32 = crc ref32+-- | calculate CRC64 using lookup table generated from config+crc64 :: CRC64Cfg -> ByteString -> Word64+crc64 = crc ref64++-- | calculate CRC8 with precalculated poly table+crc8WithTable :: Vector Word8 -> CRC8Cfg -> ByteString -> Word8+crc8WithTable = crcWithTable ref8+-- | calculate CRC16 with precalculated poly table+crc16WithTable :: Vector Word16 -> CRC16Cfg -> ByteString -> Word16+crc16WithTable = crcWithTable ref16+-- | calculate CRC32 with precalculated poly table+crc32WithTable :: Vector Word32 -> CRC32Cfg -> ByteString -> Word32+crc32WithTable = crcWithTable ref32+-- | calculate CRC64 with precalculated poly table+crc64WithTable :: Vector Word64 -> CRC64Cfg -> ByteString -> Word64+crc64WithTable = crcWithTable ref64++-- | generate CRC8 lookup table using polynomial+crc8Table :: Word8 -> [Word8]+crc8Table = crcTable+-- | generate CRC16 lookup table using polynomial+crc16Table :: Word16 -> [Word16]+crc16Table = crcTable+-- | generate CRC32 lookup table using polynomial+crc32Table :: Word32 -> [Word32]+crc32Table = crcTable+-- | generate CRC64 lookup table using polynomial+crc64Table :: Word64 -> [Word64]+crc64Table = crcTable++-- | calculate CRC using lookup table generated from config+crc :: (FiniteBits a, Integral a, Num a, V.Storable a) => (a -> a) -> CRCCfg a -> ByteString -> a+crc ref cfg = crcWithTable ref t cfg+  where+    t = V.fromList $ crcTable $ crcPoly cfg++-- | calculate CRC with reflection & precalculated poly table.+crcWithTable+  :: (FiniteBits a, Integral a, Num a, V.Storable a)+  => (a -> a)+  -> Vector a -> CRCCfg a -> ByteString -> a+crcWithTable ref t cfg =+  xor (crcFinXor cfg) . applyWhen (crcRefOut cfg) ref . crcUnsafe t (crcRefIn cfg) (crcInit cfg)++-- | calculate CRC using width, efficient lookup table, input reflection, and init value+crcUnsafe :: (FiniteBits a, Integral a, Num a, V.Storable a) => Vector a -> Bool -> a -> ByteString -> a+crcUnsafe t refIn i = BS.foldl' go i+  where+    go crc' b = crc' `shiftL` 8 `xor` t `V.unsafeIndex` fromIntegral pos+      where+        pos = fromIntegral ((crc' `xor` fromIntegral b' `shiftL` w') `shiftR` w') :: Word8+          where+            b' = applyWhen refIn ref8 b+            w' = finiteBitSize i - 8++-- | Generate CRC table using width and poly+crcTable :: (FiniteBits a, Enum a, Num a) => a -> [a]+crcTable poly = calc <$> [0..255]+  where+    l    = fromIntegral (finiteBitSize poly) :: Int+    calc = (!! 8) . iterate step . (`shiftL` (l - 8))+      where+        step curByte = applyWhen (testBit curByte $ l - 1) (`xor` poly) $ curByte `shiftL` 1++-- | CRC configuration parameters+data CRCCfg a = CRCCfg+  { crcPoly :: a+    -- ^ polynomial+  , crcInit :: a+    -- ^ initial value+  , crcRefIn :: Bool+    -- ^ reflect input+  , crcRefOut :: Bool+    -- ^ reflect output+  , crcFinXor :: a+    -- ^ final xor+  }+  deriving (Eq, Read, Show)++instance Functor CRCCfg where+  fmap f (CRCCfg p i ri ro x) = CRCCfg (f p) (f i) ri ro (f x)++showCRCCfg :: CRCCfg String -> String+showCRCCfg (CRCCfg p i ri ro x) = unwords ["POLY", p, "INIT", i, showRefl (ri, ro), "XOR", x]++-- | display reflection config+showRefl :: (Bool, Bool) -> String+showRefl (ri, ro) = case (ri, ro) of+  (False, False) -> "NOREFL"+  (False, True)  -> "REFLOUT"+  (True,  False) -> "REFLIN"+  (True,  True)  -> "REFLINOUT"++-- | specialized CRC for 'Word8'+type CRC8Cfg = CRCCfg Word8+-- | specialized CRC for 'Word16'+type CRC16Cfg = CRCCfg Word16+-- | specialized CRC for 'Word32'+type CRC32Cfg = CRCCfg Word32+-- | specialized CRC for 'Word64'+type CRC64Cfg = CRCCfg Word64++-- | display CRC8 config+showCRC8Cfg :: CRC8Cfg -> String+showCRC8Cfg = showCRCCfg . fmap w8+-- | display CRC16 config+showCRC16Cfg :: CRC16Cfg -> String+showCRC16Cfg = showCRCCfg . fmap w16+-- | display CRC32 config+showCRC32Cfg :: CRC32Cfg -> String+showCRC32Cfg = showCRCCfg . fmap w32+-- | display CRC64 config+showCRC64Cfg :: CRC64Cfg -> String+showCRC64Cfg = showCRCCfg . fmap w64++-- | POLY 0x7 INIT 0 NOREFL NOXOR+crc8Cfg :: CRC8Cfg+crc8Cfg = CRCCfg 0x7 0x0 False False 0x0+-- | POLY 0x2F INIT 0xFF NOREFL XOR 0xFF+crc88H2F :: CRC8Cfg+crc88H2F = CRCCfg 0x2f 0xff False False 0xff+-- | POLY 0x9b INIT 0xFF NOREFL NOXOR+crc8CDMA2k :: CRC8Cfg+crc8CDMA2k = CRCCfg 0x9b 0xFF False False 0+-- | POLY 0x39 INIT 0 REFLINOUT NOXOR+crc8DARC :: CRC8Cfg+crc8DARC = CRCCfg 0x39 0 True True 0+-- | POLY 0xD5 INIT 0 NOREFL XOR 0+crc8DVBS2 :: CRC8Cfg+crc8DVBS2 = CRCCfg 0xD5 0 False False 0+-- | POLY 0x1D INIT 0xFF REFLINOUT XOR 0+crc8EBU :: CRC8Cfg+crc8EBU = CRCCfg 0x1D 0xFF True True 0+-- | POLY 0x1D INIT 0xFD NOREFL XOR 0+crc8ICode :: CRC8Cfg+crc8ICode = CRCCfg 0x1D 0xFD False False 0+-- | POLY 0x07 INIT 0x00 NOREFL XOR 0x55+crc8ITU :: CRC8Cfg+crc8ITU = CRCCfg 0x07 0x00 False False 0x55+-- | POLY 0x31 INIT 0 REFLINOUT XOR 0+crc8Maxim :: CRC8Cfg+crc8Maxim = CRCCfg 0x31 0 True True 0+-- | POLY 0x07 INIT 0xFF REFLINOUT XOR 0+crc8ROHC :: CRC8Cfg+crc8ROHC = CRCCfg 0x07 0xFF True True 0+-- | POLY 0x9b INIT 0 REFLINOUT NOXOR+crc8WCDMA :: CRC8Cfg+crc8WCDMA = CRCCfg 0x9b 0 True True 0++-- | POLY 0x1021 INIT 0x0000 NOREFL NOXOR+crc16CCITZero :: CRC16Cfg+crc16CCITZero = CRCCfg 0x1021 0x0000 False False 0x0000+-- | POLY 0x8005 INIT 0 REFLINOUT XOR 0+crc16Arc :: CRC16Cfg+crc16Arc = CRCCfg 0x8005 0 True True 0+-- | POLY 0x1021 INIT 0x1D0F NOREFL XOR 0+crc16AugCCITT :: CRC16Cfg+crc16AugCCITT = CRCCfg 0x1021 0x1D0F False False 0+-- | POLY 0x8005 INIT 0 NOREFL XOR 0+crc16Buypass :: CRC16Cfg+crc16Buypass = CRCCfg 0x8005 0 False False 0+-- | POLY 0x1021 INIT 0xFFFF NOREFL XOR 0+crc16CCITTFalse :: CRC16Cfg+crc16CCITTFalse = CRCCfg 0x1021 0xFFFF False False 0+-- | POLY 0xC867 INIT 0xFFFF NOREFL XOR 0+crc16CDMA2k :: CRC16Cfg+crc16CDMA2k = CRCCfg 0xC867 0xFFFF False False 0+-- | POLY 0x8005 INIT 0x800D NOREFL XOR 0+crc16DDS110 :: CRC16Cfg+crc16DDS110 = CRCCfg 0x8005 0x800D False False 0+-- | POLY 0x0589 INIT 0 NOREFL XOR 1+crc16DECTR :: CRC16Cfg+crc16DECTR = CRCCfg 0x0589 0 False False 1+-- | POLY 0x0589 INIT 0 NOREFL XOR 0+crc16DECTX :: CRC16Cfg+crc16DECTX = CRCCfg 0x0589 0 False False 0+-- | POLY 0x3D65 INIT 0 REFLINOUT XOR 0xFFFF+crc16DNP :: CRC16Cfg+crc16DNP = CRCCfg 0x3D65 0 True True 0xFFFF+-- | POLY 0x3D65 INIT 0 NOREFL XOR 0xFFFF+crc16EN13757 :: CRC16Cfg+crc16EN13757 = CRCCfg 0x3D65 0 False False 0xFFFF+-- | POLY 0x1021 INIT 0xFFFF NOREFL XOR 0xFFFF+crc16Genibus :: CRC16Cfg+crc16Genibus = CRCCfg 0x1021 0xFFFF False False 0xFFFF+-- | POLY 0x8005 INIT 0 REFLINOUT XOR 0xFFFF+crc16Maxim :: CRC16Cfg+crc16Maxim = CRCCfg 0x8005 0 True True 0xFFFF+-- | POLY 0x1021 INIT 0xFFFF REFLINOUT XOR 0+crc16MCRF4XX :: CRC16Cfg+crc16MCRF4XX = CRCCfg 0x1021 0xFFFF True True 0+-- | POLY 0x1021 INIT 0xB2AA REFLINOUT XOR 0+crc16Riello :: CRC16Cfg+crc16Riello = CRCCfg 0x1021 0xB2AA True True 0+-- | POLY 0x8BB7 INIT 0 NOREFL XOR 0+crc16T10DIF :: CRC16Cfg+crc16T10DIF = CRCCfg 0x8BB7 0 False False 0+-- | POLY 0xA097 INIT 0 NOREFL XOR 0+crc16Teledisk :: CRC16Cfg+crc16Teledisk = CRCCfg 0xA097 0 False False 0+-- | POLY 0x1021 INIT 0x89EC REFLINOUT XOR 0+crc16TMS37157 :: CRC16Cfg+crc16TMS37157 = CRCCfg 0x1021 0x89EC True True 0+-- | POLY 0x8005 INIT 0xFFFF REFLINOUT XOR 0xFFFF+crc16USB :: CRC16Cfg+crc16USB = CRCCfg 0x8005 0xFFFF True True 0xFFFF+-- | POLY 0x1021 INIT 0xC6C6 REFLINOUT XOR 0+crc16CRCA :: CRC16Cfg+crc16CRCA = CRCCfg 0x1021 0xC6C6 True True 0+-- | POLY 0x1021 INIT 0 REFLINOUT XOR 0+crc16Kermit :: CRC16Cfg+crc16Kermit = CRCCfg 0x1021 0 True True 0+-- | POLY 0x8005 INIT 0XFFFF REFLINOUT NOXOR+crc16Modbus :: CRC16Cfg+crc16Modbus = CRCCfg 0x8005 0xFFFF True True 0x0000+-- | POLY 0x1021 INIT 0xFFFF REFLINOUT XOR 0xFFFF+crc16X25 :: CRC16Cfg+crc16X25 = CRCCfg 0x1021 0xFFFF True True 0xFFFF+-- | POLY 0x1021 INIT 0 NOREFL XOR 0+crc16XModem :: CRC16Cfg+crc16XModem = CRCCfg 0x1021 0 False False 0++-- | POLY 0x4C11DB7 INIT 0xFFFFFFFF REFLINOUT XOR 0xFFFFFFFF+crc32IEEE :: CRC32Cfg+crc32IEEE = CRCCfg 0x4C11DB7 0xFFFFFFFF True True 0xFFFFFFFF+-- | POLY 0x4C11DB7 INIT 0xFFFFFFFF NOREFL XOR 0xFFFFFFFF+crc32BZIP2 :: CRC32Cfg+crc32BZIP2 = CRCCfg 0x4C11DB7 0xFFFFFFFF False False 0xFFFFFFFF+-- | POLY 0x4C11DB7 INIT 0xFFFFFFFF NOREFL XOR 0+crc32MPEG2 :: CRC32Cfg+crc32MPEG2 = CRCCfg 0x4C11DB7 0xFFFFFFFF False False 0+-- | POLY 0x4C11DB7 INIT 0 NOREFL XOR 0xFFFFFFFF+crc32POSIX :: CRC32Cfg+crc32POSIX = CRCCfg 0x4C11DB7 0 False False 0xFFFFFFFF++-- | POLY 0x42F0E1EBA9EA3693 INIT 0 NOREFL XOR 0+crc64ECMA182 :: CRC64Cfg+crc64ECMA182 = CRCCfg 0x42F0E1EBA9EA3693 0 False False 0+-- | POLY 0x000000000000001B INIT 0xFFFFFFFFFFFFFFFF REFLINOUT XOR 0xFFFFFFFFFFFFFFFF+crc64GoISO :: CRC64Cfg+crc64GoISO = CRCCfg 0x000000000000001B 0xFFFFFFFFFFFFFFFF True True 0xFFFFFFFFFFFFFFFF+-- | POLY 0x42F0E1EBA9EA3693 INIT 0xFFFFFFFFFFFFFFFF NOREFL XOR 0xFFFFFFFFFFFFFFFF+crc64WE :: CRC64Cfg+crc64WE = CRCCfg 0x42F0E1EBA9EA3693 0xFFFFFFFFFFFFFFFF False False 0xFFFFFFFFFFFFFFFF+-- | POLY 0x42F0E1EBA9EA3693 INIT 0xFFFFFFFFFFFFFFFF REFLINOUT XOR 0xFFFFFFFFFFFFFFFF+crc64XZ :: CRC64Cfg+crc64XZ = CRCCfg 0x42F0E1EBA9EA3693 0xFFFFFFFFFFFFFFFF True True 0xFFFFFFFFFFFFFFFF

@@ -1,48 +0,0 @@--- | CRC16 utilities-module Codec.Circe.CRC16-  ( crc16-  , crc16WithTable-  , crc16Unsafe-  , crc16Table-  ) where--import Codec.Circe.Cfg-import Codec.Circe.Reflect-import Data.Bits-import Data.ByteString.Lazy (ByteString)-import qualified Data.ByteString.Lazy as BS-import Data.Vector.Storable (Vector)-import qualified Data.Vector.Storable as V-import Data.Function-import Data.Monoid-import Data.Semigroup-import Data.Word---- | calculate CRC16 using lookup table generated from config-crc16 :: CRC16Cfg -> ByteString -> Word16-crc16 cfg = crc16WithTable t cfg-  where-    t = V.fromList $ crc16Table $ crcPoly cfg---- | calculate CRC16 with precalculated poly table-crc16WithTable :: Vector Word16 -> CRC16Cfg -> ByteString -> Word16-crc16WithTable t cfg =-  xor (crcFinXor cfg)-    . applyWhen (crcRefOut cfg) ref16-    . crc16Unsafe t (crcRefIn cfg) (crcInit cfg)---- | calculate CRC16 using an efficient lookup table and init value-crc16Unsafe :: Vector Word16 -> Bool -> Word16 -> ByteString -> Word16-crc16Unsafe t refIn = BS.foldl' go-  where-    go crc b = crc `shiftL` 8 `xor` t `V.unsafeIndex` fromIntegral pos-      where-        pos = fromIntegral (crc `shiftR` 8) `xor` applyWhen refIn ref8 b---- | generate lookup table using polynomial-crc16Table :: Word16 -> [Word16]-crc16Table poly = calc <$> [0..255]-  where-    calc = appEndo (stimes (8 :: Int) $ Endo step) . (`shiftL` 8)-      where-        step curByte = applyWhen (testBit curByte 15) (`xor` poly) $ curByte `shiftL` 1

@@ -1,50 +0,0 @@--- | CRC32 utilities-module Codec.Circe.CRC32-  ( crc32-  , crc32WithTable-  , crc32Unsafe-  , crc32Table-  ) where--import Codec.Circe.Cfg-import Codec.Circe.Reflect-import Data.Bits-import Data.ByteString.Lazy (ByteString)-import qualified Data.ByteString.Lazy as BS-import Data.Vector.Storable (Vector)-import qualified Data.Vector.Storable as V-import Data.Function-import Data.Monoid-import Data.Semigroup-import Data.Word---- | calculate CRC32 using lookup table generated from config-crc32 :: CRC32Cfg -> ByteString -> Word32-crc32 cfg = crc32WithTable t cfg-  where-    t = V.fromList $ crc32Table $ crcPoly cfg---- | calculate CRC32 with precalculated poly table.-crc32WithTable :: Vector Word32 -> CRC32Cfg -> ByteString -> Word32-crc32WithTable t cfg =-  xor (crcFinXor cfg)-    . applyWhen (crcRefOut cfg) ref32-    . crc32Unsafe t (crcRefIn cfg) (crcInit cfg)---- | calculate CRC32 using an efficient lookup table and init value-crc32Unsafe :: Vector Word32 -> Bool -> Word32 -> ByteString -> Word32-crc32Unsafe t refIn = BS.foldl' go-  where-    go crc b = crc `shiftL` 8 `xor` t `V.unsafeIndex` fromIntegral pos-      where-        pos = fromIntegral ((crc `xor` (fromIntegral b' `shiftL` 24)) `shiftR` 24) :: Word8-          where-            b' = applyWhen refIn ref8 b---- | generate lookup table using polynomial-crc32Table :: Word32 -> [Word32]-crc32Table poly = calc <$> [0..255]-  where-    calc = appEndo (stimes (8 :: Int) $ Endo step) . (`shiftL` 24)-      where-        step curByte = applyWhen (testBit curByte 31) (`xor` poly) $ curByte `shiftL` 1

@@ -1,43 +0,0 @@--- | CRC configurations-module Codec.Circe.Cfg-  ( CRCCfg(..)-  , CRC16Cfg-  , crc16CCITZero-  , crc16Modbus-  , CRC32Cfg-  , crc32IEEE-  ) where--import Data.Word---- | CRC configuration parameters-data CRCCfg a = CRCCfg-  { crcPoly :: a-    -- ^ polynomial-  , crcInit :: a-    -- ^ initial value-  , crcRefIn :: Bool-    -- ^ reflect input-  , crcRefOut :: Bool-    -- ^ reflect output-  , crcFinXor :: a-    -- ^ final xor-  }-  deriving (Eq, Read, Show)---- | specialized CRC for 'Word16'-type CRC16Cfg = CRCCfg Word16--- | specialized CRC for 'Word32'-type CRC32Cfg = CRCCfg Word32---- | POLY 0x1021 INIT 0x0000 NOREFL NOXOR-crc16CCITZero :: CRC16Cfg-crc16CCITZero = CRCCfg 0x1021 0x0000 False False 0x0000---- | POLY 0x8005 INIT 0XFFFF REFLINOUT NOXOR-crc16Modbus :: CRC16Cfg-crc16Modbus = CRCCfg 0x8005 0xFFFF True True 0x0000---- | POLY 0x4C11DB7 INIT 0xFFFFFFFF REFLINOUT XOR 0xFFFFFFFF-crc32IEEE :: CRC32Cfg-crc32IEEE = CRCCfg 0x4C11DB7 0xFFFFFFFF True True 0xFFFFFFFF

@@ -1,7 +1,9 @@ -- | prettyprinting utilities module Codec.Circe.Pretty-  ( w16+  ( w8+  , w16   , w32+  , w64   , table   ) where @@ -9,24 +11,41 @@ import Data.Word import Numeric +-- | @0x0a@+w8 :: Word8 -> String+w8 w = "0x" ++ w8' w++-- | pretty word8 without 0x prefix+w8' :: Word8 -> String+w8' w = showHex (w `shiftR` 4) "" ++ showHex (w .&. 0xF) ""+ -- | @0x01ab@ w16 :: Word16 -> String w16 w = "0x" ++ w16' w  -- | pretty word16 without 0x prefix w16' :: Word16 -> String-w16' w = w3 ++ w2 ++ w1 ++ w0+w16' w = w8' h ++ w8' l   where-    w3 = showHex (w `shiftR` 12) ""-    w2 = showHex (w `shiftR` 8 .&. 0xF) ""-    w1 = showHex (w `shiftR` 4 .&. 0xF) ""-    w0 = showHex (w .&. 0xF) ""+    h = fromIntegral $ w `shiftR` 8+    l = fromIntegral w  -- | @0x0123abcd@ w32 :: Word32 -> String-w32 w = "0x" ++ w16' h ++ w16' l+w32 w = "0x" ++ w32' w++-- | pretty word32 without 0x prefix+w32' :: Word32 -> String+w32' w = w16' h ++ w16' l   where     h = fromIntegral $ w `shiftR` 16+    l = fromIntegral w++-- | @0x01234567abcdefff@+w64 :: Word64 -> String+w64 w = "0x" ++ w32' h ++ w32' l+  where+    h = fromIntegral $ w `shiftR` 32     l = fromIntegral w  -- | prettyprint 8 cols across

@@ -1,17 +1,30 @@ -- | Reflect bits-module Codec.Circe.Reflect (ref32, ref16, ref8) where+module Codec.Circe.Reflect (ref64, ref32, ref16, ref8) where  import Data.Bits+import Data.Vector.Storable (Vector)+import qualified Data.Vector.Storable as V import Data.Word +-- | Reflect 'Word64'+ref64 :: Word64 -> Word64+ref64 = s1 . s2 . s4 . s8 . s16 . s32+  where+    s1  n = ((n .&. 0xAAAAAAAAAAAAAAAA) `shiftR` 1)  .|. ((n .&. 0x5555555555555555) `shiftL` 1)+    s2  n = ((n .&. 0xCCCCCCCCCCCCCCCC) `shiftR` 2)  .|. ((n .&. 0x3333333333333333) `shiftL` 2)+    s4  n = ((n .&. 0xF0F0F0F0F0F0F0F0) `shiftR` 4)  .|. ((n .&. 0x0F0F0F0F0F0F0F0F) `shiftL` 4)+    s8  n = ((n .&. 0xFF00FF00FF00FF00) `shiftR` 8)  .|. ((n .&. 0x00FF00FF00FF00FF) `shiftL` 8)+    s16 n = ((n .&. 0xFFFF0000FFFF0000) `shiftR` 16) .|. ((n .&. 0x0000FFFF0000FFFF) `shiftL` 16)+    s32 n = (n `shiftR` 32) .|. (n `shiftL` 32)+ -- | Reflect 'Word32' ref32 :: Word32 -> Word32 ref32 = s1 . s2 . s4 . s8 . s16   where-    s1 n = ((n .&. 0xAAAAAAAA) `shiftR` 1) .|. ((n .&. 0x55555555) `shiftL` 1)-    s2 n = ((n .&. 0xCCCCCCCC) `shiftR` 2) .|. ((n .&. 0x33333333) `shiftL` 2)-    s4 n = ((n .&. 0xF0F0F0F0) `shiftR` 4) .|. ((n .&. 0x0F0F0F0F) `shiftL` 4)-    s8 n = ((n .&. 0xFF00FF00) `shiftR` 8) .|. ((n .&. 0x00FF00FF) `shiftL` 8)+    s1  n = ((n .&. 0xAAAAAAAA) `shiftR` 1) .|. ((n .&. 0x55555555) `shiftL` 1)+    s2  n = ((n .&. 0xCCCCCCCC) `shiftR` 2) .|. ((n .&. 0x33333333) `shiftL` 2)+    s4  n = ((n .&. 0xF0F0F0F0) `shiftR` 4) .|. ((n .&. 0x0F0F0F0F) `shiftL` 4)+    s8  n = ((n .&. 0xFF00FF00) `shiftR` 8) .|. ((n .&. 0x00FF00FF) `shiftL` 8)     s16 n = (n `shiftR` 16) .|. (n `shiftL` 16)  -- | Reflect 'Word16'@@ -25,8 +38,40 @@  -- | Reflect 'Word8' ref8 :: Word8 -> Word8-ref8 = s1 . s2 . s4-  where-    s1 n = ((n .&. 0xAA) `shiftR` 1) .|. ((n .&. 0x55) `shiftL` 1)-    s2 n = ((n .&. 0xCC) `shiftR` 2) .|. ((n .&. 0x33) `shiftL` 2)-    s4 n = (n `shiftR` 4) .|. (n `shiftL` 4)+ref8 = V.unsafeIndex ref8Table . fromIntegral++ref8Table :: Vector Word8+ref8Table = V.fromList+  [ 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0+  , 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0+  , 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8+  , 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8+  , 0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4+  , 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4+  , 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec+  , 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc+  , 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2+  , 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2+  , 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea+  , 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa+  , 0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6+  , 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6+  , 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee+  , 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe+  , 0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1+  , 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1+  , 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9+  , 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9+  , 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5+  , 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5+  , 0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed+  , 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd+  , 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3+  , 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3+  , 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb+  , 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb+  , 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7+  , 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7+  , 0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef+  , 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff+  ]

@@ -1,16 +1,99 @@+{-# LANGUAGE BinaryLiterals     #-}+{-# LANGUAGE NumericUnderscores #-}+{-# LANGUAGE OverloadedStrings  #-} module Test.Circe (testCirce) where -import qualified Test.Circe.CRC16 as CRC16-import qualified Test.Circe.CRC32 as CRC32-import qualified Test.Circe.Reflect as Reflect+import Codec.Circe+import Codec.Circe.Reflect+import qualified Data.Vector.Storable as V import Test.Tasty+import Test.Tasty.HUnit  testCirce :: IO () testCirce = defaultMain tests  tests :: TestTree tests = testGroup "Test.Circe"-  [ CRC16.tests-  , CRC32.tests-  , Reflect.tests+  [ testGroup "CRC8"+    [ crc8Test+    ]+  , testGroup "CRC16"+    [ crc16UnsafeTest+    , crc16Test+    ]+  , testGroup "CRC32"+    [ crc32UnsafeTest+    , crc32Test+    ]+  , testGroup "CRC64"+    [ crc64Test+    ]+  , testGroup "Reflect"+    [ ref8Test+    , ref16Test+    , ref32Test+    ]   ]++crc8Test :: TestTree+crc8Test = testCaseSteps "crc8" $ \step -> do+  step "crc8"+  crc8 crc8Cfg "alpha and omega" @?= 0x6f+  crc8 crc8Cfg "black and yellow" @?= 0x67+  step "crc88H2F"+  crc8 crc88H2F "yamborghini high" @?= 0x02+  step "crc8CDMA2k"+  crc8 crc8CDMA2k "asdfgh" @?= 0x79+  step "crc8DARC"+  crc8 crc8DARC "i am god" @?= 0x5a+  step "crc8ITU"+  crc8 crc8ITU "OMG itz GODZILLA!" @?= 0xf9+  step "crc8WCDMA"+  crc8 crc8WCDMA "city of angels" @?= 0x5d++crc16UnsafeTest :: TestTree+crc16UnsafeTest = testCase "crc16Unsafe" $+  crcUnsafe (V.fromList t) False 0 "bosscoxwuzhere" @?= 0xbe42+  where+    t = crc16Table 0x1021++crc16Test :: TestTree+crc16Test = testCaseSteps "crc16" $ \step -> do+  step "modbus"+  crc16 crc16Modbus "hello world" @?= 0xddc7+  step "X25"+  crc16 crc16X25 "city of angels" @?= 0x5386++crc32UnsafeTest :: TestTree+crc32UnsafeTest = testCase "crc32Unsafe" $+  crcUnsafe (V.fromList t) False 0 "hello world" @?= 0x737af2ae+  where+    t = crc32Table 0x4c11db7++crc32Test :: TestTree+crc32Test = testCase "crc32" $ do+  crc32 crc32IEEE "bo$$ cox rulez" @?= 0x75ce60a3+  crc32 crc32IEEE "hello world"    @?= 0x0d4a1185+  crc32 crc32IEEE "YOLO DOLO"      @?= 0xa13ee2ed++crc64Test :: TestTree+crc64Test = testCaseSteps "crc64" $ \step -> do+  step "ECMA182"+  crc64 crc64ECMA182 "fast cars" @?= 0x5c991e3b22f9bd5f+  step "XZ"+  crc64 crc64XZ "goodbye" @?= 0x8F627A49FD449B48++ref8Test :: TestTree+ref8Test = testCase "ref8" $+  ref8 0b1011_1110+   @?= 0b0111_1101++ref16Test :: TestTree+ref16Test = testCase "ref16" $+  ref16 0b1010_1111_0000_0011+    @?= 0b1100_0000_1111_0101++ref32Test :: TestTree+ref32Test = testCase "ref32" $+  ref32 0b1110_0111_0000_0000_1111_1111_1010_1010+    @?= 0b0101_0101_1111_1111_0000_0000_1110_0111

@@ -1,27 +0,0 @@-{-# LANGUAGE OverloadedStrings #-}--module Test.Circe.CRC16 (tests) where--import Codec.Circe.CRC16-import Codec.Circe.Cfg---import Data.Vector.Storable (Vector)-import qualified Data.Vector.Storable as V-import Test.Tasty-import Test.Tasty.HUnit--tests :: TestTree-tests = testGroup "CRC16"-  [ crc16UnsafeTest-  , crc16Test-  ]--crc16UnsafeTest :: TestTree-crc16UnsafeTest = testCase "crc16Unsafe" $-  crc16Unsafe (V.fromList t) False 0 "bosscoxwuzhere" @?= 0xbe42-  where-    t = crc16Table 0x1021--crc16Test :: TestTree-crc16Test = testCaseSteps "crc16" $ \step -> do-  step "modbus"-  crc16 crc16Modbus "hello world" @?= 0xddc7

@@ -1,27 +0,0 @@-{-# LANGUAGE OverloadedStrings #-}--module Test.Circe.CRC32 (tests) where--import Codec.Circe.CRC32-import Codec.Circe.Cfg-import qualified Data.Vector.Storable as V-import Test.Tasty-import Test.Tasty.HUnit--tests :: TestTree-tests = testGroup "CRC32"-  [ crc32UnsafeTest-  , crc32Test-  ]--crc32UnsafeTest :: TestTree-crc32UnsafeTest = testCase "crc32Unsafe" $-  crc32Unsafe (V.fromList t) False 0 "hello world" @?= 0x737af2ae-  where-    t = crc32Table 0x4c11db7--crc32Test :: TestTree-crc32Test = testCase "crc32" $ do-  crc32 crc32IEEE "bo$$ cox rulez" @?= 0x75ce60a3-  crc32 crc32IEEE "hello world"    @?= 0x0d4a1185-  crc32 crc32IEEE "YOLO DOLO"      @?= 0xa13ee2ed

@@ -1,30 +0,0 @@-{-# LANGUAGE BinaryLiterals     #-}-{-# LANGUAGE NumericUnderscores #-}--module Test.Circe.Reflect (tests) where--import Codec.Circe.Reflect-import Test.Tasty-import Test.Tasty.HUnit--tests :: TestTree-tests = testGroup "Reflect"-  [ ref8Test-  , ref16Test-  , ref32Test-  ]--ref8Test :: TestTree-ref8Test = testCase "ref8" $-  ref8 0b1011_1110-   @?= 0b0111_1101--ref16Test :: TestTree-ref16Test = testCase "ref16" $-  ref16 0b1010_1111_0000_0011-    @?= 0b1100_0000_1111_0101--ref32Test :: TestTree-ref32Test = testCase "ref32" $-  ref32 0b1110_0111_0000_0000_1111_1111_1010_1010-    @?= 0b0101_0101_1111_1111_0000_0000_1110_0111