1 -- !!! Testing the Word Enum instances.
2 module Main(main) where
6 import Int( Num(fromInt) )
9 putStrLn "Testing Enum Word8:"
11 putStrLn "Testing Enum Word16:"
13 putStrLn "Testing Enum Word32:"
15 putStrLn "Testing Enum Word64:"
19 #define printTest(x) (do{ putStr ( " " ++ "x" ++ " = " ) ; print (x) })
21 testEnumWord8 :: IO ()
24 printTest ((succ (0::Word8)))
25 printTest ((succ (minBound::Word8)))
26 mayBomb (printTest ((succ (maxBound::Word8))))
29 printTest (pred (1::Word8))
30 printTest (pred (maxBound::Word8))
31 mayBomb (printTest (pred (minBound::Word8)))
34 printTest ((map (toEnum::Int->Word8) [1, toInt (minBound::Word8), toInt (maxBound::Word8)]))
35 mayBomb (printTest ((toEnum (maxBound::Int))::Word8))
38 printTest ((map fromEnum [(1::Word8),minBound,maxBound]))
41 printTest ((take 7 [(1::Word8)..]))
42 printTest ((take 7 [((maxBound::Word8)-5)..])) -- just in case it doesn't catch the upper bound..
44 -- [x,y..] aka enumFromThen
45 printTest ((take 7 [(1::Word8),2..]))
46 printTest ((take 7 [(1::Word8),7..]))
47 printTest ((take 7 [(1::Word8),1..]))
48 printTest ((take 7 [(1::Word8),0..]))
49 printTest ((take 7 [(5::Word8),2..]))
50 let x = (minBound::Word8) + 1
51 printTest ((take 7 [x, x-1 ..]))
52 let x = (minBound::Word8) + 5
53 printTest ((take 7 [x, x-1 ..]))
54 let x = (maxBound::Word8) - 5
55 printTest ((take 7 [x, (x+1) ..]))
57 -- [x..y] aka enumFromTo
58 printTest ((take 7 ([(1::Word8) .. 5])))
59 printTest ((take 4 ([(1::Word8) .. 1])))
60 printTest ((take 7 ([(1::Word8) .. 0])))
61 printTest ((take 7 ([(5::Word8) .. 0])))
62 printTest ((take 7 ([(maxBound-(5::Word8)) .. maxBound])))
63 printTest ((take 7 ([(minBound+(5::Word8)) .. minBound])))
65 -- [x,y..z] aka enumFromThenTo
66 printTest ((take 7 [(5::Word8),4..1]))
67 printTest ((take 7 [(5::Word8),3..1]))
68 printTest ((take 7 [(5::Word8),3..2]))
69 printTest ((take 7 [(1::Word8),2..1]))
70 printTest ((take 7 [(2::Word8),1..2]))
71 printTest ((take 7 [(2::Word8),1..1]))
72 printTest ((take 7 [(2::Word8),3..1]))
74 let x = (maxBound::Word8) - 4
75 printTest ((take 7 [x,(x+1)..maxBound]))
76 let x = (minBound::Word8) + 5
77 printTest ((take 7 [x,(x-1)..minBound]))
79 testEnumWord16 :: IO ()
82 printTest ((succ (0::Word16)))
83 printTest ((succ (minBound::Word16)))
84 mayBomb (printTest ((succ (maxBound::Word16))))
87 printTest (pred (1::Word16))
88 printTest (pred (maxBound::Word16))
89 mayBomb (printTest (pred (minBound::Word16)))
92 printTest ((map (toEnum::Int->Word16) [1, toInt (minBound::Word16), toInt (maxBound::Word16)]))
93 mayBomb (printTest ((toEnum (maxBound::Int))::Word16))
97 printTest ((map fromEnum [(1::Word16),minBound,maxBound]))
100 printTest ((take 7 [(1::Word16)..]))
101 printTest ((take 7 [((maxBound::Word16)-5)..])) -- just in case it doesn't catch the upper bound..
103 -- [x,y..] aka enumFromThen
104 printTest ((take 7 [(1::Word16),2..]))
105 printTest ((take 7 [(1::Word16),7..]))
106 printTest ((take 7 [(1::Word16),1..]))
107 printTest ((take 7 [(1::Word16),0..]))
108 printTest ((take 7 [(5::Word16),2..]))
109 let x = (minBound::Word16) + 1
110 printTest ((take 7 [x, x-1 ..]))
111 let x = (minBound::Word16) + 5
112 printTest ((take 7 [x, x-1 ..]))
113 let x = (maxBound::Word16) - 5
114 printTest ((take 7 [x, (x+1) ..]))
116 -- [x..y] aka enumFromTo
117 printTest ((take 7 ([(1::Word16) .. 5])))
118 printTest ((take 4 ([(1::Word16) .. 1])))
119 printTest ((take 7 ([(1::Word16) .. 0])))
120 printTest ((take 7 ([(5::Word16) .. 0])))
121 printTest ((take 7 ([(maxBound-(5::Word16)) .. maxBound])))
122 printTest ((take 7 ([(minBound+(5::Word16)) .. minBound])))
124 -- [x,y..z] aka enumFromThenTo
125 printTest ((take 7 [(5::Word16),4..1]))
126 printTest ((take 7 [(5::Word16),3..1]))
127 printTest ((take 7 [(5::Word16),3..2]))
128 printTest ((take 7 [(1::Word16),2..1]))
129 printTest ((take 7 [(2::Word16),1..2]))
130 printTest ((take 7 [(2::Word16),1..1]))
131 printTest ((take 7 [(2::Word16),3..1]))
133 let x = (maxBound::Word16) - 4
134 printTest ((take 7 [x,(x+1)..maxBound]))
135 let x = (minBound::Word16) + 5
136 printTest ((take 7 [x,(x-1)..minBound]))
138 testEnumWord32 :: IO ()
141 printTest ((succ (0::Word32)))
142 printTest ((succ (minBound::Word32)))
143 mayBomb (printTest ((succ (maxBound::Word32))))
146 printTest (pred (1::Word32))
147 printTest (pred (maxBound::Word32))
148 mayBomb (printTest (pred (minBound::Word32)))
151 printTest ((map (toEnum::Int->Word32) [1, toInt (minBound::Word32), maxBound::Int]))
152 mayBomb (printTest ((toEnum (maxBound::Int))::Word32))
155 printTest ((map fromEnum [(1::Word32),minBound,fromInt (maxBound::Int)]))
156 mayBomb (printTest (fromEnum (maxBound::Word32)))
158 -- [x..] aka enumFrom
159 printTest ((take 7 [(1::Word32)..]))
160 printTest ((take 7 [((maxBound::Word32)-5)..])) -- just in case it doesn't catch the upper bound..
162 -- [x,y..] aka enumFromThen
163 printTest ((take 7 [(1::Word32),2..]))
164 printTest ((take 7 [(1::Word32),7..]))
165 printTest ((take 7 [(1::Word32),1..]))
166 printTest ((take 7 [(1::Word32),0..]))
167 printTest ((take 7 [(5::Word32),2..]))
168 let x = (minBound::Word32) + 1
169 printTest ((take 7 [x, x-1 ..]))
170 let x = (minBound::Word32) + 5
171 printTest ((take 7 [x, x-1 ..]))
172 let x = (maxBound::Word32) - 5
173 printTest ((take 7 [x, (x+1) ..]))
175 -- [x..y] aka enumFromTo
176 printTest ((take 7 ([(1::Word32) .. 5])))
177 printTest ((take 4 ([(1::Word32) .. 1])))
178 printTest ((take 7 ([(1::Word32) .. 0])))
179 printTest ((take 7 ([(5::Word32) .. 0])))
180 printTest ((take 7 ([(maxBound-(5::Word32)) .. maxBound])))
181 printTest ((take 7 ([(minBound+(5::Word32)) .. minBound])))
183 -- [x,y..z] aka enumFromThenTo
184 printTest ((take 7 [(5::Word32),4..1]))
185 printTest ((take 7 [(5::Word32),3..1]))
186 printTest ((take 7 [(5::Word32),3..2]))
187 printTest ((take 7 [(1::Word32),2..1]))
188 printTest ((take 7 [(2::Word32),1..2]))
189 printTest ((take 7 [(2::Word32),1..1]))
190 printTest ((take 7 [(2::Word32),3..1]))
192 let x = (maxBound::Word32) - 4
193 printTest ((take 7 [x,(x+1)..maxBound]))
194 let x = (minBound::Word32) + 5
195 printTest ((take 7 [x,(x-1)..minBound]))
197 testEnumWord64 :: IO ()
200 printTest ((succ (0::Word64)))
201 printTest ((succ (minBound::Word64)))
202 mayBomb (printTest ((succ (maxBound::Word64))))
205 printTest (pred (1::Word64))
206 printTest (pred (maxBound::Word64))
207 mayBomb (printTest (pred (minBound::Word64)))
210 printTest ((map (toEnum::Int->Word64) [1, toInt (minBound::Word64), maxBound::Int]))
211 mayBomb (printTest ((toEnum (maxBound::Int))::Word64))
214 printTest ((map fromEnum [(1::Word64),minBound,fromInt (maxBound::Int)]))
215 mayBomb (printTest (fromEnum (maxBound::Word64)))
217 -- [x..] aka enumFrom
218 printTest ((take 7 [(1::Word64)..]))
219 printTest ((take 7 [((maxBound::Word64)-5)..])) -- just in case it doesn't catch the upper bound..
221 -- [x,y..] aka enumFromThen
222 printTest ((take 7 [(1::Word64),2..]))
223 printTest ((take 7 [(1::Word64),7..]))
224 printTest ((take 7 [(1::Word64),1..]))
225 printTest ((take 7 [(1::Word64),0..]))
226 printTest ((take 7 [(5::Word64),2..]))
227 let x = (minBound::Word64) + 1
228 printTest ((take 7 [x, x-1 ..]))
229 let x = (minBound::Word64) + 5
230 printTest ((take 7 [x, x-1 ..]))
231 let x = (maxBound::Word64) - 5
232 printTest ((take 7 [x, (x+1) ..]))
234 -- [x..y] aka enumFromTo
235 printTest ((take 7 ([(1::Word64) .. 5])))
236 printTest ((take 4 ([(1::Word64) .. 1])))
237 printTest ((take 7 ([(1::Word64) .. 0])))
238 printTest ((take 7 ([(5::Word64) .. 0])))
239 printTest ((take 7 ([(maxBound-(5::Word64)) .. maxBound])))
240 printTest ((take 7 ([(minBound+(5::Word64)) .. minBound])))
242 -- [x,y..z] aka enumFromThenTo
243 printTest ((take 7 [(5::Word64),4..1]))
244 printTest ((take 7 [(5::Word64),3..1]))
245 printTest ((take 7 [(5::Word64),3..2]))
246 printTest ((take 7 [(1::Word64),2..1]))
247 printTest ((take 7 [(2::Word64),1..2]))
248 printTest ((take 7 [(2::Word64),1..1]))
249 printTest ((take 7 [(2::Word64),3..1]))
251 let x = (maxBound::Word64) - 4
252 printTest ((take 7 [x,(x+1)..maxBound]))
253 let x = (minBound::Word64) + 5
254 printTest ((take 7 [x,(x-1)..minBound]))
264 mayBomb x = catchAllIO x errorHandler
266 errorHandler :: Exception -> IO ()
269 Just t -> putStrLn ("error " ++ show t)