{-# LANGUAGE DeriveDataTypeable, OverloadedStrings #-}

module Tests.Test.HUnitPlus.Base(tests) where

import Control.Exception(Exception,
                         throwIO)
import Data.List
import Data.Typeable
import Debug.Trace
import Distribution.TestSuite(Test(..),
                              TestInstance(..),
                              Result(..),
                              Progress(..),
                              testGroup)
import Test.HUnitPlus.Base
import Test.HUnitPlus.Reporting

import qualified Data.HashMap.Strict as HashMap
import qualified Data.HashSet as HashSet
import qualified Tests.Test.HUnitPlus.ReporterUtils as Utils

type ReportEvent = Utils.ReportEvent

loggingReporter = Utils.loggingReporter

makeTestCase :: (Test, String, [String], Counts, [ReportEvent]) -> Test
makeTestCase (Test TestInstance { name = actualName,
                                  tags = actualTags,
                                  run = runInnerTest },
              expectedName, expectedTags, expectedCounts, expectedEvents) =
  let
    initState = State { stCounts = zeroCounts, stName = "", stPath = [],
                        stOptions = HashMap.empty, stOptionDescs = [] }

    genResult actualCounts actualEvents =
      let
        nameErr =
          if actualName /= expectedName
            then ["Expected name \"" ++ expectedName ++
                  "\" but got \"" ++ actualName ++ "\""]
            else []
        tagsErr =
          if HashSet.fromList expectedTags /= HashSet.fromList actualTags
            then ("Expected tags " ++ show expectedTags ++
                  " but got " ++ show actualTags) : nameErr
            else nameErr
        countsErr =
          if expectedCounts /= actualCounts
            then ("Expected counts " ++ show expectedCounts ++
                  " but got " ++ show actualCounts) : tagsErr
            else tagsErr
        eventsErr =
          if expectedEvents /= actualEvents
            then ("Expected reporting events " ++ show expectedEvents ++
                  " but got " ++ show actualEvents) : countsErr
            else countsErr
      in case eventsErr of
        [] -> Finished Pass
        _ -> Finished (Fail (intercalate "\n" eventsErr))

    runRealTest =
      do
        (_, State { stCounts = actualCounts }, actualEvents) <-
          executeTest loggingReporter initState [] runInnerTest
        return (genResult actualCounts actualEvents)

    testInstance = TestInstance { name = actualName, tags = [], options = [],
                                  setOption = (\_ _ -> Right testInstance),
                                  run = runRealTest }
  in
    Test testInstance

oneFail :: Counts
oneFail = zeroCounts { cFailures = 1 }

oneError :: Counts
oneError = zeroCounts { cErrors = 1 }

oneAssert :: Counts
oneAssert = zeroCounts { cAsserts = 1, cCaseAsserts = 1 }

twoFails :: Counts
twoFails = zeroCounts { cFailures = 2 }

twoErrors :: Counts
twoErrors = zeroCounts { cErrors = 2 }

twoAsserts :: Counts
twoAsserts = zeroCounts { cAsserts = 2, cCaseAsserts = 2 }

oneFailOneAssert :: Counts
oneFailOneAssert = zeroCounts { cFailures = 1, cAsserts = 1, cCaseAsserts = 1 }

twoFailsOneAssert :: Counts
twoFailsOneAssert = zeroCounts { cFailures = 2, cAsserts = 1, cCaseAsserts = 1 }

oneFailOneAssertOneError :: Counts
oneFailOneAssertOneError =
  zeroCounts { cFailures = 1, cErrors = 1, cAsserts = 1, cCaseAsserts = 1 }

oneErrorOneAssert :: Counts
oneErrorOneAssert = zeroCounts { cErrors = 1, cAsserts = 1, cCaseAsserts = 1 }

oneFailTwoAsserts :: Counts
oneFailTwoAsserts = zeroCounts { cFailures = 1, cAsserts = 2, cCaseAsserts = 2 }

twoFailsTwoAsserts :: Counts
twoFailsTwoAsserts = zeroCounts { cFailures = 2, cAsserts = 2, cCaseAsserts = 2 }

twoErrorsTwoAsserts :: Counts
twoErrorsTwoAsserts = zeroCounts { cErrors = 2, cAsserts = 2, cCaseAsserts = 2 }

externalTestPass :: Test
externalTestPass =
  let
    runTest = return (Finished Pass)

    testInstance =  TestInstance { name = "externalTestPass", tags = [],
                                   options = [], run = runTest,
                                   setOption = (\_ _ -> return testInstance) }
  in
    Test testInstance

externalTestEventuallyPass :: Test
externalTestEventuallyPass =
  let
    runTest = return (eventually Pass)

    testInstance =  TestInstance { name = "externalTestEventuallyPass",
                                   tags = [], options = [], run = runTest,
                                   setOption = (\_ _ -> return testInstance) }
  in
    Test testInstance

externalTestFail :: Test
externalTestFail =
  let
    runTest = return (Finished (Fail "External Test Failed"))

    testInstance =  TestInstance { name = "externalTestFail", tags = [],
                                   options = [], run = runTest,
                                   setOption = (\_ _ -> return testInstance) }
  in
    Test testInstance

externalTestEventuallyFail :: Test
externalTestEventuallyFail =
  let
    runTest = return (eventually (Fail "External Test Failed"))

    testInstance =  TestInstance { name = "externalTestEventuallyFail",
                                   tags = [], options = [], run = runTest,
                                   setOption = (\_ _ -> return testInstance) }
  in
    Test testInstance

externalTestError :: Test
externalTestError =
  let
    runTest = return (Finished (Error "External Test Error"))

    testInstance =  TestInstance { name = "externalTestError", tags = [],
                                   options = [], run = runTest,
                                   setOption = (\_ _ -> return testInstance) }
  in
    Test testInstance

externalTestEventuallyError :: Test
externalTestEventuallyError =
  let
    runTest = return (eventually (Error "External Test Error"))

    testInstance =  TestInstance { name = "externalTestEventuallyError",
                                   tags = [], options = [], run = runTest,
                                   setOption = (\_ _ -> return testInstance) }
  in
    Test testInstance

eventually :: Result -> Progress
eventually result =
  Progress "."
           (return (Progress ".."
                             (return (Progress "..."
                                               (return (Finished result))))))

externalTestException :: Test
externalTestException =
  let
    runTest = error "Exception Message" >> return (Finished Pass)

    testInstance =  TestInstance { name = "externalTestException",
                                   tags = [], options = [], run = runTest,
                                   setOption = (\_ _ -> return testInstance) }
  in
    Test testInstance

data TestException = TestException Bool
  deriving (Typeable, Show, Eq)

instance Exception TestException

testCases :: [(Test, String, [String], Counts, [ReportEvent])]
testCases = [
    -- Test low-level functions
    ("logAssert" ~: logAssert, "logAssert", [], oneAssert, []),
    ("logFailure" ~: logFailure "Fail Message", "logFailure", [],
     oneFail, [Utils.Failure "Fail Message"]),
    ("logError" ~: logError "Error Message", "logError", [],
     oneError, [Utils.Error "Error Message"]),
    ("logSysout" ~: logSysout "Sysout Message", "logSysout", [],
     zeroCounts, [Utils.SystemOut "Sysout Message"]),
    ("logSyserr" ~: logSyserr "Syserr Message", "logSyserr", [],
     zeroCounts, [Utils.SystemErr "Syserr Message"]),
    ("logAssert_twice" ~: do logAssert; logAssert,
     "logAssert_twice", [], twoAsserts, []),
    ("logFailure_twice" ~: do logFailure "Fail Message\n"
                              logFailure "Fail Message 2\n",
     "logFailure_twice", [], oneFail,
     [Utils.Failure "Fail Message\n", Utils.Failure "Fail Message 2\n"]),
    ("logError_twice" ~: do logError "Error Message\n"
                            logError "Error Message 2\n",
     "logError_twice", [], oneError,
     [Utils.Error "Error Message\n", Utils.Error "Error Message 2\n"]),
    -- Test assertion functions
    ("assertSuccess" ~: assertSuccess, "assertSuccess", [], oneAssert, []),
    ("assertSuccess_twice" ~: do assertSuccess; assertSuccess,
     "assertSuccess_twice", [], twoAsserts, []),
    ("assertFailure" ~: assertFailure "Fail Message", "assertFailure",
     [], oneFailOneAssert, [Utils.Failure "Fail Message"]),
    ("assertFailure_twice" ~: do assertFailure "Fail Message\n"
                                 assertFailure "Fail Message 2\n",
     "assertFailure_twice", [], oneFailTwoAsserts,
     [Utils.Failure "Fail Message\n", Utils.Failure "Fail Message 2\n"]),
    ("assertSuccess_assertFailure" ~: do assertSuccess
                                         assertFailure "Fail Message",
     "assertSuccess_assertFailure", [], oneFailTwoAsserts,
     [Utils.Failure "Fail Message"]),
    ("assertFailure_assertSuccess" ~: do assertFailure "Fail Message"
                                         assertSuccess,
     "assertFailure_assertSuccess", [], oneFailTwoAsserts,
     [Utils.Failure "Fail Message"]),
    ("abortError" ~: abortError "Error Message", "abortError", [], oneError,
     [Utils.Error "Error Message"]),
    ("abortFailure" ~: abortFailure "Failure Message", "abortFailure",
     [], oneFail, [Utils.Failure "Failure Message"]),
    ("assertFailure_abortError" ~: do assertFailure "Failure Message"
                                      abortError "Error Message",
     "assertFailure_abortError", [], oneFailOneAssertOneError,
     [Utils.Failure "Failure Message", Utils.Error "Error Message"]),
    ("assertFailure_abortFailure" ~: do assertFailure "Failure Message"
                                        abortFailure "Failure Message 2",
     "assertFailure_abortFailure", [], oneFailOneAssert,
     [Utils.Failure "Failure Message", Utils.Failure "Failure Message 2"]),
    ("abortError_assertFailure" ~: do abortError "Error Message"
                                      assertFailure "Failure Message",
     "abortError_assertFailure", [], oneError, [Utils.Error "Error Message"]),
    ("abortFailure_assertFailure" ~: do abortFailure "Failure Message"
                                        assertFailure "Failure Message 2",
     "abortFailure_assertFailure", [], oneFail,
     [Utils.Failure "Failure Message"]),
    ("assertBool_True" ~: assertBool "Fail Message" True,
     "assertBool_True", [], oneAssert, []),
    ("assertBool_False" ~: assertBool "Fail Message" False, "assertBool_False",
     [], oneFailOneAssert, [Utils.Failure "Fail Message"]),
    ("assertString_empty" ~: assertString "",
     "assertString_empty", [], oneAssert, []),
    ("assertString_nonempty" ~: assertString "non-empty",
     "assertString_nonempty", [], oneFailOneAssert, [Utils.Failure "non-empty"]),
    ("assertEqual_eq" ~: assertEqual "Prefix" 3 3,
     "assertEqual_eq", [], oneAssert, []),
    ("assertEqual_neq" ~: assertEqual "Prefix" 3 4,
     "assertEqual_neq", [], oneFailOneAssert,
     [Utils.Failure "Prefix\nexpected: 3\nbut got: 4"]),
    ("assertThrows_nothrow" ~: assertThrows (\(TestException _) -> assertSuccess)
                                            (return ()),
     "assertThrows_nothrow", [], oneFailOneAssert,
     [Utils.Failure "expected exception but computation finished normally"]),
    ("assertThrows_badthrow" ~: assertThrows (TestException False @=?)
                                             (throwIO (TestException True)),
     "assertThrows_badthrow", [], oneFailOneAssert,
     [Utils.Failure "expected: TestException False\nbut got: TestException True"]),
    ("assertThrows_goodthrow" ~: assertThrows (TestException True @=?)
                                              (throwIO (TestException True)),
     "assertThrows_goodthrow", [], oneAssert, []),
    ("assertThrowsExact_nothrow" ~: assertThrowsExact (TestException True)
                                                      (return ()),
     "assertThrowsExact_nothrow", [], oneFailOneAssert,
     [Utils.Failure ("expected exception TestException True but computation finished normally")]),
    ("assertThrowsExact_badthrow" ~:
       assertThrowsExact (TestException False) (throwIO (TestException True)),
     "assertThrowsExact_badthrow", [], oneFailOneAssert,
     [Utils.Failure ("expected exception TestException False but got TestException True")]),
    ("assertThrowsExact_goodthrow" ~:
       assertThrowsExact (TestException True) (throwIO (TestException True)),
     "assertThrowsExact_goodthrow", [], oneAssert, []),
    -- Assertable instances
    ("assert_Unit" ~: assert (), "assert_Unit", [], zeroCounts, []),
    ("assert_True" ~: assert True, "assert_True", [], oneAssert, []),
    ("assert_False" ~: assert False, "assert_False",
     [], oneFailOneAssert, [Utils.Failure ""]),
    ("assertWithMsg_True" ~: assertWithMsg "Message" True,
     "assertWithMsg_True", [], oneAssert, []),
    ("assertWithMsg_False" ~: assertWithMsg "Message" False,
     "assertWithMsg_False", [], oneFailOneAssert, [Utils.Failure "Message"]),
    ("assert_String_empty" ~: assert ("" :: String),
     "assert_String_empty", [], oneAssert, []),
    ("assert_String_nonempty" ~: assert ("non-empty" :: String), "assert_String_nonempty",
     [], oneFailOneAssert, [Utils.Failure "non-empty"]),
    ("assertWithMsg_String_empty" ~: assertWithMsg "Prefix: " ("" :: String),
     "assertWithMsg_String_empty", [], oneAssert, []),
    ("assertWithMsg_String_nonempty" ~: assertWithMsg "Prefix: " ("non-empty" :: String),
     "assertWithMsg_String_nonempty", [], oneFailOneAssert,
     [Utils.Failure "Prefix: non-empty"]),
    ("assert_list_assertSuccess_twice" ~: assert [assertSuccess, assertSuccess],
     "assert_list_assertSuccess_twice", [], twoAsserts, []),
    ("assert_list_assertFailure_twice" ~:
       assert [assertFailure "Fail Message\n", assertFailure "Fail Message 2\n"],
     "assert_list_assertFailure_twice", [], oneFailTwoAsserts,
     [Utils.Failure "Fail Message\n", Utils.Failure "Fail Message 2\n"]),
    ("assert_list_assertSuccess_assertFailure" ~:
       assert [assertSuccess, assertFailure "Fail Message"],
     "assert_list_assertSuccess_assertFailure", [], oneFailTwoAsserts,
     [Utils.Failure "Fail Message"]),
    ("assert_list_assertFailure_assertSuccess" ~:
       assert [assertFailure "Fail Message", assertSuccess],
     "assert_list_assertFailure_assertSuccess", [], oneFailTwoAsserts,
     [Utils.Failure "Fail Message"]),
    ("assertWithMsg_list_assertSuccess_twice" ~:
       assertWithMsg "Prefix: " [assertSuccess, assertSuccess],
     "assertWithMsg_list_assertSuccess_twice", [], twoAsserts, []),
    ("assertWithMsg_list_assertFailure_twice" ~:
       assertWithMsg "Prefix: " [assertFailure "Fail Message\n",
                                 assertFailure "Fail Message 2\n"],
     "assertWithMsg_list_assertFailure_twice", [], oneFailTwoAsserts,
     [Utils.Failure "Prefix: Fail Message\n",
      Utils.Failure "Prefix: Fail Message 2\n"]),
    ("assertWithMsg_list_assertSuccess_assertFailure" ~:
       assertWithMsg "Prefix: " [assertSuccess, assertFailure "Fail Message"],
     "assertWithMsg_list_assertSuccess_assertFailure", [], oneFailTwoAsserts,
     [Utils.Failure "Prefix: Fail Message"]),
    ("assertWithMsg_list_assertFailure_assertSuccess" ~:
       assertWithMsg "Prefix: " [assertFailure "Fail Message", assertSuccess],
     "assertWithMsg_list_assertFailure_assertSuccess", [], oneFailTwoAsserts,
     [Utils.Failure "Prefix: Fail Message"]),
    ("assert_Pass" ~: assert Pass, "assert_Pass", [], oneAssert, []),
    ("assert_Fail" ~: assert (Fail "Fail Message"), "assert_Fail", [],
     oneFailOneAssert, [Utils.Failure "Fail Message"]),
    ("assert_Error" ~: assert (Error "Error Message"), "assert_Error", [],
     oneError, [Utils.Error "Error Message"]),
    ("assertWithMsg_Pass" ~: assertWithMsg "Prefix: " Pass,
     "assertWithMsg_Pass", [], oneAssert, []),
    ("assertWithMsg_Fail" ~: assertWithMsg "Prefix: " (Fail "Fail Message"),
     "assertWithMsg_Fail", [], oneFailOneAssert,
     [Utils.Failure "Prefix: Fail Message"]),
    ("assertWithMsg_Error" ~:
       assertWithMsg "Prefix: " (Error "Error Message"),
     "assertWithMsg_Error", [], oneError, [Utils.Error "Prefix: Error Message"]),
    ("assert_eventually_Pass" ~: assert (eventually Pass),
     "assert_eventually_Pass", [], oneAssert, []),
    ("assert_eventually_Fail" ~: assert (eventually (Fail "Fail Message")),
     "assert_eventually_Fail", [], oneFailOneAssert,
     [Utils.Failure "Fail Message"]),
    ("assert_eventually_Error" ~: assert (eventually (Error "Error Message")),
     "assert_eventually_Error", [], oneError, [Utils.Error "Error Message"]),
    ("assertWithMsg_eventually_Pass" ~: assert (eventually Pass),
     "assertWithMsg_eventually_Pass", [], oneAssert, []),
    ("assertWithMsg_eventually_Fail" ~:
       assertWithMsg "Prefix: " (eventually (Fail "Fail Message")),
     "assertWithMsg_eventually_Fail", [], oneFailOneAssert,
     [Utils.Failure "Prefix: Fail Message"]),
    ("assertWithMsg_eventually_Error" ~:
       assertWithMsg "Prefix: " (eventually (Error "Error Message")),
     "assertWithMsg_eventually_Error", [], oneError,
     [Utils.Error "Prefix: Error Message"]),
    -- Monadized assertable instances
    ("assert_return_Unit" ~: assert (return () :: IO ()),
     "assert_return_Unit", [], zeroCounts, []),
    ("assert_return_True" ~: assert (return True :: IO Bool),
     "assert_return_True", [], oneAssert, []),
    ("assert_return_False" ~: assert (return False :: IO Bool),
     "assert_return_False", [], oneFailOneAssert, [Utils.Failure ""]),
    ("assertWithMsg_return_True" ~:
       assertWithMsg "Message" (return True :: IO Bool),
     "assertWithMsg_return_True", [], oneAssert, []),
    ("assertWithMsg_return_False" ~:
       assertWithMsg "Message" (return False :: IO Bool),
     "assertWithMsg_return_False", [], oneFailOneAssert,
     [Utils.Failure "Message"]),
    ("assert_return_String_empty" ~: assert (return "" :: IO String),
     "assert_return_String_empty", [], oneAssert, []),
    ("assert_return_String_nonempty" ~: assert (return "non-empty" :: IO String),
     "assert_return_String_nonempty", [], oneFailOneAssert,
     [Utils.Failure "non-empty"]),
    ("assertWithMsg_return_String_empty" ~:
       assertWithMsg "Prefix: " (return "" :: IO String),
     "assertWithMsg_return_String_empty", [], oneAssert, []),
    ("assertWithMsg_return_String_nonempty" ~:
       assertWithMsg "Prefix: " (return "non-empty" :: IO String),
     "assertWithMsg_return_String_nonempty", [], oneFailOneAssert,
     [Utils.Failure "Prefix: non-empty"]),
    ("assert_return_list_assertSuccess_twice" ~:
       assert (return [assertSuccess, assertSuccess] :: IO [Assertion]),
     "assert_return_list_assertSuccess_twice", [], twoAsserts, []),
    ("assert_return_list_assertFailure_twice" ~:
       assert (return [assertFailure "Fail Message\n",
                       assertFailure "Fail Message 2\n"] :: IO [Assertion]),
     "assert_return_list_assertFailure_twice", [], oneFailTwoAsserts,
     [Utils.Failure "Fail Message\n", Utils.Failure "Fail Message 2\n"]),
    ("assert_return_list_assertSuccess_assertFailure" ~:
       assert (return [assertSuccess,
                       assertFailure "Fail Message"] :: IO [Assertion]),
     "assert_return_list_assertSuccess_assertFailure", [], oneFailTwoAsserts,
     [Utils.Failure "Fail Message"]),
    ("assert_return_list_assertFailure_assertSuccess" ~:
       assert (return [assertFailure "Fail Message",
                       assertSuccess] :: IO [Assertion]),
     "assert_return_list_assertFailure_assertSuccess", [], oneFailTwoAsserts,
     [Utils.Failure "Fail Message"]),
    ("assertWithMsg_return_list_assertSuccess_twice" ~:
       assertWithMsg "Prefix: " (return [assertSuccess, assertSuccess]
                                 :: IO [Assertion]),
     "assertWithMsg_return_list_assertSuccess_twice", [], twoAsserts, []),
    ("assertWithMsg_return_list_assertFailure_twice" ~:
       assertWithMsg "Prefix: " (return [assertFailure "Fail Message\n",
                                         assertFailure "Fail Message 2\n"]
                                 :: IO [Assertion]),
     "assertWithMsg_return_list_assertFailure_twice", [], oneFailTwoAsserts,
     [Utils.Failure "Prefix: Fail Message\n",
      Utils.Failure "Prefix: Fail Message 2\n"]),
    ("assertWithMsg_return_list_assertSuccess_assertFailure" ~:
       assertWithMsg "Prefix: "(return [assertSuccess,
                                        assertFailure "Fail Message"]
                                :: IO [Assertion]),
     "assertWithMsg_return_list_assertSuccess_assertFailure",
     [], oneFailTwoAsserts, [Utils.Failure "Prefix: Fail Message"]),
    ("assertWithMsg_return_list_assertFailure_assertSuccess" ~:
       assertWithMsg "Prefix: " (return [assertFailure "Fail Message",
                                         assertSuccess] :: IO [Assertion]),
     "assertWithMsg_return_list_assertFailure_assertSuccess",
     [], oneFailTwoAsserts, [Utils.Failure "Prefix: Fail Message"]),
    ("assert_return_Pass" ~: assert (return Pass :: IO Result),
     "assert_return_Pass", [], oneAssert, []),
    ("assert_return_Fail" ~: assert (return (Fail "Fail Message") :: IO Result),
     "assert_return_Fail", [], oneFailOneAssert, [Utils.Failure "Fail Message"]),
    ("assert_return_Error" ~:
       assert (return (Error "Error Message") :: IO Result),
     "assert_return_Error", [], oneError, [Utils.Error "Error Message"]),
    ("assertWithMsg_return_Pass" ~:
       assertWithMsg "Message" (return Pass :: IO Result),
     "assertWithMsg_return_Pass", [], oneAssert, []),
    ("assertWithMsg_return_Fail" ~:
       assertWithMsg "Prefix: " (return (Fail "Fail Message") :: IO Result),
     "assertWithMsg_return_Fail", [], oneFailOneAssert,
     [Utils.Failure "Prefix: Fail Message"]),
    ("assertWithMsg_return_Error" ~:
       assertWithMsg "Prefix: " (return (Error "Error Message") :: IO Result),
     "assertWithMsg_return_Error", [], oneError,
     [Utils.Error "Prefix: Error Message"]),
    ("assert_return_eventually_Pass" ~:
       assert (return (eventually Pass) :: IO Progress),
     "assert_return_eventually_Pass", [], oneAssert, []),
    ("assert_return_eventually_Fail" ~:
       assert (return (eventually (Fail "Fail Message")) :: IO Progress),
     "assert_return_eventually_Fail", [], oneFailOneAssert,
     [Utils.Failure "Fail Message"]),
    ("assert_return_eventually_Error" ~:
       assert (return (eventually (Error "Error Message")) :: IO Progress),
     "assert_return_eventually_Error", [], oneError,
     [Utils.Error "Error Message"]),
    ("assertWithMsg_return_eventually_Pass" ~:
       assertWithMsg "Prefix: " (return (eventually Pass) :: IO Progress),
     "assertWithMsg_return_eventually_Pass", [], oneAssert, []),
    ("assertWithMsg_return_eventually_Fail" ~:
       assertWithMsg "Prefix: " (return (eventually (Fail "Fail Message"))
                                 :: IO Progress),
     "assertWithMsg_return_eventually_Fail", [], oneFailOneAssert,
     [Utils.Failure "Prefix: Fail Message"]),
    ("assertWithMsg_return_eventually_Error" ~:
       assertWithMsg "Prefix: " (return (eventually (Error "Error Message"))
                                 :: IO Progress),
     "assertWithMsg_return_eventually_Error", [], oneError,
     [Utils.Error "Prefix: Error Message"]),
    -- Assertion operators
    ("assertWithMsg_operator_Pass" ~: True @? "Message",
     "assertWithMsg_operator_Pass", [], oneAssert, []),
    ("assertWithMsg_operator_False" ~: False @? "Message",
     "assertWithMsg_operator_False", [], oneFailOneAssert,
     [Utils.Failure "Message"]),
    ("assertWithMsg_operator_Fail" ~: Fail "Message" @? "Prefix: ",
     "assertWithMsg_operator_Fail", [], oneFailOneAssert,
     [Utils.Failure "Prefix: Message"]),
    ("assertWithMsg_operator_Error" ~: Error "Message" @? "Prefix: ",
     "assertWithMsg_operator_Error", [], oneError,
     [Utils.Error "Prefix: Message"]),
    ("assertEqual_operator_eq" ~: 10 @=? 10,
     "assertEqual_operator_eq", [], oneAssert, []),
    ("assertEqual_operator_neq" ~: 0 @=? 1, "assertEqual_operator_neq",
     [], oneFailOneAssert, [Utils.Failure "expected: 0\nbut got: 1"]),
    ("assertEqual_operator2_eq" ~: 7 @?= 7,
     "assertEqual_operator2_eq", [], oneAssert, []),
    ("assertEqual_operator2_neq" ~: 11 @=? 8, "assertEqual_operator2_neq",
     [], oneFailOneAssert, [Utils.Failure "expected: 11\nbut got: 8"]),
    -- Test-building functions
    ("HUnit_Test_empty" ~: (return () :: IO ()),
     "HUnit_Test_empty", [], zeroCounts, []),
    ("HUnit_Test_Progress_Pass" ~: (return (Finished Pass) :: IO Progress),
     "HUnit_Test_Progress_Pass", [], oneAssert, []),
    ("HUnit_Test_Progress_Fail" ~:
       (return (Finished (Fail "Fail Message")) :: IO Progress),
     "HUnit_Test_Progress_Fail", [], oneFailOneAssert,
     [Utils.Failure "Fail Message"]),
    ("HUnit_Test_Progress_Error" ~:
       (return (Finished (Error "Error Message")) :: IO Progress),
     "HUnit_Test_Progress_Error", [], oneError, [Utils.Error "Error Message"]),
    ("HUnit_Test_Progress_eventually_Pass" ~:
       (return (eventually Pass) :: IO Progress),
     "HUnit_Test_Progress_eventually_Pass", [], oneAssert, []),
    ("HUnit_Test_Progress_eventually_Fail" ~:
       (return (eventually (Fail "Fail Message")) :: IO Progress),
     "HUnit_Test_Progress_eventually_Fail", [], oneFailOneAssert,
     [Utils.Failure "Fail Message"]),
    ("HUnit_Test_Progress_eventually_Error" ~:
       (return (eventually (Error "Error Message")) :: IO Progress),
     "HUnit_Test_Progress_eventually_Error", [], oneError,
     [Utils.Error "Error Message"]),
    ("HUnit_Test_Bool_True" ~: (return True :: IO Bool),
     "HUnit_Test_Bool_True", [], oneAssert, []),
    ("HUnit_Test_Bool_False" ~: (return False :: IO Bool),
     "HUnit_Test_Bool_False", [], oneFailOneAssert, [Utils.Failure ""]),
    ("HUnit_Test_with_msg_True" ~: (True ~? "Failure Message"),
     "HUnit_Test_with_msg_True", [], oneAssert, []),
    ("HUnit_Test_with_msg_False" ~: (False ~? "Fail Message"),
     "HUnit_Test_with_msg_False", [], oneFailOneAssert,
     [Utils.Failure "Fail Message"]),
    ("HUnit_Eq_Test_eq" ~: (4 ~?= 4), "HUnit_Eq_Test_eq", [], oneAssert, []),
    ("HUnit_Eq_Test_neq" ~: (4 ~?= 5), "HUnit_Eq_Test_neq", [],
     oneFailOneAssert, [Utils.Failure "expected: 5\nbut got: 4"]),
    ("HUnit_Eq_Test2_eq" ~: (3 ~=? 3), "HUnit_Eq_Test2_eq", [], oneAssert, []),
    ("HUnit_Eq_Test2_neq" ~: (3 ~=? 2), "HUnit_Eq_Test2_neq", [],
     oneFailOneAssert, [Utils.Failure "expected: 3\nbut got: 2"]),
    (externalTestPass, "externalTestPass", [], zeroCounts, []),
    (externalTestEventuallyPass, "externalTestEventuallyPass", [], zeroCounts,
     [Utils.Progress ".", Utils.Progress "..", Utils.Progress "..."]),
    (externalTestFail, "externalTestFail", [], oneFail,
     [Utils.Failure "External Test Failed"]),
    (externalTestEventuallyFail, "externalTestEventuallyFail", [], oneFail,
     [Utils.Progress ".", Utils.Progress "..", Utils.Progress "...",
      Utils.Failure "External Test Failed"]),
    (externalTestError, "externalTestError", [], oneError,
     [Utils.Error "External Test Error"]),
    (externalTestEventuallyError, "externalTestEventuallyError", [], oneError,
     [Utils.Progress ".", Utils.Progress "..", Utils.Progress "...",
      Utils.Error "External Test Error"]),
    (externalTestException, "externalTestException", [], oneError,
     [Utils.Exception "Exception Message"]),
    -- Test manipulation of tags and test names
    (testName "newName" (test (return () :: IO ())),
     "newName", [], zeroCounts, []),
    (testTags ["tag", "gat"] ("newTags" ~: (return () :: IO ())),
     "newTags", ["tag", "gat"], zeroCounts, []),
    (testNameTags "newNameTags" ["tag", "gat"] (test (return () :: IO ())),
     "newNameTags", ["tag", "gat"], zeroCounts, [])
  ]
{-
miscTests :: [Test]
miscTests =
  let
    anonTest1 = test True
    anonTest2 = test True

    tagsTest1 = testTags ["tag"] True
    tagsTest2 = testTags ["tag", "gat"] True

    nameTest = testName "test1" True

    anonTestCreate =
      TestInstance { name = "anonTestCreate", tags = [], options = [],
                     setOption = (\_ _ -> anonTestCreate),
                     run = if (name anonTest1) /= (name anonTest2)
                             then return (Finished Pass)
                             else
                               return (Finished (Fail "expected unique names")) }
    tagsTestCreate
  in
    [ Test anontestCreate, Test tagsTestCreate ]
-}
tests :: Test
tests = testGroup "Base" (map makeTestCase testCases)