1 -- !!! Testing the Word Enum instances.
2 module Main(main) where
8 putStrLn "Testing Enum Word8:"
10 putStrLn "Testing Enum Word16:"
12 putStrLn "Testing Enum Word32:"
14 putStrLn "Testing Enum Word64:"
18 #define printTest(x) (do{ putStr ( " " ++ "x" ++ " = " ) ; print (x) })
20 testEnumWord8 :: IO ()
23 printTest ((succ (0::Word8)))
24 printTest ((succ (minBound::Word8)))
25 mayBomb (printTest ((succ (maxBound::Word8))))
28 printTest (pred (1::Word8))
29 printTest (pred (maxBound::Word8))
30 mayBomb (printTest (pred (minBound::Word8)))
33 printTest ((map (toEnum::Int->Word8) [1, toInt (minBound::Word8), toInt (maxBound::Word8)]))
34 mayBomb (printTest ((toEnum (maxBound::Int))::Word8))
37 printTest ((map fromEnum [(1::Word8),minBound,maxBound]))
40 printTest ((take 7 [(1::Word8)..]))
41 printTest ((take 7 [((maxBound::Word8)-5)..])) -- just in case it doesn't catch the upper bound..
43 -- [x,y..] aka enumFromThen
44 printTest ((take 7 [(1::Word8),2..]))
45 printTest ((take 7 [(1::Word8),7..]))
46 printTest ((take 7 [(1::Word8),1..]))
47 printTest ((take 7 [(1::Word8),0..]))
48 printTest ((take 7 [(5::Word8),2..]))
49 let x = (minBound::Word8) + 1
50 printTest ((take 7 [x, x-1 ..]))
51 let x = (minBound::Word8) + 5
52 printTest ((take 7 [x, x-1 ..]))
53 let x = (maxBound::Word8) - 5
54 printTest ((take 7 [x, (x+1) ..]))
56 -- [x..y] aka enumFromTo
57 printTest ((take 7 ([(1::Word8) .. 5])))
58 printTest ((take 4 ([(1::Word8) .. 1])))
59 printTest ((take 7 ([(1::Word8) .. 0])))
60 printTest ((take 7 ([(5::Word8) .. 0])))
61 printTest ((take 7 ([(maxBound-(5::Word8)) .. maxBound])))
62 printTest ((take 7 ([(minBound+(5::Word8)) .. minBound])))
64 -- [x,y..z] aka enumFromThenTo
65 printTest ((take 7 [(5::Word8),4..1]))
66 printTest ((take 7 [(5::Word8),3..1]))
67 printTest ((take 7 [(5::Word8),3..2]))
68 printTest ((take 7 [(1::Word8),2..1]))
69 printTest ((take 7 [(2::Word8),1..2]))
70 printTest ((take 7 [(2::Word8),1..1]))
71 printTest ((take 7 [(2::Word8),3..1]))
73 let x = (maxBound::Word8) - 4
74 printTest ((take 7 [x,(x+1)..maxBound]))
75 let x = (minBound::Word8) + 5
76 printTest ((take 7 [x,(x-1)..minBound]))
78 testEnumWord16 :: IO ()
81 printTest ((succ (0::Word16)))
82 printTest ((succ (minBound::Word16)))
83 mayBomb (printTest ((succ (maxBound::Word16))))
86 printTest (pred (1::Word16))
87 printTest (pred (maxBound::Word16))
88 mayBomb (printTest (pred (minBound::Word16)))
91 printTest ((map (toEnum::Int->Word16) [1, toInt (minBound::Word16), toInt (maxBound::Word16)]))
92 mayBomb (printTest ((toEnum (maxBound::Int))::Word16))
96 printTest ((map fromEnum [(1::Word16),minBound,maxBound]))
99 printTest ((take 7 [(1::Word16)..]))
100 printTest ((take 7 [((maxBound::Word16)-5)..])) -- just in case it doesn't catch the upper bound..
102 -- [x,y..] aka enumFromThen
103 printTest ((take 7 [(1::Word16),2..]))
104 printTest ((take 7 [(1::Word16),7..]))
105 printTest ((take 7 [(1::Word16),1..]))
106 printTest ((take 7 [(1::Word16),0..]))
107 printTest ((take 7 [(5::Word16),2..]))
108 let x = (minBound::Word16) + 1
109 printTest ((take 7 [x, x-1 ..]))
110 let x = (minBound::Word16) + 5
111 printTest ((take 7 [x, x-1 ..]))
112 let x = (maxBound::Word16) - 5
113 printTest ((take 7 [x, (x+1) ..]))
115 -- [x..y] aka enumFromTo
116 printTest ((take 7 ([(1::Word16) .. 5])))
117 printTest ((take 4 ([(1::Word16) .. 1])))
118 printTest ((take 7 ([(1::Word16) .. 0])))
119 printTest ((take 7 ([(5::Word16) .. 0])))
120 printTest ((take 7 ([(maxBound-(5::Word16)) .. maxBound])))
121 printTest ((take 7 ([(minBound+(5::Word16)) .. minBound])))
123 -- [x,y..z] aka enumFromThenTo
124 printTest ((take 7 [(5::Word16),4..1]))
125 printTest ((take 7 [(5::Word16),3..1]))
126 printTest ((take 7 [(5::Word16),3..2]))
127 printTest ((take 7 [(1::Word16),2..1]))
128 printTest ((take 7 [(2::Word16),1..2]))
129 printTest ((take 7 [(2::Word16),1..1]))
130 printTest ((take 7 [(2::Word16),3..1]))
132 let x = (maxBound::Word16) - 4
133 printTest ((take 7 [x,(x+1)..maxBound]))
134 let x = (minBound::Word16) + 5
135 printTest ((take 7 [x,(x-1)..minBound]))
137 testEnumWord32 :: IO ()
140 printTest ((succ (0::Word32)))
141 printTest ((succ (minBound::Word32)))
142 mayBomb (printTest ((succ (maxBound::Word32))))
145 printTest (pred (1::Word32))
146 printTest (pred (maxBound::Word32))
147 mayBomb (printTest (pred (minBound::Word32)))
150 printTest ((map (toEnum::Int->Word32) [1, toInt (minBound::Word32), maxBound::Int]))
151 mayBomb (printTest ((toEnum (maxBound::Int))::Word32))
154 printTest ((map fromEnum [(1::Word32),minBound,fromInt (maxBound::Int)]))
155 mayBomb (printTest (fromEnum (maxBound::Word32)))
157 -- [x..] aka enumFrom
158 printTest ((take 7 [(1::Word32)..]))
159 printTest ((take 7 [((maxBound::Word32)-5)..])) -- just in case it doesn't catch the upper bound..
161 -- [x,y..] aka enumFromThen
162 printTest ((take 7 [(1::Word32),2..]))
163 printTest ((take 7 [(1::Word32),7..]))
164 printTest ((take 7 [(1::Word32),1..]))
165 printTest ((take 7 [(1::Word32),0..]))
166 printTest ((take 7 [(5::Word32),2..]))
167 let x = (minBound::Word32) + 1
168 printTest ((take 7 [x, x-1 ..]))
169 let x = (minBound::Word32) + 5
170 printTest ((take 7 [x, x-1 ..]))
171 let x = (maxBound::Word32) - 5
172 printTest ((take 7 [x, (x+1) ..]))
174 -- [x..y] aka enumFromTo
175 printTest ((take 7 ([(1::Word32) .. 5])))
176 printTest ((take 4 ([(1::Word32) .. 1])))
177 printTest ((take 7 ([(1::Word32) .. 0])))
178 printTest ((take 7 ([(5::Word32) .. 0])))
179 printTest ((take 7 ([(maxBound-(5::Word32)) .. maxBound])))
180 printTest ((take 7 ([(minBound+(5::Word32)) .. minBound])))
182 -- [x,y..z] aka enumFromThenTo
183 printTest ((take 7 [(5::Word32),4..1]))
184 printTest ((take 7 [(5::Word32),3..1]))
185 printTest ((take 7 [(5::Word32),3..2]))
186 printTest ((take 7 [(1::Word32),2..1]))
187 printTest ((take 7 [(2::Word32),1..2]))
188 printTest ((take 7 [(2::Word32),1..1]))
189 printTest ((take 7 [(2::Word32),3..1]))
191 let x = (maxBound::Word32) - 4
192 printTest ((take 7 [x,(x+1)..maxBound]))
193 let x = (minBound::Word32) + 5
194 printTest ((take 7 [x,(x-1)..minBound]))
196 testEnumWord64 :: IO ()
199 printTest ((succ (0::Word64)))
200 printTest ((succ (minBound::Word64)))
201 mayBomb (printTest ((succ (maxBound::Word64))))
204 printTest (pred (1::Word64))
205 printTest (pred (maxBound::Word64))
206 mayBomb (printTest (pred (minBound::Word64)))
209 printTest ((map (toEnum::Int->Word64) [1, toInt (minBound::Word64), maxBound::Int]))
210 mayBomb (printTest ((toEnum (maxBound::Int))::Word64))
213 printTest ((map fromEnum [(1::Word64),minBound,fromInt (maxBound::Int)]))
214 mayBomb (printTest (fromEnum (maxBound::Word64)))
216 -- [x..] aka enumFrom
217 printTest ((take 7 [(1::Word64)..]))
218 printTest ((take 7 [((maxBound::Word64)-5)..])) -- just in case it doesn't catch the upper bound..
220 -- [x,y..] aka enumFromThen
221 printTest ((take 7 [(1::Word64),2..]))
222 printTest ((take 7 [(1::Word64),7..]))
223 printTest ((take 7 [(1::Word64),1..]))
224 printTest ((take 7 [(1::Word64),0..]))
225 printTest ((take 7 [(5::Word64),2..]))
226 let x = (minBound::Word64) + 1
227 printTest ((take 7 [x, x-1 ..]))
228 let x = (minBound::Word64) + 5
229 printTest ((take 7 [x, x-1 ..]))
230 let x = (maxBound::Word64) - 5
231 printTest ((take 7 [x, (x+1) ..]))
233 -- [x..y] aka enumFromTo
234 printTest ((take 7 ([(1::Word64) .. 5])))
235 printTest ((take 4 ([(1::Word64) .. 1])))
236 printTest ((take 7 ([(1::Word64) .. 0])))
237 printTest ((take 7 ([(5::Word64) .. 0])))
238 printTest ((take 7 ([(maxBound-(5::Word64)) .. maxBound])))
239 printTest ((take 7 ([(minBound+(5::Word64)) .. minBound])))
241 -- [x,y..z] aka enumFromThenTo
242 printTest ((take 7 [(5::Word64),4..1]))
243 printTest ((take 7 [(5::Word64),3..1]))
244 printTest ((take 7 [(5::Word64),3..2]))
245 printTest ((take 7 [(1::Word64),2..1]))
246 printTest ((take 7 [(2::Word64),1..2]))
247 printTest ((take 7 [(2::Word64),1..1]))
248 printTest ((take 7 [(2::Word64),3..1]))
250 let x = (maxBound::Word64) - 4
251 printTest ((take 7 [x,(x+1)..maxBound]))
252 let x = (minBound::Word64) + 5
253 printTest ((take 7 [x,(x-1)..minBound]))
263 mayBomb x = catchAllIO x errorHandler
265 errorHandler :: Exception -> IO ()
268 Just t -> putStrLn ("error " ++ show t)