Skip to content

Instantly share code, notes, and snippets.

@sanssecours

sanssecours/Test5.hs

Last active November 23, 2015 17:43
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save sanssecours/92e1746a04bcdbb719d2 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save sanssecours/92e1746a04bcdbb719d2 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
Test5.hs
-- Imports ---------------------------------------------------------------------
import Aufgabe5 (Nat(..), Zeichen(..), Ziffer(..),
isCanPR, mkCanPR, plusPR, minusPR, timesPR, divPR,
eqPR, neqPR, grPR, lePR, grEqPR, leEqPR)
import Test.HUnit
-- 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))
nat4 = Nat ((A, A, A), (Null, Null, Vier))
nat5 = Nat ((A, A, A), (Null, Null, Fuenf))
nat6 = Nat ((A, A, A), (Null, Null, Sechs))
nat8 = Nat ((A, A, A), (Null, Null, Acht))
nat11 = Nat ((A, A, A), (Null, Eins, Eins))
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))
nat120 = Nat ((A, A, A), (Eins, Zwei, Null))
nat123 = Nat ((A, A, A), (Eins, Zwei, Drei))
nat200 = Nat ((A, A, A), (Zwei, Null, Null))
nat823 = Nat ((A, A, A), (Acht, Zwei, Drei))
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))
nat2674 = Nat ((A, A, C), (Sechs, Sieben, Vier))
nat12345 = Nat ((A, A, M), (Drei, Vier, Fuenf))
nat88178 = Nat ((A, D, K), (Eins, Sieben, Acht))
nat255367 = Nat ((A, J, V), (Drei, Sechs, Sieben))
nat1234500 = Nat ((B, V, M), (Fuenf, Null, Null))
nat1246845 = Nat ((B, V, Y), (Acht, Vier, Fuenf))
nat1860867 = Nat ((C, T, O), (Acht, Sechs, Sieben))
nat2960546 = Nat ((E, J, W), (Fuenf, Vier, Sechs))
nat3301053 = Nat ((E, W, Z), (Null, Fuenf, Drei))
nat4060225 = Nat ((G, A, E), (Zwei, Zwei, Fuenf))
nat5921092 = Nat ((I, T, T), (Null, Neun, Zwei))
nat6602106 = Nat ((J, T, Y), (Eins, Null, Sechs))
nat8120450 = Nat ((M, A, I), (Vier, Fuenf, Null))
nat9903159 = Nat ((O, Q, X), (Eins, Fuenf, Neun))
nat11421503 = Nat ((Q, X, H), (Fuenf, Null, Drei))
nat16505265 = Nat ((Y, K, V), (Zwei, Sechs, Fuenf))
natMaxMinusOne = Nat ((Z, Z, Z), (Neun, Neun, Acht))
natMax = Nat ((Z, Z, Z), (Neun, Neun, Neun))
posRatUndefined = (nat0, nat0)
-- Main ------------------------------------------------------------------------
main = runTestTT $ TestList [
testEq
, testOrd
, testShow
, testNum
, testIsCanPR
, testMkCanPR
, testPlusPR
, testMinusPR
, testTimesPR
, testDivPR
, testEqPR
, testNeqPR
, testGrPR
, testLePR
, testGrEqPR
, testLeEqPR
, testPosRat
]
-- 1 ---------------------------------------------------------------------------
testEq = TestLabel "Eq" $ TestList
[ TestCase $ assertEqual
"nat12345 /= nat1234500"
True
(nat12345 /= nat1234500)
, TestCase $ assertEqual
"nat2000 /= nat200"
True
(nat2000 /= nat200)
, TestCase $ assertEqual
"nat1 /= nat0"
True
(nat1 /= nat0)
, TestCase $ assertEqual
"nat0 /= nat2000"
True
(nat0 /= nat2000)
, TestCase $ assertEqual
"nat123 /= nat3"
True
(nat123 /= nat3)
, TestCase $ assertEqual
"nat2015 /= nat2015"
False
(nat2015 /= nat2015)
, TestCase $ assertEqual
"natMax /= natMaxMinusOne"
True
(natMax /= natMaxMinusOne)
, TestCase $ assertEqual
"natMaxMinusOne /= natMaxMinusOne"
False
(natMaxMinusOne /= natMaxMinusOne)
]
testOrd = TestLabel "Ord" $ TestList
[ TestCase $ assertEqual
"nat1337 `compare` nat1337"
EQ
(nat1337 `compare` nat1337)
, TestCase $ assertEqual
"nat0 `compare` nat1"
LT
(nat0 `compare` nat1)
, TestCase $ assertEqual
"nat1 `compare` nat0"
GT
(nat1 `compare` nat0)
, TestCase $ assertEqual
"nat4060225 `compare` nat1"
GT
(nat4060225 `compare` nat1)
, TestCase $ assertEqual
"nat1 `compare` nat4060225"
LT
(nat1 `compare` nat4060225)
, TestCase $ assertEqual
"nat1500 `compare` nat123"
GT
(nat1500 `compare` nat123)
, TestCase $ assertEqual
"natMaxMinusOne `compare` natMax"
LT
(natMaxMinusOne `compare` natMax)
, TestCase $ assertEqual
"natMax `compare` natMax"
EQ
(natMax `compare` natMax)
, TestCase $ assertEqual
"natMax `compare` nat0"
GT
(natMax `compare` nat0)
]
testShow = TestLabel "Show" $ TestList
[ TestCase $ assertEqual
"show nat0"
"\"AAA 000\""
(show nat0)
, TestCase $ assertEqual
"show nat20"
"\"AAA 020\""
(show nat20)
, TestCase $ assertEqual
"show nat1700"
"\"AAB 700\""
(show nat1700)
, TestCase $ assertEqual
"show natMax"
"\"ZZZ 999\""
(show natMax)
, TestCase $ assertEqual
"show natMaxMinusOne"
"\"ZZZ 998\""
(show natMaxMinusOne)
, TestCase $ assertEqual
"show nat1234500"
"\"BVM 500\""
(show nat1234500)
, TestCase $ assertEqual
"show nat4060225"
"\"GAE 225\""
(show nat4060225)
]
testNum = TestLabel "Num" $ TestList
[ TestCase $ assertEqual
"nat0 + nat1"
nat1
(nat0 + nat1)
, TestCase $ assertEqual
"nat1 + nat0"
nat1
(nat1 + nat0)
, TestCase $ assertEqual
"nat1337 + nat1337"
nat2674
(nat1337 + nat1337)
, TestCase $ assertEqual
"nat1860867 + nat4060225"
nat5921092
(nat1860867 + nat4060225)
, TestCase $ assertEqual
"natMax + nat2"
natMax
(natMax + nat2)
, TestCase $ assertEqual
"natMax - nat1"
natMaxMinusOne
(natMax - nat1)
, TestCase $ assertEqual
"nat1 - nat2"
nat0
(nat1 - nat2)
, TestCase $ assertEqual
"nat16505265 - nat6602106"
nat9903159
(nat16505265 - nat6602106)
, TestCase $ assertEqual
"nat0 * nat1"
nat0
(nat0 * nat1)
, TestCase $ assertEqual
"nat1337 * nat0"
nat0
(nat1337 * nat0)
, TestCase $ assertEqual
"nat0 * nat1337"
nat0
(nat0 * nat1337)
, TestCase $ assertEqual
"nat1 * nat1337"
nat1337
(nat1 * nat1337)
, TestCase $ assertEqual
"nat1760 * nat12345"
natMax
(nat1760 * nat12345)
, TestCase $ assertEqual
"nat1337 * nat12345"
nat16505265
(nat1337 * nat12345)
, TestCase $ assertEqual
"natMaxMinusOne * nat1"
natMaxMinusOne
(natMaxMinusOne * nat1)
, TestCase $ assertEqual
"negate natMax"
nat0
(negate natMax)
, TestCase $ assertEqual
"negate natMaxMinusOne"
nat0
(negate natMaxMinusOne)
, TestCase $ assertEqual
"negate nat2015"
nat0
(negate nat2015)
, TestCase $ assertEqual
"negate nat0"
nat0
(negate nat0)
, TestCase $ assertEqual
"abs nat0"
nat0
(abs nat0)
, TestCase $ assertEqual
"abs nat5921092"
nat5921092
(abs nat5921092)
, TestCase $ assertEqual
"abs nat1999"
nat1999
(abs nat1999)
, TestCase $ assertEqual
"abs natMax"
natMax
(abs natMax)
, TestCase $ assertEqual
"signum nat0"
0
(signum nat0)
, TestCase $ assertEqual
"signum nat1"
1
(signum nat1)
, TestCase $ assertEqual
"signum nat1860867"
1
(signum nat1860867)
, TestCase $ assertEqual
"signum natMax"
1
(signum natMax)
, TestCase $ assertEqual
"fromInteger 17575999"
natMax
(fromInteger 17575999)
, TestCase $ assertEqual
"fromInteger 17576000"
natMax
(fromInteger 17576000)
, TestCase $ assertEqual
"fromInteger 17575998"
natMaxMinusOne
(fromInteger 17575998)
, TestCase $ assertEqual
"fromInteger 4060225"
nat4060225
(fromInteger 4060225)
, TestCase $ assertEqual
"fromInteger 0"
nat0
(fromInteger 0)
, TestCase $ assertEqual
"fromInteger 1"
nat1
(fromInteger 1)
, TestCase $ assertEqual
"fromInteger 1246845"
nat1246845
(fromInteger 1246845)
, TestCase $ assertEqual
"fromInteger 16505265"
nat16505265
(fromInteger 16505265)
, TestCase $ assertEqual
"fromInteger 12345678910"
natMax
(fromInteger 12345678910)
, TestCase $ assertEqual
"fromInteger (-1)"
nat0
(fromInteger (-1))
, TestCase $ assertEqual
"fromInteger (-16505265)"
nat0
(fromInteger (-16505265))
, TestCase $ assertEqual
"fromInteger (-0)"
nat0
(fromInteger (-0))
]
-- 2 ---------------------------------------------------------------------------
testIsCanPR = TestLabel "isCanPR" $ TestList
[ TestCase $ assertEqual
"isCanPR (nat2, nat1)"
True
(isCanPR (nat2, nat1))
, TestCase $ assertEqual
"isCanPR (nat1, nat0)"
False
(isCanPR (nat1, nat0))
, TestCase $ assertEqual
"isCanPR (nat16505265, nat0)"
False
(isCanPR (nat16505265, nat0))
, TestCase $ assertEqual
"isCanPR (nat6, nat2)"
False
(isCanPR (nat6, nat2))
, TestCase $ assertEqual
"isCanPR (nat2, nat6)"
False
(isCanPR (nat2, nat6))
, TestCase $ assertEqual
"isCanPR (nat5921092, nat2)"
False
(isCanPR (nat5921092, nat2))
, TestCase $ assertEqual
"isCanPR (nat5, nat16505265)"
False
(isCanPR (nat5, nat16505265))
, TestCase $ assertEqual
"isCanPR (nat200, nat1234500)"
False
(isCanPR (nat200, nat1234500))
, TestCase $ assertEqual
"isCanPR (nat2, nat12345)"
True
(isCanPR (nat2, nat12345))
, TestCase $ assertEqual
"isCanPR (nat0, nat12345)"
False
(isCanPR (nat0, nat12345))
, TestCase $ assertEqual
"isCanPR (nat0, nat1)"
True
(isCanPR (nat0, nat1))
]
testMkCanPR = TestLabel "mkCanPR" $ TestList
[ TestCase $ assertEqual
"mkCanPR (nat2, nat1)"
(nat2, nat1)
(mkCanPR (nat2, nat1))
, TestCase $ assertEqual
"mkCanPR (nat1, nat0)"
posRatUndefined
(mkCanPR (nat1, nat0))
, TestCase $ assertEqual
"mkCanPR (nat16505265, nat0)"
posRatUndefined
(mkCanPR (nat16505265, nat0))
, TestCase $ assertEqual
"mkCanPR (nat6, nat2)"
(nat3, nat1)
(mkCanPR (nat6, nat2))
, TestCase $ assertEqual
"mkCanPR (nat2, nat6)"
(nat1, nat3)
(mkCanPR (nat2, nat6))
, TestCase $ assertEqual
"mkCanPR (nat5921092, nat2)"
(nat2960546, nat1)
(mkCanPR (nat5921092, nat2))
, TestCase $ assertEqual
"mkCanPR (nat5, nat16505265)"
(nat1, nat3301053)
(mkCanPR (nat5, nat16505265))
, TestCase $ assertEqual
"mkCanPR (nat200, nat1234500)"
(nat2, nat12345)
(mkCanPR (nat200, nat1234500))
, TestCase $ assertEqual
"mkCanPR (nat2, nat12345)"
(nat2, nat12345)
(mkCanPR (nat2, nat12345))
, TestCase $ assertEqual
"mkCanPR (nat0, nat12345)"
(nat0, nat1)
(mkCanPR (nat0, nat12345))
, TestCase $ assertEqual
"mkCanPR (nat0, nat1)"
(nat0, nat1)
(mkCanPR (nat0, nat1))
, TestCase $ assertEqual
"mkCanPR (nat1800, nat12345)"
(nat120, nat823)
(mkCanPR (nat1800, nat12345))
]
testPlusPR = TestLabel "plusPR" $ TestList
[ TestCase $ assertEqual
"(nat2, nat1) `plusPR` (nat3, nat4)"
(nat11, nat4)
((nat2, nat1) `plusPR` (nat3, nat4))
, TestCase $ assertEqual
"(nat2, nat0) `plusPR` (nat3, nat4)"
posRatUndefined
((nat2, nat0) `plusPR` (nat3, nat4))
, TestCase $ assertEqual
"(nat2960546, nat5921092) `plusPR` (nat4060225, nat0)"
posRatUndefined
((nat2960546, nat5921092) `plusPR` (nat4060225, nat0))
, TestCase $ assertEqual
"(nat2960546, nat5921092) `plusPR` (nat4060225, nat3301053)"
(nat11421503, nat6602106)
((nat2960546, nat5921092) `plusPR` (nat4060225, nat3301053))
, TestCase $ assertEqual
"(natMaxMinusOne, natMaxMinusOne) `plusPR` (natMax, natMax)"
(nat2, nat1)
((natMaxMinusOne, natMaxMinusOne) `plusPR` (natMax, natMax))
, TestCase $ assertEqual
"(natMaxMinusOne, natMax) `plusPR` (nat0, natMax)"
(natMaxMinusOne, natMax)
((natMaxMinusOne, natMax) `plusPR` (nat0, natMax))
]
testMinusPR = TestLabel "minusPR" $ TestList
[ TestCase $ assertEqual
"(nat2, nat1) `minusPR` (nat3, nat4)"
(nat5, nat4)
((nat2, nat1) `minusPR` (nat3, nat4))
, TestCase $ assertEqual
"(nat2, nat0) `minusPR` (nat3, nat4)"
posRatUndefined
((nat2, nat0) `minusPR` (nat3, nat4))
, TestCase $ assertEqual
"(nat2960546, nat5921092) `minusPR` (nat4060225, nat0)"
posRatUndefined
((nat2960546, nat5921092) `minusPR` (nat4060225, nat0))
, TestCase $ assertEqual
"(nat1, nat2) `minusPR` (nat2, nat2)"
(nat0, nat1)
((nat1, nat2) `minusPR` (nat2, nat2))
, TestCase $ assertEqual
"(nat2960546, nat5921092) `minusPR` (nat4060225, nat3301053)"
(nat0, nat1)
((nat2960546, nat5921092) `minusPR` (nat4060225, nat3301053))
, TestCase $ assertEqual
"(natMaxMinusOne, natMaxMinusOne) `minusPR` (natMax, natMax)"
(nat0, nat1)
((natMaxMinusOne, natMaxMinusOne) `minusPR` (natMax, natMax))
, TestCase $ assertEqual
"(natMaxMinusOne, natMax) `minusPR` (natMax, natMaxMinusOne)"
(nat0, nat1)
((natMaxMinusOne, natMax) `minusPR` (natMax, natMaxMinusOne))
, TestCase $ assertEqual
"(natMaxMinusOne, natMax) `minusPR` (nat0, natMax)"
(natMaxMinusOne, natMax)
((natMaxMinusOne, natMax) `minusPR` (nat0, natMax))
, TestCase $ assertEqual
"(natMax, nat1337) `minusPR` (natMaxMinusOne, nat1337)"
(nat1, nat1337)
((natMax, nat1337) `minusPR` (natMaxMinusOne, nat1337))
]
testTimesPR = TestLabel "timesPR" $ TestList
[ TestCase $ assertEqual
"(nat2, nat1) `timesPR` (nat3, nat4)"
(nat3, nat2)
((nat2, nat1) `timesPR` (nat3, nat4))
, TestCase $ assertEqual
"(nat2, nat0) `timesPR` (nat3, nat4)"
posRatUndefined
((nat2, nat0) `timesPR` (nat3, nat4))
, TestCase $ assertEqual
"(nat2960546, nat5921092) `timesPR` (nat4060225, nat0)"
posRatUndefined
((nat2960546, nat5921092) `timesPR` (nat4060225, nat0))
, TestCase $ assertEqual
"(nat2960546, nat5921092) `timesPR` (nat4060225, nat3301053)"
(nat4060225, nat6602106)
((nat2960546, nat5921092) `timesPR` (nat4060225, nat3301053))
, TestCase $ assertEqual
"(natMaxMinusOne, natMaxMinusOne) `timesPR` (natMax, natMax)"
(nat1, nat1)
((natMaxMinusOne, natMaxMinusOne) `timesPR` (natMax, natMax))
, TestCase $ assertEqual
"(natMaxMinusOne, natMax) `timesPR` (natMax, natMaxMinusOne)"
(nat1, nat1)
((natMaxMinusOne, natMax) `timesPR` (natMax, natMaxMinusOne))
, TestCase $ assertEqual
"(natMaxMinusOne, natMax) `timesPR` (nat0, natMax)"
(nat0, nat1)
((natMaxMinusOne, natMax) `timesPR` (nat0, natMax))
, TestCase $ assertEqual
"(natMax, nat1337) `timesPR` (natMaxMinusOne, nat1337)"
(natMax, nat1)
((natMax, nat1337) `timesPR` (natMaxMinusOne, nat1337))
]
testDivPR = TestLabel "divPR" $ TestList
[ TestCase $ assertEqual
"(nat2, nat1) `divPR` (nat3, nat4)"
(nat8, nat3)
((nat2, nat1) `divPR` (nat3, nat4))
, TestCase $ assertEqual
"(nat2, nat0) `divPR` (nat3, nat4)"
posRatUndefined
((nat2, nat0) `divPR` (nat3, nat4))
, TestCase $ assertEqual
"(nat2960546, nat5921092) `divPR` (nat4060225, nat0)"
posRatUndefined
((nat2960546, nat5921092) `divPR` (nat4060225, nat0))
, TestCase $ assertEqual
"(nat1, nat2) `divPR` (nat0, nat3)"
posRatUndefined
((nat1, nat2) `divPR` (nat0, nat3))
, TestCase $ assertEqual
"(nat2960546, nat5921092) `divPR` (nat4060225, nat3301053)"
(nat3301053, nat8120450)
((nat2960546, nat5921092) `divPR` (nat4060225, nat3301053))
, TestCase $ assertEqual
"(natMaxMinusOne, natMaxMinusOne) `divPR` (natMax, natMax)"
(nat1, nat1)
((natMaxMinusOne, natMaxMinusOne) `divPR` (natMax, natMax))
, TestCase $ assertEqual
"(natMax, nat1337) `divPR` (natMaxMinusOne, nat1337)"
(natMax, natMaxMinusOne)
((natMax, nat1337) `divPR` (natMaxMinusOne, nat1337))
]
testEqPR = TestLabel "eqPR" $ TestList
[ TestCase $ assertEqual
"(nat2, nat1) `eqPR` (nat3, nat4)"
False
((nat2, nat1) `eqPR` (nat3, nat4))
, TestCase $ assertEqual
"(nat2, nat0) `eqPR` (nat2, nat1)"
False
((nat2, nat0) `eqPR` (nat2, nat1))
, TestCase $ assertEqual
"(nat1, nat1) `eqPR` (nat1, nat0)"
False
((nat1, nat1) `eqPR` (nat1, nat0))
, TestCase $ assertEqual
"(nat0, nat0) `eqPR` (nat0, nat0)"
False
((nat0, nat0) `eqPR` (nat0, nat0))
, TestCase $ assertEqual
"(nat2960546, nat3301053) `eqPR` (nat2960546, nat3301053)"
True
((nat2960546, nat3301053) `eqPR` (nat2960546, nat3301053))
, TestCase $ assertEqual
"(nat2, nat1) `eqPR` (nat8, nat4)"
True
((nat2, nat1) `eqPR` (nat8, nat4))
]
testNeqPR = TestLabel "neqPR" $ TestList
[ TestCase $ assertEqual
"(nat2, nat1) `neqPR` (nat3, nat4)"
True
((nat2, nat1) `neqPR` (nat3, nat4))
, TestCase $ assertEqual
"(nat2, nat0) `neqPR` (nat2, nat1)"
False
((nat2, nat0) `neqPR` (nat2, nat1))
, TestCase $ assertEqual
"(nat1, nat1) `neqPR` (nat1, nat0)"
False
((nat1, nat1) `neqPR` (nat1, nat0))
, TestCase $ assertEqual
"(nat0, nat0) `neqPR` (nat0, nat0)"
False
((nat0, nat0) `neqPR` (nat0, nat0))
, TestCase $ assertEqual
"(nat2960546, nat3301053) `neqPR` (nat2960546, nat3301053)"
False
((nat2960546, nat3301053) `neqPR` (nat2960546, nat3301053))
, TestCase $ assertEqual
"(nat2, nat1) `neqPR` (nat8, nat4)"
False
((nat2, nat1) `neqPR` (nat8, nat4))
]
testGrPR = TestLabel "grPR" $ TestList
[ TestCase $ assertEqual
"(nat2, nat1) `grPR` (nat3, nat4)"
True
((nat2, nat1) `grPR` (nat3, nat4))
, TestCase $ assertEqual
"(nat2, nat0) `grPR` (nat2, nat1)"
False
((nat2, nat0) `grPR` (nat2, nat1))
, TestCase $ assertEqual
"(nat1, nat1) `grPR` (nat1, nat0)"
False
((nat1, nat1) `grPR` (nat1, nat0))
, TestCase $ assertEqual
"(nat0, nat0) `grPR` (nat0, nat0)"
False
((nat0, nat0) `grPR` (nat0, nat0))
, TestCase $ assertEqual
"(nat2960546, nat3301053) `grPR` (nat2960546, nat3301053)"
False
((nat2960546, nat3301053) `grPR` (nat2960546, nat3301053))
, TestCase $ assertEqual
"(nat2, nat1) `grPR` (nat8, nat4)"
False
((nat2, nat1) `grPR` (nat8, nat4))
, TestCase $ assertEqual
"(natMax, nat12345) `grPR` (natMaxMinusOne, nat12345)"
True
((natMax, nat12345) `grPR` (natMaxMinusOne, nat12345))
, TestCase $ assertEqual
"(nat1999, nat30) `grPR` (nat2000, nat30)"
False
((nat1999, nat30) `grPR` (nat2000, nat30))
]
testLePR = TestLabel "lePR" $ TestList
[ TestCase $ assertEqual
"(nat2, nat1) `lePR` (nat3, nat4)"
False
((nat2, nat1) `lePR` (nat3, nat4))
, TestCase $ assertEqual
"(nat2, nat0) `lePR` (nat2, nat1)"
False
((nat2, nat0) `lePR` (nat2, nat1))
, TestCase $ assertEqual
"(nat1, nat1) `lePR` (nat1, nat0)"
False
((nat1, nat1) `lePR` (nat1, nat0))
, TestCase $ assertEqual
"(nat0, nat0) `lePR` (nat0, nat0)"
False
((nat0, nat0) `lePR` (nat0, nat0))
, TestCase $ assertEqual
"(nat2960546, nat3301053) `lePR` (nat2960546, nat3301053)"
False
((nat2960546, nat3301053) `lePR` (nat2960546, nat3301053))
, TestCase $ assertEqual
"(nat2, nat1) `lePR` (nat8, nat4)"
False
((nat2, nat1) `lePR` (nat8, nat4))
, TestCase $ assertEqual
"(natMax, nat12345) `lePR` (natMaxMinusOne, nat12345)"
False
((natMax, nat12345) `lePR` (natMaxMinusOne, nat12345))
, TestCase $ assertEqual
"(nat1999, nat30) `lePR` (nat2000, nat30)"
True
((nat1999, nat30) `lePR` (nat2000, nat30))
, TestCase $ assertEqual
"(nat2000, nat2001) `lePR` (nat2000, nat2000)"
True
((nat2000, nat2001) `lePR` (nat2000, nat2000))
]
testGrEqPR = TestLabel "grEqPR" $ TestList
[ TestCase $ assertEqual
"(nat2, nat1) `grEqPR` (nat3, nat4)"
True
((nat2, nat1) `grEqPR` (nat3, nat4))
, TestCase $ assertEqual
"(nat2, nat0) `grEqPR` (nat2, nat1)"
False
((nat2, nat0) `grEqPR` (nat2, nat1))
, TestCase $ assertEqual
"(nat1, nat1) `grEqPR` (nat1, nat0)"
False
((nat1, nat1) `grEqPR` (nat1, nat0))
, TestCase $ assertEqual
"(nat0, nat0) `grEqPR` (nat0, nat0)"
False
((nat0, nat0) `grEqPR` (nat0, nat0))
, TestCase $ assertEqual
"(nat2960546, nat3301053) `grEqPR` (nat2960546, nat3301053)"
True
((nat2960546, nat3301053) `grEqPR` (nat2960546, nat3301053))
, TestCase $ assertEqual
"(nat2, nat1) `grEqPR` (nat8, nat4)"
True
((nat2, nat1) `grEqPR` (nat8, nat4))
, TestCase $ assertEqual
"(natMax, nat12345) `grEqPR` (natMaxMinusOne, nat12345)"
True
((natMax, nat12345) `grEqPR` (natMaxMinusOne, nat12345))
, TestCase $ assertEqual
"(nat1999, nat30) `grEqPR` (nat2000, nat30)"
False
((nat1999, nat30) `grEqPR` (nat2000, nat30))
]
testLeEqPR = TestLabel "leEqPR" $ TestList
[ TestCase $ assertEqual
"(nat2, nat1) `leEqPR` (nat3, nat4)"
False
((nat2, nat1) `leEqPR` (nat3, nat4))
, TestCase $ assertEqual
"(nat2, nat0) `leEqPR` (nat2, nat1)"
False
((nat2, nat0) `leEqPR` (nat2, nat1))
, TestCase $ assertEqual
"(nat1, nat1) `leEqPR` (nat1, nat0)"
False
((nat1, nat1) `leEqPR` (nat1, nat0))
, TestCase $ assertEqual
"(nat0, nat0) `leEqPR` (nat0, nat0)"
False
((nat0, nat0) `leEqPR` (nat0, nat0))
, TestCase $ assertEqual
"(nat0, nat1) `leEqPR` (nat0, nat1)"
True
((nat0, nat1) `leEqPR` (nat0, nat1))
, TestCase $ assertEqual
"(nat2960546, nat3301053) `leEqPR` (nat2960546, nat3301053)"
True
((nat2960546, nat3301053) `leEqPR` (nat2960546, nat3301053))
, TestCase $ assertEqual
"(nat2, nat1) `leEqPR` (nat8, nat4)"
True
((nat2, nat1) `leEqPR` (nat8, nat4))
, TestCase $ assertEqual
"(natMax, nat12345) `leEqPR` (natMaxMinusOne, nat12345)"
False
((natMax, nat12345) `leEqPR` (natMaxMinusOne, nat12345))
, TestCase $ assertEqual
"(nat1999, nat30) `leEqPR` (nat2000, nat30)"
True
((nat1999, nat30) `leEqPR` (nat2000, nat30))
]
testPosRat = TestLabel "PosRat-tests from exercise sheet" $ TestList
[ TestCase $ assertEqual
("isCanPR (Nat ((A, A, A), (Neun, Neun, Acht)), " ++
"Nat ((A, A, A), (Null, Null, Sechs)))")
False
(isCanPR (Nat ((A, A, A), (Neun, Neun, Acht)),
Nat ((A, A, A), (Null, Null, Sechs))))
, TestCase $ assertEqual
("mkCanPR (Nat ((A, A, A), (Null, Null, Acht)), " ++
"Nat ((A, A, A), (Null, Null, Sechs))")
(Nat ((A, A, A), (Null, Null, Vier)),
Nat ((A, A, A), (Null, Null, Drei)))
(mkCanPR (Nat ((A, A, A), (Null, Null, Acht)),
Nat ((A, A, A), (Null, Null, Sechs))))
, TestCase $ assertEqual
("plusPR (Nat ((A, A, A), (Null, Null, Acht)), " ++
"Nat ((A, A, A), (Null, Null, Vier))) " ++
"(Nat ((A, A, A), (Null, Vier, Zwei)), " ++
"Nat ((A, A, A), (Null, Null, Eins)))")
(Nat ((A, A, A), (Null, Vier, Vier)),
Nat ((A, A, A), (Null, Null, Eins)))
(plusPR (Nat ((A, A, A), (Null, Null, Acht)),
Nat ((A, A, A), (Null, Null, Vier)))
(Nat ((A, A, A), (Null, Vier, Zwei)),
Nat ((A, A, A), (Null, Null, Eins))))
, TestCase $ assertEqual
("minusPR (Nat ((A, A, A), (Null, Null, Acht)), " ++
"Nat ((A, A, A), (Null, Null, Vier))) " ++
"(Nat ((A, A, A), (Null, Vier, Zwei)), " ++
"Nat ((A, A, A), (Null, Null, Eins)))")
(Nat ((A, A, A), (Null, Null, Null)),
Nat ((A, A, A), (Null, Null, Eins)))
(minusPR (Nat ((A, A, A), (Null, Null, Acht)),
Nat ((A, A, A), (Null, Null, Vier)))
(Nat ((A, A, A), (Null, Vier, Zwei)),
Nat ((A, A, A), (Null, Null, Eins))))
, TestCase $ assertEqual
("timesPR (Nat ((A, A, A), (Null, Null, Acht)), " ++
"Nat ((A, A, A), (Null, Null, Null))) " ++
"(Nat ((A, A, A), (Null, Vier, Zwei)), " ++
"Nat ((A, A, A), (Null, Null, Eins)))")
(Nat ((A, A, A), (Null, Null, Null)),
Nat ((A, A, A), (Null, Null, Null)))
(timesPR (Nat ((A, A, A), (Null, Null, Acht)),
Nat ((A, A, A), (Null, Null, Null)))
(Nat ((A, A, A), (Null, Vier, Zwei)),
Nat ((A, A, A), (Null, Null, Eins))))
, TestCase $ assertEqual
("eqPR (Nat ((A, A, A), (Null, Null, Acht)), " ++
"Nat ((A, A, A), (Null, Null, Vier))) " ++
"(Nat ((A, A, A), (Null, Null, Vier)), " ++
"Nat ((A, A, A), (Null, Null, Zwei)))")
True
(eqPR (Nat ((A, A, A), (Null, Null, Acht)),
Nat ((A, A, A), (Null, Null, Vier)))
(Nat ((A, A, A), (Null, Null, Vier)),
Nat ((A, A, A), (Null, Null, Zwei))))
, TestCase $ assertEqual
("leEqPR (Nat ((A, A, A), (Null, Null, Acht)), " ++
"Nat ((A, A, A), (Null, Null, Vier))) " ++
"(Nat ((A, A, A), (Null, Vier, Zwei)), " ++
"Nat ((A, A, A), (Null, Null, Eins)))")
True
(leEqPR (Nat ((A, A, A), (Null, Null, Acht)),
Nat ((A, A, A), (Null, Null, Vier)))
(Nat ((A, A, A), (Null, Vier, Zwei)),
Nat ((A, A, A), (Null, Null, Eins))))
]
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment