Skip to content

Instantly share code, notes, and snippets.

@sanssecours

sanssecours/Test4.hs

Last active November 22, 2015 14:03
Show Gist options
  • Save sanssecours/0ade97509fc00ae731d8 to your computer and use it in GitHub Desktop.
Save sanssecours/0ade97509fc00ae731d8 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
Test4.hs
-- Imports ---------------------------------------------------------------------
import Aufgabe4
import Test.HUnit
import Control.Exception
import Control.Monad
-- Support ---------------------------------------------------------------------
assertException ex action
= handleJust isWanted (const $ return ()) $ do
action
assertFailure $ "Expected exception: " ++ show ex
where isWanted = guard . (== ex)
assertError ex f =
TestCase $ assertException (ErrorCall ex) $ evaluate f
-- Numbers ---------------------------------------------------------------------
nat0 = Nat ((A, A, A), (Null, Null, Null))
nat1 = Nat ((A, A, A), (Null, Null, Eins))
nat2 = Nat ((A, A, A), (Null, Null, Zwei))
nat3 = Nat ((A, A, A), (Null, Null, Drei))
nat6 = Nat ((A, A, A), (Null, Null, Sechs))
nat8 = Nat ((A, A, A), (Null, Null, Acht))
nat14 = Nat ((A, A, A), (Null, Eins, Vier))
nat15 = Nat ((A, A, A), (Null, Eins, Fuenf))
nat20 = Nat ((A, A, A), (Null, Zwei, Null))
nat24 = Nat ((A, A, A), (Null, Zwei, Vier))
nat29 = Nat ((A, A, A), (Null, Zwei, Neun))
nat30 = Nat ((A, A, A), (Null, Drei, Null))
nat31 = Nat ((A, A, A), (Null, Drei, Eins))
nat123 = Nat ((A, A, A), (Eins, Zwei, Drei))
nat200 = Nat ((A, A, A), (Zwei, Null, Null))
nat1337 = Nat ((A, A, B), (Drei, Drei, Sieben))
nat1500 = Nat ((A, A, B), (Fuenf, Null, Null))
nat1600 = Nat ((A, A, B), (Sechs, Null, Null))
nat1700 = Nat ((A, A, B), (Sieben, Null, Null))
nat1750 = Nat ((A, A, B), (Sieben, Fuenf, Null))
nat1751 = Nat ((A, A, B), (Sieben, Fuenf, Eins))
nat1752 = Nat ((A, A, B), (Sieben, Fuenf, Zwei))
nat1755 = Nat ((A, A, B), (Sieben, Fuenf, Fuenf))
nat1760 = Nat ((A, A, B), (Sieben, Sechs, Null))
nat1775 = Nat ((A, A, B), (Sieben, Sieben, Fuenf))
nat1800 = Nat ((A, A, B), (Acht, Null, Null))
nat1900 = Nat ((A, A, B), (Neun, Null, Null))
nat1999 = Nat ((A, A, B), (Neun, Neun, Neun))
nat2000 = Nat ((A, A, C), (Null, Null, Null))
nat2001 = Nat ((A, A, C), (Null, Null, Eins))
nat2015 = Nat ((A, A, C), (Null, Eins, Fuenf))
nat12345 = Nat ((A, A, M), (Drei, Vier, Fuenf))
nat88178 = Nat ((A, D, K), (Eins, Sieben, Acht))
nat1234500 = Nat ((B, V, M), (Fuenf, Null, Null))
nat1246845 = Nat ((B, V, Y), (Acht, Vier, Fuenf))
nat1860867 = Nat ((C, T, O), (Acht, Sechs, Sieben))
nat4060225 = Nat ((G, A, E), (Zwei, Zwei, Fuenf))
natMaxMinusOne = Nat ((Z, Z, Z), (Neun, Neun, Acht))
natMax = Nat ((Z, Z, Z), (Neun, Neun, Neun))
-- Main ------------------------------------------------------------------------
main = runTestTT $ TestList [ testPlusN
, testMinusN
, testTimesN
, testDivN
, testModN
, testPowerN
, testEqN
, testNeqN
, testGrN
, testLeN
, testGrEqN
, testLeEqN
, testNatOperations
, testWochentag4InCorrectInput
, testWochentag4CorrectInput]
-- 1 ---------------------------------------------------------------------------
testPlusN = TestLabel "plusN" $ TestList
[ TestCase $ assertEqual
"plusN nat12345 nat1234500"
nat1246845
(plusN nat12345 nat1234500)
, TestCase $ assertEqual
"plusN nat2000 nat1"
nat2001
(plusN nat2000 nat1)
, TestCase $ assertEqual
"plusN nat0 nat2000"
nat2000
(plusN nat0 nat2000)
, TestCase $ assertEqual
"plusN natMax nat1"
natMax
(plusN natMax nat1)
]
testMinusN = TestLabel "minusN" $ TestList
[ TestCase $ assertEqual
"minusN nat12345 nat1234500"
nat0
(minusN nat12345 nat1234500)
, TestCase $ assertEqual
"minusN nat2000 nat1"
nat1999
(minusN nat2000 nat1)
, TestCase $ assertEqual
"minusN nat0 nat2000"
nat0
(minusN nat0 nat2000)
, TestCase $ assertEqual
"minusN natMax nat1"
natMaxMinusOne
(minusN natMax nat1)
]
testTimesN = TestLabel "timesN" $ TestList
[ TestCase $ assertEqual
"timesN nat12345 nat1234500"
natMax
(timesN nat12345 nat1234500)
, TestCase $ assertEqual
"timesN nat2000 nat1"
nat2000
(timesN nat2000 nat1)
, TestCase $ assertEqual
"timesN nat0 nat2000"
nat0
(timesN nat0 nat2000)
, TestCase $ assertEqual
"timesN nat2015 nat2015"
nat4060225
(timesN nat2015 nat2015)
]
testDivN = TestLabel "divN" $ TestList
[ TestCase $ assertEqual
"divN nat12345 nat1234500"
nat0
(divN nat12345 nat1234500)
, TestCase $ assertEqual
"divN nat2000 nat1"
nat2000
(divN nat2000 nat1)
, TestCase $ assertEqual
"divN nat0 nat2000"
nat0
(divN nat0 nat2000)
, TestCase $ assertEqual
"divN nat1234500 nat14"
nat88178
(divN nat1234500 nat14)
, TestCase $ assertEqual
"divN nat2015 nat2015"
nat1
(divN nat2015 nat2015)
, assertError "Division durch 0 nicht moeglich" $
divN nat12345 nat0
]
testModN = TestLabel "modN" $ TestList
[ TestCase $ assertEqual
"modN nat12345 nat1234500"
nat12345
(modN nat12345 nat1234500)
, TestCase $ assertEqual
"modN nat2000 nat1"
nat0
(modN nat2000 nat1)
, TestCase $ assertEqual
"modN nat0 nat2000"
nat0
(modN nat0 nat2000)
, TestCase $ assertEqual
"modN nat1234500 nat14"
nat8
(modN nat1234500 nat14)
, TestCase $ assertEqual
"modN nat2015 nat2015"
nat0
(modN nat2015 nat2015)
, assertError "Division durch 0 nicht moeglich" $
modN nat12345 nat0
]
testPowerN = TestLabel "powerN" $ TestList
[ TestCase $ assertEqual
"powerN nat12345 nat1234500"
natMax
(powerN nat12345 nat1234500)
, TestCase $ assertEqual
"powerN nat2000 nat1"
nat2000
(powerN nat2000 nat1)
, TestCase $ assertEqual
"powerN nat0 nat2000"
nat0
(powerN nat0 nat2000)
, TestCase $ assertEqual
"powerN nat123 nat3"
nat1860867
(powerN nat123 nat3)
, TestCase $ assertEqual
"powerN nat2015 nat0"
nat1
(powerN nat2015 nat0)
, TestCase $ assertEqual
"powerN nat1 nat1234500"
nat1
(powerN nat1 nat1234500)
, TestCase $ assertEqual
"powerN nat2 nat1234500"
natMax
(powerN nat2 nat1234500)
]
testEqN = TestLabel "eqN" $ TestList
[ TestCase $ assertEqual
"eqN nat12345 nat1234500"
False
(eqN nat12345 nat1234500)
, TestCase $ assertEqual
"eqN nat2000 nat200"
False
(eqN nat2000 nat200)
, TestCase $ assertEqual
"eqN nat1 nat0"
False
(eqN nat1 nat0)
, TestCase $ assertEqual
"eqN nat0 nat2000"
False
(eqN nat0 nat2000)
, TestCase $ assertEqual
"eqN nat123 nat3"
False
(eqN nat123 nat3)
, TestCase $ assertEqual
"eqN nat2015 nat2015"
True
(eqN nat2015 nat2015)
, TestCase $ assertEqual
"eqN natMaxMinusOne natMax"
False
(eqN natMaxMinusOne natMax)
, TestCase $ assertEqual
"eqN natMaxMinusOne natMaxMinusOne"
True
(eqN natMaxMinusOne natMaxMinusOne)
]
testNeqN = TestLabel "neqN" $ TestList
[ TestCase $ assertEqual
"neqN nat12345 nat1234500"
True
(neqN nat12345 nat1234500)
, TestCase $ assertEqual
"neqN nat2000 nat200"
True
(neqN nat2000 nat200)
, TestCase $ assertEqual
"neqN nat1 nat0"
True
(neqN nat1 nat0)
, TestCase $ assertEqual
"neqN nat0 nat2000"
True
(neqN nat0 nat2000)
, TestCase $ assertEqual
"neqN nat123 nat3"
True
(neqN nat123 nat3)
, TestCase $ assertEqual
"neqN nat2015 nat2015"
False
(neqN nat2015 nat2015)
, TestCase $ assertEqual
"neqN natMaxMinusOne natMax"
True
(neqN natMaxMinusOne natMax)
, TestCase $ assertEqual
"neqN natMaxMinusOne natMaxMinusOne"
False
(neqN natMaxMinusOne natMaxMinusOne)
]
testGrN = TestLabel "grN" $ TestList
[ TestCase $ assertEqual
"grN nat12345 nat1234500"
False
(grN nat12345 nat1234500)
, TestCase $ assertEqual
"grN nat2000 nat200"
True
(grN nat2000 nat200)
, TestCase $ assertEqual
"grN nat1 nat0"
True
(grN nat1 nat0)
, TestCase $ assertEqual
"grN nat0 nat2000"
False
(grN nat0 nat2000)
, TestCase $ assertEqual
"grN nat123 nat3"
True
(grN nat123 nat3)
, TestCase $ assertEqual
"grN nat2015 nat2015"
False
(grN nat2015 nat2015)
, TestCase $ assertEqual
"grN natMaxMinusOne natMax"
False
(grN natMaxMinusOne natMax)
, TestCase $ assertEqual
"grN natMaxMinusOne natMaxMinusOne"
False
(grN natMaxMinusOne natMaxMinusOne)
]
testLeN = TestLabel "leN" $ TestList
[ TestCase $ assertEqual
"leN nat12345 nat1234500"
True
(leN nat12345 nat1234500)
, TestCase $ assertEqual
"leN nat2000 nat200"
False
(leN nat2000 nat200)
, TestCase $ assertEqual
"leN nat1 nat0"
False
(leN nat1 nat0)
, TestCase $ assertEqual
"leN nat0 nat2000"
True
(leN nat0 nat2000)
, TestCase $ assertEqual
"leN nat123 nat3"
False
(leN nat123 nat3)
, TestCase $ assertEqual
"leN nat2015 nat2015"
False
(leN nat2015 nat2015)
, TestCase $ assertEqual
"leN natMaxMinusOne natMax"
True
(leN natMaxMinusOne natMax)
, TestCase $ assertEqual
"leN natMaxMinusOne natMaxMinusOne"
False
(leN natMaxMinusOne natMaxMinusOne)
]
testGrEqN = TestLabel "grEqN" $ TestList
[ TestCase $ assertEqual
"grEqN nat12345 nat1234500"
False
(grEqN nat12345 nat1234500)
, TestCase $ assertEqual
"grEqN nat2000 nat200"
True
(grEqN nat2000 nat200)
, TestCase $ assertEqual
"grEqN nat1 nat0"
True
(grEqN nat1 nat0)
, TestCase $ assertEqual
"grEqN nat0 nat2000"
False
(grEqN nat0 nat2000)
, TestCase $ assertEqual
"grEqN nat123 nat3"
True
(grEqN nat123 nat3)
, TestCase $ assertEqual
"grEqN nat2015 nat2015"
True
(grEqN nat2015 nat2015)
, TestCase $ assertEqual
"grEqN natMaxMinusOne natMax"
False
(grEqN natMaxMinusOne natMax)
, TestCase $ assertEqual
"grEqN natMaxMinusOne natMaxMinusOne"
True
(grEqN natMaxMinusOne natMaxMinusOne)
]
testLeEqN = TestLabel "leEqN" $ TestList
[ TestCase $ assertEqual
"leEqN nat12345 nat1234500"
True
(leEqN nat12345 nat1234500)
, TestCase $ assertEqual
"leEqN nat2000 nat200"
False
(leEqN nat2000 nat200)
, TestCase $ assertEqual
"leEqN nat1 nat0"
False
(leEqN nat1 nat0)
, TestCase $ assertEqual
"leEqN nat0 nat2000"
True
(leEqN nat0 nat2000)
, TestCase $ assertEqual
"leEqN nat123 nat3"
False
(leEqN nat123 nat3)
, TestCase $ assertEqual
"leEqN nat2015 nat2015"
True
(leEqN nat2015 nat2015)
, TestCase $ assertEqual
"leEqN natMaxMinusOne natMax"
True
(leEqN natMaxMinusOne natMax)
, TestCase $ assertEqual
"leEqN natMaxMinusOne natMaxMinusOne"
True
(leEqN natMaxMinusOne natMaxMinusOne)
]
testNatOperations = TestLabel "Nat-Operations From Exercise Sheet" $ TestList
[ TestCase $ assertEqual
("plusN (Nat ((A, A, A), (Neun, Neun, Acht))) " ++
"(Nat ((A, A, A), (Null, Null, Sechs)))")
(Nat ((A, A, B), (Null, Null, Vier)))
(plusN (Nat ((A, A, A), (Neun, Neun, Acht)))
(Nat ((A, A, A), (Null, Null, Sechs))))
, TestCase $ assertEqual
("minusN (Nat ((A, A, B), (Null, Null, Vier))) " ++
"(Nat ((A, A, A), (Null, Null, Sechs)))")
(Nat ((A, A, A), (Neun, Neun, Acht)))
(minusN (Nat ((A, A, B), (Null, Null, Vier)))
(Nat ((A, A, A), (Null, Null, Sechs))))
, TestCase $ assertEqual
("minusN (Nat ((A, A, A), (Null, Null, Sechs))) " ++
"(Nat ((A, A, B), (Null, Null, Vier)))")
(Nat ((A, A, A), (Null, Null, Null)))
(minusN (Nat ((A, A, A), (Null, Null, Sechs)))
(Nat ((A, A, B), (Null, Null, Vier))))
, TestCase $ assertEqual
("timesN (Nat ((Z, Z, Z), (Neun, Neun, Neun))) " ++
"(Nat ((A, A, A), (Null, Null, Zwei)))")
(Nat ((Z, Z, Z), (Neun, Neun, Neun)))
(timesN (Nat ((Z, Z, Z), (Neun, Neun, Neun)))
(Nat ((A, A, A), (Null, Null, Zwei))))
, TestCase $ assertEqual
("eqN (Nat ((A, A, B), (Null, Null, Vier))) " ++
"(Nat ((A, A, A), (Null, Null, Sechs)))")
False
(eqN (Nat ((A, A, B), (Null, Null, Vier)))
(Nat ((A, A, A), (Null, Null, Sechs))))
, TestCase $ assertEqual
("neqN (Nat ((A, A, B), (Null, Null, Vier))) " ++
"(Nat ((A, A, A), (Null, Null, Sechs)))")
True
(neqN (Nat ((A, A, B), (Null, Null, Vier)))
(Nat ((A, A, A), (Null, Null, Sechs))))
, TestCase $ assertEqual
("grN (Nat ((A, A, B), (Null, Null, Vier))) " ++
"(Nat ((A, A, A), (Null, Null, Sechs)))")
True
(grN (Nat ((A, A, B), (Null, Null, Vier)))
(Nat ((A, A, A), (Null, Null, Sechs))))
, TestCase $ assertEqual
("leEqN (Nat ((A, A, B), (Null, Null, Vier))) " ++
"(Nat ((A, A, A), (Null, Null, Sechs)))")
False
(leEqN (Nat ((A, A, B), (Null, Null, Vier)))
(Nat ((A, A, A), (Null, Null, Sechs))))
]
-- 2 ---------------------------------------------------------------------------
testWochentag4InCorrectInput = TestLabel "wochentag4: Incorrect Input"
$ TestList
[ assertError "Falsche Argumente" $
wochentag4 (nat30, Feber, nat2015) Donnerstag (nat24, August, nat2015)
, assertError "Falsche Argumente" $
wochentag4 (nat29, Feber, nat2001) Donnerstag (nat24, August, nat2015)
, assertError "Falsche Argumente" $
wochentag4 (nat15, Feber, nat2001) Donnerstag (nat0, August, nat2015)
, assertError "Falsche Argumente" $
wochentag4 (nat0, Jaenner, nat2015) Donnerstag (nat1, September, nat2015)
, assertError "Falsche Argumente" $
wochentag4 (nat2015, Jaenner, nat2015) Donnerstag
(nat1, September, nat2015)
, assertError "Falsche Argumente" $
wochentag4 (nat31, April, nat2015) Donnerstag
(nat1, Oktober, nat2000)
]
testWochentag4CorrectInput = TestLabel "wochentag4: Correct Input" $ TestList
[ TestCase $ assertEqual
"wochentag4 (nat6, August, nat2015) Donnerstag (nat24, August, nat2015)"
Montag
(wochentag4 (nat6, August, nat2015) Donnerstag (nat24, August, nat2015))
, TestCase $ assertEqual
"wochentag4 (nat24, August, nat2015) Montag (nat6, August, nat2015)"
Donnerstag
(wochentag4 (nat24, August, nat2015) Montag (nat6, August, nat2015))
, TestCase $ assertEqual
"wochentag4 (nat6, August, nat2015) Donnerstag (nat24, November, nat2015)"
Dienstag
(wochentag4 (nat6, August, nat2015) Donnerstag (nat24, November, nat2015))
, TestCase $ assertEqual
"wochentag4 (nat14, Maerz, nat2000) Dienstag (nat14, Maerz, nat2001)"
Mittwoch
(wochentag4 (nat14, Maerz, nat2000) Dienstag (nat14, Maerz, nat2001))
, TestCase $ assertEqual
"wochentag4 (nat14, Maerz, nat2000) Dienstag (nat14, Maerz, nat2015)"
Samstag
(wochentag4 (nat14, Maerz, nat2000) Dienstag (nat14, Maerz, nat2015))
, TestCase $ assertEqual
"wochentag4 (nat14, Maerz, nat2015) Samstag (nat14, Maerz, nat2000)"
Dienstag
(wochentag4 (nat14, Maerz, nat2015) Samstag (nat14, Maerz, nat2000))
, TestCase $ assertEqual
"wochentag4 (nat1, Oktober, nat2000) Sonntag (nat14, Maerz, nat2015)"
Samstag
(wochentag4 (nat1, Oktober, nat2000) Sonntag (nat14, Maerz, nat2015))
, TestCase $ assertEqual
"wochentag4 (nat1, Oktober, nat1900) Montag (nat14, Maerz, nat2015)"
Samstag
(wochentag4 (nat1, Oktober, nat1900) Montag (nat14, Maerz, nat2015))
, TestCase $ assertEqual
"wochentag4 (nat1, Oktober, nat1800) Mittwoch (nat14, Maerz, nat2015)"
Samstag
(wochentag4 (nat1, Oktober, nat1800) Mittwoch (nat14, Maerz, nat2015))
, TestCase $ assertEqual
"wochentag4 (nat1, Oktober, nat1775) Sonntag (nat14, Maerz, nat2015)"
Samstag
(wochentag4 (nat1, Oktober, nat1775) Sonntag (nat14, Maerz, nat2015))
, TestCase $ assertEqual
"wochentag4 (nat1, Oktober, nat1760) Mittwoch (nat14, Maerz, nat2015)"
Samstag
(wochentag4 (nat1, Oktober, nat1760) Mittwoch (nat14, Maerz, nat2015))
, TestCase $ assertEqual
"wochentag4 (nat1, Oktober, nat1755) Mittwoch (nat14, Maerz, nat2015)"
Samstag
(wochentag4 (nat1, Oktober, nat1755) Mittwoch (nat14, Maerz, nat2015))
, TestCase $ assertEqual
"wochentag4 (nat1, Oktober, nat1752) Sonntag (nat14, Maerz, nat2015)"
Samstag
(wochentag4 (nat1, Oktober, nat1752) Sonntag (nat14, Maerz, nat2015))
, TestCase $ assertEqual
"wochentag4 (nat1, Oktober, nat1751) Dienstag (nat1, Maerz, nat1752)"
Sonntag
(wochentag4 (nat1, Oktober, nat1751) Dienstag (nat1, Maerz, nat1752))
, TestCase $ assertEqual
"wochentag4 (nat1, Oktober, nat1751) Dienstag (nat1, Mai, nat1752)"
Freitag
(wochentag4 (nat1, Oktober, nat1751) Dienstag (nat1, Mai, nat1752))
, TestCase $ assertEqual
"wochentag4 (nat1, Oktober, nat1751) Dienstag (nat1, Juli, nat1752)"
Mittwoch
(wochentag4 (nat1, Oktober, nat1751) Dienstag (nat1, Juli, nat1752))
, TestCase $ assertEqual
"wochentag4 (nat1, Oktober, nat1751) Dienstag (nat1, Juli, nat1752)"
Mittwoch
(wochentag4 (nat1, Oktober, nat1751) Dienstag (nat1, Juli, nat1752))
, TestCase $ assertEqual
"wochentag4 (nat1, Oktober, nat1751) Dienstag (nat1, August, nat1752)"
Samstag
(wochentag4 (nat1, Oktober, nat1751) Dienstag (nat1, August, nat1752))
, TestCase $ assertEqual
"wochentag4 (nat1, Oktober, nat1751) Dienstag (nat1, September, nat1752)"
Dienstag
(wochentag4 (nat1, Oktober, nat1751) Dienstag (nat1, September, nat1752))
, TestCase $ assertEqual
("wochentag4 (nat20, September, nat1752) Mittwoch " ++
"(nat30, September, nat1752)")
Samstag
(wochentag4 (nat20, September, nat1752) Mittwoch
(nat30, September, nat1752))
, TestCase $ assertEqual
("wochentag4 (nat15, September, nat1752) Freitag " ++
"(nat30, September, nat1752)")
Samstag
(wochentag4 (nat15, September, nat1752) Freitag
(nat30, September, nat1752))
, TestCase $ assertEqual
("wochentag4 (nat10, September, nat1752) Freitag " ++
"(nat30, September, nat1752)")
Samstag
(wochentag4 (nat15, September, nat1752) Freitag
(nat30, September, nat1752))
, TestCase $ assertEqual
("wochentag4 (nat1, September, nat1752) Freitag " ++
"(nat30, September, nat1752)")
Samstag
(wochentag4 (nat1, September, nat1752) Freitag
(nat30, September, nat1752))
, TestCase $ assertEqual
"wochentag4 (nat1, September, nat1752) Freitag (nat1, Oktober, nat1752)"
Sonntag
(wochentag4 (nat1, September, nat1752) Freitag (nat1, Oktober, nat1752))
, TestCase $ assertEqual
"wochentag4 (nat1, August, nat1752) Dienstag (nat1, Oktober, nat1752)"
Sonntag
(wochentag4 (nat1, August, nat1752) Dienstag (nat1, Oktober, nat1752))
, TestCase $ assertEqual
"wochentag4 (nat1, Juli, nat1752) Samstag (nat1, Oktober, nat1752)"
Sonntag
(wochentag4 (nat1, Juli, nat1752) Samstag (nat1, Oktober, nat1752))
, TestCase $ assertEqual
"wochentag4 (nat1, Juni, nat1752) Donnerstag (nat1, Oktober, nat1752)"
Sonntag
(wochentag4 (nat1, Juni, nat1752) Donnerstag (nat1, Oktober, nat1752))
, TestCase $ assertEqual
"wochentag4 (nat1, Mai, nat1752) Montag (nat1, Oktober, nat1752)"
Sonntag
(wochentag4 (nat1, Mai, nat1752) Montag (nat1, Oktober, nat1752))
, TestCase $ assertEqual
"wochentag4 (nat1, April, nat1752) Samstag (nat1, Oktober, nat1752)"
Sonntag
(wochentag4 (nat1, April, nat1752) Samstag (nat1, Oktober, nat1752))
, TestCase $ assertEqual
"wochentag4 (nat1, Maerz, nat1752) Mittwoch (nat1, Oktober, nat1752)"
Sonntag
(wochentag4 (nat1, Maerz, nat1752) Mittwoch (nat1, Oktober, nat1752))
, TestCase $ assertEqual
"wochentag4 (nat1, Feber, nat1752) Dienstag (nat1, Oktober, nat1752)"
Sonntag
(wochentag4 (nat1, Feber, nat1752) Dienstag (nat1, Oktober, nat1752))
, TestCase $ assertEqual
"wochentag4 (nat1, Jaenner, nat1752) Samstag (nat1, Oktober, nat1752)"
Sonntag
(wochentag4 (nat1, Jaenner, nat1752) Samstag (nat1, Oktober, nat1752))
, TestCase $ assertEqual
"wochentag4 (nat1, Dezember, nat1751) Mittwoch (nat1, Oktober, nat1752)"
Sonntag
(wochentag4 (nat1, Dezember, nat1751) Mittwoch (nat1, Oktober, nat1752))
, TestCase $ assertEqual
"wochentag4 (nat1, November, nat1751) Montag (nat1, Oktober, nat1752)"
Sonntag
(wochentag4 (nat1, November, nat1751) Montag (nat1, Oktober, nat1752))
, TestCase $ assertEqual
"wochentag4 (nat1, Oktober, nat1751) Freitag (nat1, Oktober, nat1752)"
Sonntag
(wochentag4 (nat1, Oktober, nat1751) Freitag (nat1, Oktober, nat1752))
, TestCase $ assertEqual
"wochentag4 (nat1, Oktober, nat1751) Freitag (nat14, Maerz, nat2015)"
Samstag
(wochentag4 (nat1, Oktober, nat1751) Freitag (nat14, Maerz, nat2015))
, TestCase $ assertEqual
"wochentag4 (nat1, Oktober, nat1750) Donnerstag (nat14, Maerz, nat2015)"
Samstag
(wochentag4 (nat1, Oktober, nat1750) Donnerstag (nat14, Maerz, nat2015))
, TestCase $ assertEqual
"wochentag4 (nat1, Oktober, nat1700) Freitag (nat14, Maerz, nat2015)"
Samstag
(wochentag4 (nat1, Oktober, nat1700) Freitag (nat14, Maerz, nat2015))
, TestCase $ assertEqual
"wochentag4 (nat14, Maerz, nat2015) Samstag (nat1, Oktober, nat1700)"
Freitag
(wochentag4 (nat14, Maerz, nat2015) Samstag (nat1, Oktober, nat1700))
, TestCase $ assertEqual
"wochentag4 (nat1, Oktober, nat1600) Sonntag (nat14, Maerz, nat2015)"
Samstag
(wochentag4 (nat1, Oktober, nat1600) Sonntag (nat14, Maerz, nat2015))
]
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment