redact-0.4.0.0: test/Redact/Markdown/Test.hs
{-# LANGUAGE OverloadedStrings #-}
module Redact.Markdown.Test (tests) where
-- https://hackage.haskell.org/package/tasty
import Test.Tasty (TestTree, testGroup)
-- https://hackage.haskell.org/package/tasty-hunit
import Test.Tasty.HUnit ((@=?), testCase)
-- (redact)
import Redact.Markdown
( Line(NormalLine, RedactLine), Part(Redact, Stet), redact, redact'
, redactLine, redactLine'
)
------------------------------------------------------------------------------
testRedactLine :: TestTree
testRedactLine = testGroup "redactLine"
[ testCase "empty" $ Just (NormalLine []) @=? redactLine ""
, testCase "TT" $ Just (NormalLine [Stet "``"]) @=? redactLine "``"
, testCase "T" $ Nothing @=? redactLine "`"
, testCase "TTT" $ Nothing @=? redactLine "```"
, testCase "a" $ Just (NormalLine [Stet "a"]) @=? redactLine "a"
, testCase "TaT" $
Just (NormalLine [Stet "`", Redact "a", Stet "`"]) @=?
redactLine "`a`"
, testCase "TTa" $ Just (NormalLine [Stet "``a"]) @=? redactLine "``a"
, testCase "aTT" $ Just (NormalLine [Stet "a``"]) @=? redactLine "a``"
, testCase "aT" $ Nothing @=? redactLine "a`"
, testCase "Ta" $ Nothing @=? redactLine "`a"
, testCase "TTaT" $ Nothing @=? redactLine "``a`"
, testCase "TaTT" $ Nothing @=? redactLine "`a``"
, testCase "TaTb" $
Just (NormalLine [Stet "`", Redact "a", Stet "`b"]) @=?
redactLine "`a`b"
, testCase "aTbT" $
Just (NormalLine [Stet "a`", Redact "b", Stet "`"]) @=?
redactLine "a`b`"
, testCase "aTTb" $ Just (NormalLine [Stet "a``b"]) @=? redactLine "a``b"
, testCase "TaTbT" $ Nothing @=? redactLine "`a`b`"
, testCase "aTbTc" $
Just (NormalLine [Stet "a`", Redact "b", Stet "`c"]) @=?
redactLine "a`b`c"
, testCase "TaTbTcT" $
Just
( NormalLine
[Stet "`", Redact "a", Stet "`b`", Redact "c", Stet "`"]
) @=?
redactLine "`a`b`c`"
, testCase "TaTTbTc" $
Just
( NormalLine
[Stet "`", Redact "a", Stet "``", Redact "b", Stet "`c"]
) @=?
redactLine "`a``b`c"
, testCase "TaTTbTTcT" $
Just
( NormalLine
[ Stet "`", Redact "a", Stet "``", Redact "b", Stet "``"
, Redact "c" , Stet "`"
]
) @=? redactLine "`a``b``c`"
, testCase "TaTbTcTd" $
Just
( NormalLine
[Stet "`", Redact "a", Stet "`b`", Redact "c", Stet "`d"]
) @=?
redactLine "`a`b`c`d"
, testCase "aTbTTcTd" $
Just
( NormalLine
[Stet "a`", Redact "b", Stet "``", Redact "c", Stet "`d"]
) @=?
redactLine "a`b``c`d"
, testCase "aTbTcTcT" $
Just
( NormalLine
[Stet "a`", Redact "b", Stet "`c`", Redact "d", Stet "`"]
) @=?
redactLine "a`b`c`d`"
]
------------------------------------------------------------------------------
testRedactLine' :: TestTree
testRedactLine' = testGroup "redactLine'"
[ testCase "empty" $ NormalLine [] @=? redactLine' ""
, testCase "TT" $ NormalLine [Stet "``"] @=? redactLine' "``"
, testCase "T" $ NormalLine [Stet "`"] @=? redactLine' "`"
, testCase "TTT" $ NormalLine [Stet "```"] @=? redactLine' "```"
, testCase "a" $ NormalLine [Stet "a"] @=? redactLine' "a"
, testCase "TaT" $
NormalLine [Stet "`", Redact "a", Stet "`"] @=? redactLine' "`a`"
, testCase "TTa" $ NormalLine [Stet "``a"] @=? redactLine' "``a"
, testCase "aTT" $ NormalLine [Stet "a``"] @=? redactLine' "a``"
, testCase "aT" $ NormalLine [Stet "a`"] @=? redactLine' "a`"
, testCase "Ta" $ NormalLine [Stet "`", Redact "a"] @=? redactLine' "`a"
, testCase "TTaT" $ NormalLine [Stet "``a`"] @=? redactLine' "``a`"
, testCase "TaTT" $
NormalLine [Stet "`", Redact "a", Stet "``"] @=? redactLine' "`a``"
, testCase "TaTb" $
NormalLine [Stet "`", Redact "a", Stet "`b"] @=? redactLine' "`a`b"
, testCase "aTbT" $
NormalLine [Stet "a`", Redact "b", Stet "`"] @=? redactLine' "a`b`"
, testCase "aTTb" $ NormalLine [Stet "a``b"] @=? redactLine' "a``b"
, testCase "TaTbT" $
NormalLine [Stet "`", Redact "a", Stet "`b`"] @=? redactLine' "`a`b`"
, testCase "aTbTc" $
NormalLine [Stet "a`", Redact "b", Stet "`c"] @=? redactLine' "a`b`c"
, testCase "TaTbTcT" $
NormalLine [Stet "`", Redact "a", Stet "`b`", Redact "c", Stet "`"]
@=? redactLine' "`a`b`c`"
, testCase "TaTTbTc" $
NormalLine [Stet "`", Redact "a", Stet "``", Redact "b", Stet "`c"]
@=? redactLine' "`a``b`c"
, testCase "TaTTbTTcT" $
NormalLine
[ Stet "`", Redact "a", Stet "``", Redact "b", Stet "``"
, Redact "c", Stet "`"
]
@=? redactLine' "`a``b``c`"
, testCase "TaTbTcTd" $
NormalLine [Stet "`", Redact "a", Stet "`b`", Redact "c", Stet "`d"]
@=? redactLine' "`a`b`c`d"
, testCase "aTbTTcTd" $
NormalLine [Stet "a`", Redact "b", Stet "``", Redact "c", Stet "`d"]
@=? redactLine' "a`b``c`d"
, testCase "aTbTcTcT" $
NormalLine [Stet "a`", Redact "b", Stet "`c`", Redact "d", Stet "`"]
@=? redactLine' "a`b`c`d`"
]
------------------------------------------------------------------------------
testRedact :: TestTree
testRedact = testGroup "redact"
[ testCase "empty" $ Right [] @=? redact ""
, testCase "newline" $ Right [NormalLine []] @=? redact "\n"
, testCase "newlines" $
Right [NormalLine [], NormalLine []] @=? redact "\n\n"
, testCase "inline_single" $
Right [NormalLine [Stet "a`", Redact "b", Stet "`c"]] @=?
redact "a`b`c\n"
, testCase "inline_multiple" $
Right
[ NormalLine [Stet "a`", Redact "b", Stet "`c"]
, NormalLine
[Stet "`", Redact "d", Stet "`e`", Redact "f", Stet "`"]
] @=? redact "a`b`c\n`d`e`f`\n"
, testCase "inline_invalid" $
Left "inline code not terminated (line 2)" @=? redact "a`b`c\nd`e\n\n"
, testCase "fenced_three" $
Right
[ NormalLine [Stet "```"]
, RedactLine "a`b`c"
, NormalLine [Stet "```"]
] @=? redact "```\na`b`c\n```\n"
, testCase "fenced_extra" $
Right
[ NormalLine [Stet "`````"]
, RedactLine "a`b`c"
, NormalLine [Stet "```````"]
] @=? redact "`````\na`b`c\n```````\n"
, testCase "fenced_multiple" $
Right
[ NormalLine [Stet "a"]
, NormalLine [Stet "```"]
, RedactLine "b"
, RedactLine "c"
, NormalLine [Stet "```"]
, NormalLine [Stet "```"]
, RedactLine "d"
, NormalLine [Stet "```"]
] @=? redact "a\n```\nb\nc\n```\n```\nd\n```\n"
, testCase "fenced_language" $
Right
[ NormalLine [Stet "a"]
, NormalLine [Stet "```haskell"]
, RedactLine "--"
, NormalLine [Stet "```"]
] @=? redact "a\n```haskell\n--\n```\n"
, testCase "fenced_invalid" $
Left "fenced code not terminated (line 4)" @=? redact "a\n```\nb\n"
]
------------------------------------------------------------------------------
testRedact' :: TestTree
testRedact' = testGroup "redact'"
[ testCase "empty" $ [] @=? redact' ""
, testCase "newline" $ [NormalLine []] @=? redact' "\n"
, testCase "newlines" $ [NormalLine [], NormalLine []] @=? redact' "\n\n"
, testCase "inline_single" $
[NormalLine [Stet "a`", Redact "b", Stet "`c"]] @=? redact' "a`b`c\n"
, testCase "inline_multiple" $
[ NormalLine [Stet "a`", Redact "b", Stet "`c"]
, NormalLine [Stet "`", Redact "d", Stet "`e`", Redact "f", Stet "`"]
] @=? redact' "a`b`c\n`d`e`f`\n"
, testCase "inline_invalid" $
[ NormalLine [Stet "a`", Redact "b", Stet "`c"]
, NormalLine [Stet "d`", Redact "e"]
, NormalLine []
] @=? redact' "a`b`c\nd`e\n\n"
, testCase "fenced_three" $
[ NormalLine [Stet "```"]
, RedactLine "a`b`c"
, NormalLine [Stet "```"]
] @=? redact' "```\na`b`c\n```\n"
, testCase "fenced_extra" $
[ NormalLine [Stet "`````"]
, RedactLine "a`b`c"
, NormalLine [Stet "```````"]
] @=? redact' "`````\na`b`c\n```````\n"
, testCase "fenced_multiple" $
[ NormalLine [Stet "a"]
, NormalLine [Stet "```"]
, RedactLine "b"
, RedactLine "c"
, NormalLine [Stet "```"]
, NormalLine [Stet "```"]
, RedactLine "d"
, NormalLine [Stet "```"]
] @=? redact' "a\n```\nb\nc\n```\n```\nd\n```\n"
, testCase "fenced_language" $
[ NormalLine [Stet "a"]
, NormalLine [Stet "```haskell"]
, RedactLine "--"
, NormalLine [Stet "```"]
] @=? redact' "a\n```haskell\n--\n```\n"
, testCase "fenced_invalid" $
[ NormalLine [Stet "a"]
, NormalLine [Stet "```"]
, RedactLine "b"
] @=? redact' "a\n```\nb\n"
]
------------------------------------------------------------------------------
tests :: TestTree
tests = testGroup "Redact.Markdown"
[ testRedactLine
, testRedactLine'
, testRedact
, testRedact'
]