ghc/tests/lib/should_run/enum03.hs

   1 -- !!! Testing the Word Enum instances.
   2 module Main(main) where
   3
   4 import Exception
   5 import Word
   6
   7 main = do
   8   putStrLn "Testing Enum Word8:"
   9   testEnumWord8
  10   putStrLn "Testing Enum Word16:"
  11   testEnumWord16
  12   putStrLn "Testing Enum Word32:"
  13   testEnumWord32
  14   putStrLn "Testing Enum Word64:"
  15   testEnumWord64
  16
  17
  18 #define printTest(x) (do{ putStr ( "    " ++ "x" ++ " = " ) ; print (x) })
  19
  20 testEnumWord8 :: IO ()
  21 testEnumWord8 = do
  22      -- succ
  23   printTest ((succ (0::Word8)))
  24   printTest ((succ (minBound::Word8)))
  25   mayBomb   (printTest ((succ (maxBound::Word8))))
  26
  27      -- pred
  28   printTest (pred (1::Word8))
  29   printTest (pred (maxBound::Word8))
  30   mayBomb   (printTest (pred (minBound::Word8)))
  31
  32      -- toEnum
  33   printTest ((map (toEnum::Int->Word8) [1, toInt (minBound::Word8), toInt (maxBound::Word8)]))
  34   mayBomb   (printTest ((toEnum (maxBound::Int))::Word8))
  35
  36      -- fromEnum
  37   printTest ((map fromEnum [(1::Word8),minBound,maxBound]))
  38
  39      -- [x..] aka enumFrom
  40   printTest ((take 7 [(1::Word8)..]))
  41   printTest ((take 7 [((maxBound::Word8)-5)..])) -- just in case it doesn't catch the upper bound..
  42
  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) ..]))
  55
  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])))
  63
  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]))
  72
  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]))
  77
  78 testEnumWord16 :: IO ()
  79 testEnumWord16 = do
  80      -- succ
  81   printTest ((succ (0::Word16)))
  82   printTest ((succ (minBound::Word16)))
  83   mayBomb   (printTest ((succ (maxBound::Word16))))
  84
  85      -- pred
  86   printTest (pred (1::Word16))
  87   printTest (pred (maxBound::Word16))
  88   mayBomb   (printTest (pred (minBound::Word16)))
  89
  90      -- toEnum
  91   printTest ((map (toEnum::Int->Word16) [1, toInt (minBound::Word16), toInt (maxBound::Word16)]))
  92   mayBomb   (printTest ((toEnum (maxBound::Int))::Word16))
  93
  94
  95      -- fromEnum
  96   printTest ((map fromEnum [(1::Word16),minBound,maxBound]))
  97
  98      -- [x..] aka enumFrom
  99   printTest ((take 7 [(1::Word16)..]))
 100   printTest ((take 7 [((maxBound::Word16)-5)..])) -- just in case it doesn't catch the upper bound..
 101
 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) ..]))
 114
 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])))
 122
 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]))
 131
 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]))
 136
 137 testEnumWord32 :: IO ()
 138 testEnumWord32 = do
 139      -- succ
 140   printTest ((succ (0::Word32)))
 141   printTest ((succ (minBound::Word32)))
 142   mayBomb   (printTest ((succ (maxBound::Word32))))
 143
 144      -- pred
 145   printTest (pred (1::Word32))
 146   printTest (pred (maxBound::Word32))
 147   mayBomb   (printTest (pred (minBound::Word32)))
 148
 149      -- toEnum
 150   printTest ((map (toEnum::Int->Word32) [1, toInt (minBound::Word32), maxBound::Int]))
 151   mayBomb   (printTest ((toEnum (maxBound::Int))::Word32))
 152
 153      -- fromEnum
 154   printTest ((map fromEnum [(1::Word32),minBound,fromInt (maxBound::Int)]))
 155   mayBomb   (printTest (fromEnum (maxBound::Word32)))
 156
 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..
 160
 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) ..]))
 173
 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])))
 181
 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]))
 190
 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]))
 195
 196 testEnumWord64 :: IO ()
 197 testEnumWord64 = do
 198      -- succ
 199   printTest ((succ (0::Word64)))
 200   printTest ((succ (minBound::Word64)))
 201   mayBomb   (printTest ((succ (maxBound::Word64))))
 202
 203      -- pred
 204   printTest (pred (1::Word64))
 205   printTest (pred (maxBound::Word64))
 206   mayBomb   (printTest (pred (minBound::Word64)))
 207
 208      -- toEnum
 209   printTest ((map (toEnum::Int->Word64) [1, toInt (minBound::Word64), maxBound::Int]))
 210   mayBomb   (printTest ((toEnum (maxBound::Int))::Word64))
 211
 212      -- fromEnum
 213   printTest ((map fromEnum [(1::Word64),minBound,fromInt (maxBound::Int)]))
 214   mayBomb   (printTest (fromEnum (maxBound::Word64)))
 215
 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..
 219
 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) ..]))
 232
 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])))
 240
 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]))
 249
 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]))
 254
 255
 256 --
 257 --
 258 --  Utils
 259 --
 260 --
 261
 262
 263 mayBomb x = catchAllIO x errorHandler
 264
 265 errorHandler :: Exception -> IO ()
 266 errorHandler e =
 267   case justErrors e of
 268     Just t -> putStrLn ("error " ++ show t)
 269     _      -> return ()
 270