Brace expansion is not correct about language-bash HOT 6 CLOSED

import System.Process (readProcess)

import Text.Regex (subRegex)
import Text.Regex.TDFA (makeRegex, match)
import Test.QuickCheck
import Test.QuickCheck.Monadic (assert, monadicIO, run)
import Language.Bash.Expand (braceExpand)
import Language.Bash.Parse.Word (word)
import Language.Bash.Pretty (prettyText)
import Text.Parsec (parse)

testExpand :: String -> [String]
testExpand s =
  map prettyText $ braceExpand (case parse word "" s of Right w -> w)

charset :: Gen String
charset = elements strs
  where
    strs = ["", ",", "\\{", "\\}", "\\,", "\\ "] ++
           map (:[]) ['a'..'z']

junk :: Int -> Gen String
junk sz = do
    xs <- resize sz $ listOf1 charset
    return $ foldr (++) "" xs

maybeBraced :: Gen String
maybeBraced = do
    s <- junk 10
    frequency [(5, braced s),
               (1, llbraced s),
               (1, lrbraced s),
               (1, rlbraced s),
               (1, rrbraced s),
               (1, str_only s)]
  where
    braced s   = return $ "{" ++ s ++ "}"
    llbraced s = return $ "{" ++ s
    lrbraced s = return $ "}" ++ s
    rlbraced s = return $        s ++ "{"
    rrbraced s = return $        s ++ "}"
    str_only   = return

maybeStr :: Gen String
maybeStr = oneof [blank, maybeBraced]
  where
    blank = return ""

braceExpr :: Gen String
braceExpr = sized braceExpr'
  where
    braceExpr' 0 = maybeStr
    braceExpr' n
      | n > 0 = do
          x <- braceExpr' $ n `quot` 2
          y <- braceExpr' $ n `quot` 2
          return $ x ++ y
      | otherwise = error "wao"

expandWithBash :: String -> IO String
expandWithBash str = do
    expn <- readProcess "/bin/bash" ["-c", "echo " ++ str] ""
    return $ filter (\x -> x /= '\r' && x /= '\n') expn

prop_expandsLikeBash :: String -> Property
prop_expandsLikeBash str = monadicIO test
  where
    re = makeRegex "\\\\(.)"
    test = do
        bash <- run $ expandWithBash str
        let expn = testExpand str
            joined = unwords expn
            m = match re joined
            check = if m then subRegex re joined "\\1" else joined
        run $ putStrLn bash
        run $ putStrLn check
        assert $ bash == check

main :: IO ()
main = quickCheck $ forAll braceExpr prop_expandsLikeBash