-- For testing the Util module
module Testing.Unit.UtilTests (tests, runU) where

import Test.HUnit

import Language.Sifflet.Util

import Testing.TestUtil

testPar :: Test
testPar = 
    assertAll
       [assertEqual "par (a b c)" "(a b c)" (par "a" ["b", "c"]),
        assertEqual "par (a)" "(a)" (par "a" [])]

f1 :: Int -> Int
f1 x = x + 3

f2 :: Int -> IO Int
f2 x = return $ x + 3

list2 :: [[Int]]
list2 = [[1, 5, 7], [9, 6], [1..5]]

list2plus3 :: [[Int]]
list2plus3 = [[4, 8, 10], [12, 9], [4..8]]

tlist :: [(String, Int)]
tlist = [("a", 21), ("b", 77), ("c", 90)]

testMap2 :: Test
testMap2 = TestCase $ assertEqual "map2" list2plus3 (map2 f1 list2)

testMapM2 :: Test
testMapM2 = TestCase $ assertEqualIO "mapM2" list2plus3 (mapM2 f2 list2)

assertEqualIO :: (Eq b, Show b) => String -> b -> IO b -> IO ()
assertEqualIO label expected expr = do
  {
    result <- expr
  ; assertEqual label expected result
  }

testAdjustAList :: Test
testAdjustAList = 
    assertAll
         [assertEqual "adjustAList a"
                      [("a",24),("b",77),("c",90)]
                      (adjustAList "a" f1 tlist)
         , assertEqual "adjustAList b"
                       [("a",21),("b",80),("c",90)]
                       (adjustAList "b" f1 tlist)
         , assertEqual "adjustAList c"
                       [("a",21),("b",77),("c",93)]
                       (adjustAList "c" f1 tlist)
         , assertEqual "adjustAList d"
                       [("a",21),("b",77),("c",90)]
                       (adjustAList "d" f1 tlist)
         ]

testAdjustAListM :: Test
testAdjustAListM =
    assertAll
         [assertEqualIO "adjustAListM a"
                      [("a",24),("b",77),("c",90)]
                      (adjustAListM "a" f2 tlist)
         , assertEqualIO "adjustAListM b"
                       [("a",21),("b",80),("c",90)]
                       (adjustAListM "b" f2 tlist)
         , assertEqualIO "adjustAListM c"
                       [("a",21),("b",77),("c",93)]
                       (adjustAListM "c" f2 tlist)

         , assertEqualIO "adjustAListM d"
                       [("a",21),("b",77),("c",90)]
                       (adjustAListM "d" f2 tlist)
         ]

tests :: Test
tests = TestList
            [TestLabel "par" testPar
            , TestLabel "map2" testMap2
            , TestLabel "mapM2" testMapM2
            , TestLabel "adjustAList" testAdjustAList
            , TestLabel "adjustAListM" testAdjustAListM
            ]

runU :: IO ()
runU = utestloop tests