{-# LANGUAGE OverloadedStrings #-}
import qualified Data.ByteString as BS
import Test.Tasty
import Test.Tasty.HUnit
import Internal.FixWarnings
main :: IO ()
main = defaultMain tests
tests :: TestTree
tests =
testGroup "FixWarnings"
[ testCase "Removes thing" $ do
-- fixRedundancyWarning 1 (IndividualThings ["foo"]) [input1]
-- @?= Just [output1]
--
-- fixRedundancyWarning 1 (IndividualThings ["bar"]) [input2]
-- @?= Just [output2]
--
-- fixRedundancyWarning 1 (IndividualThings ["baz", "foo"]) [input3]
-- @?= Just [output3]
--
-- fixRedundancyWarning 1 (IndividualThings ["bar"]) [input4]
-- @?= Just [output4]
--
-- fixRedundancyWarning 1 (IndividualThings ["foo", "baz"]) input5
-- @?= Just output5
--
-- fixRedundancyWarning 2 (IndividualThings ["bar"]) input6
-- @?= Just output6
--
-- fixRedundancyWarning 3 (IndividualThings ["bar"]) input7
-- @?= Just output7
--
-- fixRedundancyWarning 1 (IndividualThings ["Bar"]) [input8]
-- @?= Just [output8]
--
-- fixRedundancyWarning 1 (IndividualThings ["two"]) [input9]
-- @?= Just [output9]
--
-- fixRedundancyWarning 1 (IndividualThings ["+~"]) [input10]
-- @?= Just [output10]
--
-- fixRedundancyWarning 1 (IndividualThings [":~:"]) [input11]
-- @?= Just [output11]
--
-- fixRedundancyWarning 1 (IndividualThings ["two"]) [input12]
-- @?= Just [output12]
--
-- fixRedundancyWarning 1 WholeModule input13
-- @?= Just output13
--
-- fixRedundancyWarning 1 WholeModule input14
-- @?= Just output14
--
-- fixRedundancyWarning 1 WholeModule input15
-- @?= Just output15
--
-- fixRedundancyWarning 1 (IndividualThings ["zip", "zipWith"]) input16
-- @?= Just output16
--
-- fixRedundancyWarning 1 (IndividualThings ["Baz"]) input17
-- @?= Just output17
--
-- fixRedundancyWarning 1 (IndividualThings ["+"]) input18
-- @?= Just output18
--
-- fixRedundancyWarning 1 (IndividualThings [":+:"]) input19
-- @?= Just output19
fixRedundancyWarning 1 (IndividualThings ["Foo"]) input20
@?= Just output20
]
input1, output1 :: BS.ByteString
input1 = "import Foo.Bar (foo, bar)"
output1 = "import Foo.Bar (bar)"
input2, output2 :: BS.ByteString
input2 = "import Foo.Bar (foo, bar)"
output2 = "import Foo.Bar (foo)"
input3, output3 :: BS.ByteString
input3 = "import Foo.Bar (foo, bar, baz)"
output3 = "import Foo.Bar (bar)"
input4, output4 :: BS.ByteString
input4 = "import Foo.Bar (foo, bar, baz)"
output4 = "import Foo.Bar (foo, baz)"
input5, output5 :: [BS.ByteString]
input5 = [ "import Foo.Bar ( foo"
, " , bar"
, " , baz"
, " )"
]
output5 = [ "import Foo.Bar ( bar"
, " )"
]
input6, output6 :: [BS.ByteString]
input6 = [ "import Foo.Bar ( foo"
, " , bar"
, " , baz"
, " )"
]
output6 = [ "import Foo.Bar ( foo"
, " , baz"
, " )"
]
input7, output7 :: [BS.ByteString]
input7 = [ "import Foo.Bar"
, " ( foo"
, " , pattern bar"
, " , baz"
, " )"
]
output7 = [ "import Foo.Bar"
, " ( foo"
, " , baz"
, " )"
]
input8, output8 :: BS.ByteString
input8 = "import Foo (foo, Bar(one, two), baz)"
output8 = "import Foo (foo, baz)"
input9, output9 :: BS.ByteString
input9 = "import Foo (foo, Bar(one, two), baz)"
output9 = "import Foo (foo, Bar(one), baz)"
input10, output10 :: BS.ByteString
input10 = "import Foo (foo, (+~), baz)"
output10 = "import Foo (foo, baz)"
input11, output11 :: BS.ByteString
input11 = "import Foo (foo, (:~:)(..), baz)"
output11 = "import Foo (foo, baz)"
input12, output12 :: BS.ByteString
input12 = "import Foo (foo, (:~:)(one, two), baz)"
output12 = "import Foo (foo, (:~:)(one), baz)"
input13, output13 :: [BS.ByteString]
input13 = [ "import Foo"
, " (one, two, three)"
, "import Bar"
]
output13 = [ "import Bar" ]
input14, output14 :: [BS.ByteString]
input14 = [ "import Foo (one"
, " ,two"
, " )"
, "import Bar"
]
output14 = [ "import Bar" ]
input15, output15 :: [BS.ByteString]
input15 = [ "import Foo"
, "import Bar"
]
output15 = [ "import Bar" ]
-- first match is a subsubstring of another term
input16, output16 :: [BS.ByteString]
input16 = [ "import Data.List (zip4, zip, zipWith3, zipWith, zipWith2, zip3)" ]
output16 = [ "import Data.List (zip4, zipWith3, zipWith2, zip3)" ]
input17, output17 :: [BS.ByteString]
input17 = [ "import Foo (Bar( Baz), foo)" ]
output17 = [ "import Foo (Bar, foo)" ]
input18, output18 :: [BS.ByteString]
input18 = [ "import Foo (foo, ( + ))" ]
output18 = [ "import Foo (foo)" ]
input19, output19 :: [BS.ByteString]
input19 = [ "import Foo (foo, ( :+: ) (.. ), bar)" ]
output19 = [ "import Foo (foo, bar)" ]
input20, output20 :: [BS.ByteString]
input20 = [ "import Foo (foo, Foo (.. ))" ]
output20 = [ "import Foo (foo)" ]