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 import Int( Num(fromInt), Integral(toInt) )
   7
   8 main = do
   9   putStrLn "Testing Enum Word8:"
  10   testEnumWord8
  11   putStrLn "Testing Enum Word16:"
  12   testEnumWord16
  13   putStrLn "Testing Enum Word32:"
  14   testEnumWord32
  15   putStrLn "Testing Enum Word64:"
  16   testEnumWord64
  17
  18
  19 #define printTest(x) (do{ putStr ( "    " ++ "x" ++ " = " ) ; print (x) })
  20
  21 testEnumWord8 :: IO ()
  22 testEnumWord8 = do
  23      -- succ
  24   printTest ((succ (0::Word8)))
  25   printTest ((succ (minBound::Word8)))
  26   mayBomb   (printTest ((succ (maxBound::Word8))))
  27
  28      -- pred
  29   printTest (pred (1::Word8))
  30   printTest (pred (maxBound::Word8))
  31   mayBomb   (printTest (pred (minBound::Word8)))
  32
  33      -- toEnum
  34   printTest ((map (toEnum::Int->Word8) [1, toInt (minBound::Word8), toInt (maxBound::Word8)]))
  35   mayBomb   (printTest ((toEnum (maxBound::Int))::Word8))
  36
  37      -- fromEnum
  38   printTest ((map fromEnum [(1::Word8),minBound,maxBound]))
  39
  40      -- [x..] aka enumFrom
  41   printTest ((take 7 [(1::Word8)..]))
  42   printTest ((take 7 [((maxBound::Word8)-5)..])) -- just in case it doesn't catch the upper bound..
  43
  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) ..]))
  56
  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])))
  64
  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]))
  73
  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]))
  78
  79 testEnumWord16 :: IO ()
  80 testEnumWord16 = do
  81      -- succ
  82   printTest ((succ (0::Word16)))
  83   printTest ((succ (minBound::Word16)))
  84   mayBomb   (printTest ((succ (maxBound::Word16))))
  85
  86      -- pred
  87   printTest (pred (1::Word16))
  88   printTest (pred (maxBound::Word16))
  89   mayBomb   (printTest (pred (minBound::Word16)))
  90
  91      -- toEnum
  92   printTest ((map (toEnum::Int->Word16) [1, toInt (minBound::Word16), toInt (maxBound::Word16)]))
  93   mayBomb   (printTest ((toEnum (maxBound::Int))::Word16))
  94
  95
  96      -- fromEnum
  97   printTest ((map fromEnum [(1::Word16),minBound,maxBound]))
  98
  99      -- [x..] aka enumFrom
 100   printTest ((take 7 [(1::Word16)..]))
 101   printTest ((take 7 [((maxBound::Word16)-5)..])) -- just in case it doesn't catch the upper bound..
 102
 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) ..]))
 115
 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])))
 123
 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]))
 132
 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]))
 137
 138 testEnumWord32 :: IO ()
 139 testEnumWord32 = do
 140      -- succ
 141   printTest ((succ (0::Word32)))
 142   printTest ((succ (minBound::Word32)))
 143   mayBomb   (printTest ((succ (maxBound::Word32))))
 144
 145      -- pred
 146   printTest (pred (1::Word32))
 147   printTest (pred (maxBound::Word32))
 148   mayBomb   (printTest (pred (minBound::Word32)))
 149
 150      -- toEnum
 151   printTest ((map (toEnum::Int->Word32) [1, toInt (minBound::Word32), maxBound::Int]))
 152   mayBomb   (printTest ((toEnum (maxBound::Int))::Word32))
 153
 154      -- fromEnum
 155   printTest ((map fromEnum [(1::Word32),minBound,fromInt (maxBound::Int)]))
 156   mayBomb   (printTest (fromEnum (maxBound::Word32)))
 157
 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..
 161
 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) ..]))
 174
 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])))
 182
 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]))
 191
 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]))
 196
 197 testEnumWord64 :: IO ()
 198 testEnumWord64 = do
 199      -- succ
 200   printTest ((succ (0::Word64)))
 201   printTest ((succ (minBound::Word64)))
 202   mayBomb   (printTest ((succ (maxBound::Word64))))
 203
 204      -- pred
 205   printTest (pred (1::Word64))
 206   printTest (pred (maxBound::Word64))
 207   mayBomb   (printTest (pred (minBound::Word64)))
 208
 209      -- toEnum
 210   printTest ((map (toEnum::Int->Word64) [1, toInt (minBound::Word64), maxBound::Int]))
 211   mayBomb   (printTest ((toEnum (maxBound::Int))::Word64))
 212
 213      -- fromEnum
 214   printTest ((map fromEnum [(1::Word64),minBound,fromInt (maxBound::Int)]))
 215   mayBomb   (printTest (fromEnum (maxBound::Word64)))
 216
 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..
 220
 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) ..]))
 233
 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])))
 241
 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]))
 250
 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]))
 255
 256
 257 --
 258 --
 259 --  Utils
 260 --
 261 --
 262
 263
 264 mayBomb x = catchJust errorCalls x (\e -> putStrLn ("error " ++ show e))