From 1b4f53266cadfbd54f8198908424b4890fb1755f Mon Sep 17 00:00:00 2001
From: michaelt <what_is_it_to_do_anything@yahoo.com>
Date: Thu, 26 Dec 2013 11:38:06 -0500
Subject: [PATCH] missing case in decodeUtf8

---
 Pipes/Text.hs | 22 ++++++++++++----------
 test/Test.hs  | 15 +++++----------
 2 files changed, 17 insertions(+), 20 deletions(-)

diff --git a/Pipes/Text.hs b/Pipes/Text.hs
index d62aee7..e8b64dc 100644
--- a/Pipes/Text.hs
+++ b/Pipes/Text.hs
@@ -141,6 +141,7 @@ module Pipes.Text  (
 import Control.Exception (throwIO, try)
 import Control.Monad (liftM, unless)
 import Control.Monad.Trans.State.Strict (StateT(..))
+import Data.Monoid ((<>))
 import qualified Data.Text as T
 import qualified Data.Text.IO as T
 import qualified Data.Text.Encoding as TE
@@ -590,16 +591,17 @@ count c p = P.fold (+) 0 id (p >-> P.map (fromIntegral . T.count c))
 -- into a Pipe of Text
 
 decodeUtf8 :: Monad m => Producer ByteString m r -> Producer Text m (Producer ByteString m r)
-decodeUtf8 = go PE.streamDecodeUtf8 where
-  go dec0 p = do 
-     x <- lift (next p)
-     case x of Left r -> return (return r)
-               Right (chunk, p') -> 
-                 case dec0 chunk of PE.Some text _ dec -> do yield text
-                                                             go dec p'
-                                    PE.Other text bs -> do yield text
-                                                           return (do yield bs
-                                                                      p')
+decodeUtf8 = go B.empty PE.streamDecodeUtf8 where
+  go carry dec0 p = do 
+     x <- lift (next p) 
+     case x of Left r -> return (do yield carry
+                                    return r)
+               Right (chunk, p') -> case dec0 chunk of 
+                   PE.Some text carry2 dec -> do yield text
+                                                 go carry2 dec p'
+                   PE.Other text bs -> do yield text 
+                                          return (do yield bs
+                                                     p')
 
 -- | Splits a 'Producer' after the given number of characters
 splitAt
diff --git a/test/Test.hs b/test/Test.hs
index 66351d1..53dca6a 100644
--- a/test/Test.hs
+++ b/test/Test.hs
@@ -23,17 +23,16 @@ import qualified Pipes.Text.Internal as PE
 import qualified Pipes.Text as TP
 import qualified Pipes.ByteString as BP 
 import qualified Pipes as P 
-
-
 import Debug.Trace
+
 main :: IO ()
 main = defaultMain [tests]
 -- >>> :main  -a 10000
 
 tests = testGroup "stream_decode" [
   -- testProperty "t_utf8_incr_valid" t_utf8_incr_valid,
-  testProperty "t_utf8_incr_mixed" t_utf8_incr_mixed,
-   testProperty "t_utf8_incr_pipe" t_utf8_incr_pipe]
+--  testProperty "t_utf8_incr_mixed" t_utf8_incr_mixed ] -- ,
+  testProperty "t_utf8_incr_pipe" t_utf8_incr_pipe]
 
 t_utf8_incr_valid  = do
         Positive n <- arbitrary
@@ -68,23 +67,19 @@ t_utf8_incr_mixed  = do
     chunk n bs = let (a,b) = B.splitAt n bs in if B.null a then [] else a : chunk n b
     appendBytes txt bts = E.encodeUtf8 txt <> B.pack bts ; (<>) = B.append
 
-
-
-
 t_utf8_incr_pipe  = do    
        Positive  m <- arbitrary
        Positive n  <- arbitrary  
        txt         <- genUnicode
        let chunkSize = mod n 7 + 1
-           bytesLength = mod 20 m
+           bytesLength = mod 3 m
        forAll (vector bytesLength) $ 
               (BL.toStrict . BP.toLazy . roundtrip . P.each . chunk chunkSize . appendBytes txt) 
               `eq` 
               appendBytes txt
     where 
     roundtrip :: Monad m => P.Producer B.ByteString m r -> P.Producer B.ByteString m r
-    roundtrip p = do pbs <- TP.decodeUtf8 p P.>-> TP.encodeUtf8
-                     pbs
+    roundtrip p = join (TP.decodeUtf8 p P.>-> TP.encodeUtf8) 
     chunk n bs = let (a,b) = B.splitAt n bs in if B.null a then [] else a : chunk n b
     appendBytes txt bts = E.encodeUtf8 txt <> B.pack bts ; (<>) = B.append
 
-- 
2.41.0