Use === more widely in tests
authorBryan O'Sullivan <bos@serpentine.com>
Sun, 21 May 2017 04:56:30 +0000 (21:56 -0700)
committerBryan O'Sullivan <bos@serpentine.com>
Sun, 21 May 2017 04:56:30 +0000 (21:56 -0700)
tests/Tests/Properties.hs

index 1f00037..94a8705 100644 (file)
@@ -62,10 +62,10 @@ t_pack_unpack       = (T.unpack . T.pack) `eq` id
 tl_pack_unpack      = (TL.unpack . TL.pack) `eq` id
 t_stream_unstream   = (S.unstream . S.stream) `eq` id
 tl_stream_unstream  = (SL.unstream . SL.stream) `eq` id
-t_reverse_stream t  = (S.reverse . S.reverseStream) t == t
-t_singleton c       = [c] == (T.unpack . T.singleton) c
-tl_singleton c      = [c] == (TL.unpack . TL.singleton) c
-tl_unstreamChunks x = f 11 x == f 1000 x
+t_reverse_stream t  = (S.reverse . S.reverseStream) t === t
+t_singleton c       = [c] === (T.unpack . T.singleton) c
+tl_singleton c      = [c] === (TL.unpack . TL.singleton) c
+tl_unstreamChunks x = f 11 x === f 1000 x
     where f n = SL.unstreamChunks n . S.streamList
 tl_chunk_unchunk    = (TL.fromChunks . TL.toChunks) `eq` id
 tl_from_to_strict   = (TL.fromStrict . TL.toStrict) `eq` id
@@ -76,13 +76,13 @@ encodeL1 = B.pack . map (fromIntegral . fromEnum) . T.unpack
 encodeLazyL1 :: TL.Text -> BL.ByteString
 encodeLazyL1 = BL.fromChunks . map encodeL1 . TL.toChunks
 
-t_ascii t    = E.decodeASCII (E.encodeUtf8 a) == a
+t_ascii t    = E.decodeASCII (E.encodeUtf8 a) === a
     where a  = T.map (\c -> chr (ord c `mod` 128)) t
-tl_ascii t   = EL.decodeASCII (EL.encodeUtf8 a) == a
+tl_ascii t   = EL.decodeASCII (EL.encodeUtf8 a) === a
     where a  = TL.map (\c -> chr (ord c `mod` 128)) t
-t_latin1 t   = E.decodeLatin1 (encodeL1 a) == a
+t_latin1 t   = E.decodeLatin1 (encodeL1 a) === a
     where a  = T.map (\c -> chr (ord c `mod` 256)) t
-tl_latin1 t  = EL.decodeLatin1 (encodeLazyL1 a) == a
+tl_latin1 t  = EL.decodeLatin1 (encodeLazyL1 a) === a
     where a  = TL.map (\c -> chr (ord c `mod` 256)) t
 t_utf8       = forAll genUnicode $ (E.decodeUtf8 . E.encodeUtf8) `eq` id
 t_utf8'      = forAll genUnicode $ (E.decodeUtf8' . E.encodeUtf8) `eq` (id . Right)
@@ -113,7 +113,7 @@ t_utf8_undecoded = forAll genUnicode $ \t ->
   let b = E.encodeUtf8 t
       ls = concatMap (leftover . E.encodeUtf8 . T.singleton) . T.unpack $ t
       leftover = (++ [B.empty]) . init . tail . B.inits
-  in (map snd . feedChunksOf 1 E.streamDecodeUtf8) b == ls
+  in (map snd . feedChunksOf 1 E.streamDecodeUtf8) b === ls
 
 data Badness = Solo | Leading | Trailing
              deriving (Eq, Show)
@@ -203,8 +203,8 @@ t_mconcat         = unsquare $
                     mconcat `eq` (unpackS . mconcat . L.map T.pack)
 tl_mconcat        = unsquare $
                     mconcat `eq` (unpackS . mconcat . L.map TL.pack)
-t_mempty          = mempty == (unpackS (mempty :: T.Text))
-tl_mempty         = mempty == (unpackS (mempty :: TL.Text))
+t_mempty          = mempty === (unpackS (mempty :: T.Text))
+tl_mempty         = mempty === (unpackS (mempty :: TL.Text))
 t_IsString        = fromString  `eqP` (T.unpack . fromString)
 tl_IsString       = fromString  `eqP` (TL.unpack . fromString)
 
@@ -732,7 +732,7 @@ tl_indices (NotEmpty s) = lazyIndices s `eq` S.indices s
           conc = T.concat . TL.toChunks
 t_indices_occurs = unsquare $ \(NotEmpty t) ts ->
     let s = T.intercalate t ts
-    in Slow.indices t s == indices t s
+    in Slow.indices t s === indices t s
 
 -- Bit shifts.
 shiftL w = forAll (choose (0,width-1)) $ \k -> Bits.shiftL w k == U.shiftL w k
@@ -824,18 +824,18 @@ tb_formatRealFloat_double (a::Double) = tb_formatRealFloat a
 -- Reading.
 
 t_decimal (n::Int) s =
-    T.signed T.decimal (T.pack (show n) `T.append` t) == Right (n,t)
+    T.signed T.decimal (T.pack (show n) `T.append` t) === Right (n,t)
     where t = T.dropWhile isDigit s
 tl_decimal (n::Int) s =
-    TL.signed TL.decimal (TL.pack (show n) `TL.append` t) == Right (n,t)
+    TL.signed TL.decimal (TL.pack (show n) `TL.append` t) === Right (n,t)
     where t = TL.dropWhile isDigit s
 t_hexadecimal m s ox =
-    T.hexadecimal (T.concat [p, T.pack (showHex n ""), t]) == Right (n,t)
+    T.hexadecimal (T.concat [p, T.pack (showHex n ""), t]) === Right (n,t)
     where t = T.dropWhile isHexDigit s
           p = if ox then "0x" else ""
           n = getPositive m :: Int
 tl_hexadecimal m s ox =
-    TL.hexadecimal (TL.concat [p, TL.pack (showHex n ""), t]) == Right (n,t)
+    TL.hexadecimal (TL.concat [p, TL.pack (showHex n ""), t]) === Right (n,t)
     where t = TL.dropWhile isHexDigit s
           p = if ox then "0x" else ""
           n = getPositive m :: Int
@@ -883,7 +883,7 @@ t_take_drop_16 m t = T.append (takeWord16 n t) (dropWord16 n t) === t
   where n = small m
 t_use_from t = monadicIO $ assert . (==t) =<< run (useAsPtr t fromPtr)
 
-t_copy t = T.copy t == t
+t_copy t = T.copy t === t
 
 -- Regression tests.
 s_filter_eq s = S.filter p t == S.streamList (filter p s)