diff options
Diffstat (limited to 'testsuite/tests/ffi/should_run/ffi009.hs')
| -rw-r--r-- | testsuite/tests/ffi/should_run/ffi009.hs | 552 |
1 files changed, 0 insertions, 552 deletions
diff --git a/testsuite/tests/ffi/should_run/ffi009.hs b/testsuite/tests/ffi/should_run/ffi009.hs deleted file mode 100644 index 5e91843bb5..0000000000 --- a/testsuite/tests/ffi/should_run/ffi009.hs +++ /dev/null @@ -1,552 +0,0 @@ -import Foreign -import System.Random - --------------------------------------------------------------------------------- - -type FunType5I = Int -> Int -> Int -> Int -> Int -> Int - -foreign import ccall "dynamic" callFun5I :: FunPtr FunType5I -> FunType5I -foreign import ccall "wrapper" mkFun5I :: FunType5I -> IO (FunPtr FunType5I) - -manyArgs5I :: FunType5I -manyArgs5I a1 a2 a3 a4 a5 = (((a1 * 31 + a2) * 31 + a3) * 31 + a4) * 31 + a5 - -test5I :: IO () -test5I = do - a1 <- randomIO - a2 <- randomIO - a3 <- randomIO - a4 <- randomIO - a5 <- randomIO - funAddr <- mkFun5I manyArgs5I - print (callFun5I funAddr a1 a2 a3 a4 a5 == - manyArgs5I a1 a2 a3 a4 a5) - freeHaskellFunPtr funAddr - --------------------------------------------------------------------------------- - -type FunType11D = Double -> Double -> Double -> Double -> Double -> Double - -> Double -> Double -> Double -> Double -> Double -> Double - -foreign import ccall "dynamic" callFun11D :: FunPtr FunType11D -> FunType11D -foreign import ccall "wrapper" mkFun11D :: FunType11D -> IO (FunPtr FunType11D) - -manyArgs11D :: FunType11D -manyArgs11D a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 = - ((((a1 * 31 + a2) * 31 + a3) * 31 + a4) * 31 + a5) * 31 + a6 - + a7 + a8 + a9 + a10 + a11 - -test11D :: IO () -test11D = do - a1 <- randomIO - a2 <- randomIO - a3 <- randomIO - a4 <- randomIO - a5 <- randomIO - a6 <- randomIO - a7 <- randomIO - a8 <- randomIO - a9 <- randomIO - a10 <- randomIO - a11 <- randomIO - funAddr <- mkFun11D manyArgs11D - let x = callFun11D funAddr a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 - y = manyArgs11D a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 - if x /= y then - print x >> print y - else - print True - freeHaskellFunPtr funAddr - --------------------------------------------------------------------------------- - -type FunType11M = Int -> Double -> Float -> Char -> Bool -> Int -> Float -> Int - -> Char -> Double -> Bool -> Double - -foreign import ccall "dynamic" callFun11M :: FunPtr FunType11M -> FunType11M -foreign import ccall "wrapper" mkFun11M :: FunType11M -> IO (FunPtr FunType11M) - -manyArgs11M :: FunType11M -manyArgs11M a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 = - (((((((((fromIntegral a1 * 31 + a2) * 31 + - realToFrac a3) * 31 + fromIntegral (fromEnum a4)) * 31 + - fromIntegral (fromEnum a5)) * 31 + fromIntegral a6) * 31 + - realToFrac a7) * 31 + fromIntegral a8) * 31 + - fromIntegral (fromEnum a9)) * 31 + a10) * 31 + - fromIntegral (fromEnum a11) - -test11M :: IO () -test11M = do - a1 <- randomIO - a2 <- randomIO - a3 <- randomIO - a4 <- randomIO - a5 <- randomIO - a6 <- randomIO - a7 <- randomIO - a8 <- randomIO - a9 <- randomIO - a10 <- randomIO - a11 <- randomIO - funAddr <- mkFun11M manyArgs11M - print (callFun11M funAddr a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 == - manyArgs11M a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11) - freeHaskellFunPtr funAddr - --------------------------------------------------------------------------------- - -type FunTypeM1 = Double -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int - -> Int -> Int -> Int -> Double - -foreign import ccall "dynamic" callFunM1 :: FunPtr FunTypeM1 -> FunTypeM1 -foreign import ccall "wrapper" mkFunM1 :: FunTypeM1 -> IO (FunPtr FunTypeM1) - -manyArgsM1 :: FunTypeM1 -manyArgsM1 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 = - (((((((((( a1 * 31 + fromIntegral a2) * 31 + - fromIntegral a3) * 31 + fromIntegral a4) * 31 + - fromIntegral a5) * 31 + fromIntegral a6) * 31 + - fromIntegral a7) * 31 + fromIntegral a8) * 31 + - fromIntegral a9) * 31 + fromIntegral a10) * 31 + - fromIntegral a11) * 31 + fromIntegral a12 - -testM1 :: IO () -testM1 = do - a1 <- randomIO - a2 <- randomIO - a3 <- randomIO - a4 <- randomIO - a5 <- randomIO - a6 <- randomIO - a7 <- randomIO - a8 <- randomIO - a9 <- randomIO - a10 <- randomIO - a11 <- randomIO - a12 <- randomIO - funAddr <- mkFunM1 manyArgsM1 - print (callFunM1 funAddr a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 == - manyArgsM1 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12) - freeHaskellFunPtr funAddr - --------------------------------------------------------------------------------- - -type FunTypeM2 = Int -> Double -> Int -> Int -> Int -> Int -> Int -> Int -> Int - -> Int -> Int -> Int -> Double - -foreign import ccall "dynamic" callFunM2 :: FunPtr FunTypeM2 -> FunTypeM2 -foreign import ccall "wrapper" mkFunM2 :: FunTypeM2 -> IO (FunPtr FunTypeM2) - -manyArgsM2 :: FunTypeM2 -manyArgsM2 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 = - ((((((((((fromIntegral a1 * 31 + a2) * 31 + - fromIntegral a3) * 31 + fromIntegral a4) * 31 + - fromIntegral a5) * 31 + fromIntegral a6) * 31 + - fromIntegral a7) * 31 + fromIntegral a8) * 31 + - fromIntegral a9) * 31 + fromIntegral a10) * 31 + - fromIntegral a11) * 31 + fromIntegral a12 - -testM2 :: IO () -testM2 = do - a1 <- randomIO - a2 <- randomIO - a3 <- randomIO - a4 <- randomIO - a5 <- randomIO - a6 <- randomIO - a7 <- randomIO - a8 <- randomIO - a9 <- randomIO - a10 <- randomIO - a11 <- randomIO - a12 <- randomIO - funAddr <- mkFunM2 manyArgsM2 - print (callFunM2 funAddr a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 == - manyArgsM2 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12) - freeHaskellFunPtr funAddr - --------------------------------------------------------------------------------- - -type FunTypeM3 = Int -> Int -> Double -> Int -> Int -> Int -> Int -> Int -> Int - -> Int -> Int -> Int -> Double - -foreign import ccall "dynamic" callFunM3 :: FunPtr FunTypeM3 -> FunTypeM3 -foreign import ccall "wrapper" mkFunM3 :: FunTypeM3 -> IO (FunPtr FunTypeM3) - -manyArgsM3 :: FunTypeM3 -manyArgsM3 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 = - ((((((((((fromIntegral a1 * 31 + fromIntegral a2) * 31 + - a3) * 31 + fromIntegral a4) * 31 + - fromIntegral a5) * 31 + fromIntegral a6) * 31 + - fromIntegral a7) * 31 + fromIntegral a8) * 31 + - fromIntegral a9) * 31 + fromIntegral a10) * 31 + - fromIntegral a11) * 31 + fromIntegral a12 - -testM3 :: IO () -testM3 = do - a1 <- randomIO - a2 <- randomIO - a3 <- randomIO - a4 <- randomIO - a5 <- randomIO - a6 <- randomIO - a7 <- randomIO - a8 <- randomIO - a9 <- randomIO - a10 <- randomIO - a11 <- randomIO - a12 <- randomIO - funAddr <- mkFunM3 manyArgsM3 - print (callFunM3 funAddr a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 == - manyArgsM3 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12) - freeHaskellFunPtr funAddr - --------------------------------------------------------------------------------- - -type FunTypeM4 = Int -> Int -> Int -> Double -> Int -> Int -> Int -> Int -> Int - -> Int -> Int -> Int -> Double - -foreign import ccall "dynamic" callFunM4 :: FunPtr FunTypeM4 -> FunTypeM4 -foreign import ccall "wrapper" mkFunM4 :: FunTypeM4 -> IO (FunPtr FunTypeM4) - -manyArgsM4 :: FunTypeM4 -manyArgsM4 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 = - ((((((((((fromIntegral a1 * 31 + fromIntegral a2) * 31 + - fromIntegral a3) * 31 + a4) * 31 + - fromIntegral a5) * 31 + fromIntegral a6) * 31 + - fromIntegral a7) * 31 + fromIntegral a8) * 31 + - fromIntegral a9) * 31 + fromIntegral a10) * 31 + - fromIntegral a11) * 31 + fromIntegral a12 - -testM4 :: IO () -testM4 = do - a1 <- randomIO - a2 <- randomIO - a3 <- randomIO - a4 <- randomIO - a5 <- randomIO - a6 <- randomIO - a7 <- randomIO - a8 <- randomIO - a9 <- randomIO - a10 <- randomIO - a11 <- randomIO - a12 <- randomIO - funAddr <- mkFunM4 manyArgsM4 - print (callFunM4 funAddr a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 == - manyArgsM4 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12) - freeHaskellFunPtr funAddr - --------------------------------------------------------------------------------- - -type FunTypeM5 = Int -> Int -> Int -> Int -> Double -> Int -> Int -> Int -> Int - -> Int -> Int -> Int -> Double - -foreign import ccall "dynamic" callFunM5 :: FunPtr FunTypeM5 -> FunTypeM5 -foreign import ccall "wrapper" mkFunM5 :: FunTypeM5 -> IO (FunPtr FunTypeM5) - -manyArgsM5 :: FunTypeM5 -manyArgsM5 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 = - ((((((((((fromIntegral a1 * 31 + fromIntegral a2) * 31 + - fromIntegral a3) * 31 + fromIntegral a4) * 31 + - a5) * 31 + fromIntegral a6) * 31 + - fromIntegral a7) * 31 + fromIntegral a8) * 31 + - fromIntegral a9) * 31 + fromIntegral a10) * 31 + - fromIntegral a11) * 31 + fromIntegral a12 - -testM5 :: IO () -testM5 = do - a1 <- randomIO - a2 <- randomIO - a3 <- randomIO - a4 <- randomIO - a5 <- randomIO - a6 <- randomIO - a7 <- randomIO - a8 <- randomIO - a9 <- randomIO - a10 <- randomIO - a11 <- randomIO - a12 <- randomIO - funAddr <- mkFunM5 manyArgsM5 - print (callFunM5 funAddr a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 == - manyArgsM5 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12) - freeHaskellFunPtr funAddr - --------------------------------------------------------------------------------- - -type FunTypeM6 = Int -> Int -> Int -> Int -> Int -> Double -> Int -> Int -> Int - -> Int -> Int -> Int -> Double - -foreign import ccall "dynamic" callFunM6 :: FunPtr FunTypeM6 -> FunTypeM6 -foreign import ccall "wrapper" mkFunM6 :: FunTypeM6 -> IO (FunPtr FunTypeM6) - -manyArgsM6 :: FunTypeM6 -manyArgsM6 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 = - ((((((((((fromIntegral a1 * 31 + fromIntegral a2) * 31 + - fromIntegral a3) * 31 + fromIntegral a4) * 31 + - fromIntegral a5) * 31 + a6) * 31 + - fromIntegral a7) * 31 + fromIntegral a8) * 31 + - fromIntegral a9) * 31 + fromIntegral a10) * 31 + - fromIntegral a11) * 31 + fromIntegral a12 - -testM6 :: IO () -testM6 = do - a1 <- randomIO - a2 <- randomIO - a3 <- randomIO - a4 <- randomIO - a5 <- randomIO - a6 <- randomIO - a7 <- randomIO - a8 <- randomIO - a9 <- randomIO - a10 <- randomIO - a11 <- randomIO - a12 <- randomIO - funAddr <- mkFunM6 manyArgsM6 - print (callFunM6 funAddr a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 == - manyArgsM6 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12) - freeHaskellFunPtr funAddr - --------------------------------------------------------------------------------- - -type FunTypeM7 = Int -> Int -> Int -> Int -> Int -> Int -> Double -> Int -> Int - -> Int -> Int -> Int -> Double - -foreign import ccall "dynamic" callFunM7 :: FunPtr FunTypeM7 -> FunTypeM7 -foreign import ccall "wrapper" mkFunM7 :: FunTypeM7 -> IO (FunPtr FunTypeM7) - -manyArgsM7 :: FunTypeM7 -manyArgsM7 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 = - ((((((((((fromIntegral a1 * 31 + fromIntegral a2) * 31 + - fromIntegral a3) * 31 + fromIntegral a4) * 31 + - fromIntegral a5) * 31 + fromIntegral a6) * 31 + - a7) * 31 + fromIntegral a8) * 31 + - fromIntegral a9) * 31 + fromIntegral a10) * 31 + - fromIntegral a11) * 31 + fromIntegral a12 - -testM7 :: IO () -testM7 = do - a1 <- randomIO - a2 <- randomIO - a3 <- randomIO - a4 <- randomIO - a5 <- randomIO - a6 <- randomIO - a7 <- randomIO - a8 <- randomIO - a9 <- randomIO - a10 <- randomIO - a11 <- randomIO - a12 <- randomIO - funAddr <- mkFunM7 manyArgsM7 - print (callFunM7 funAddr a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 == - manyArgsM7 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12) - freeHaskellFunPtr funAddr - --------------------------------------------------------------------------------- - -type FunTypeM8 = Int -> Int -> Int -> Int -> Int -> Int -> Int -> Double -> Int - -> Int -> Int -> Int -> Double - -foreign import ccall "dynamic" callFunM8 :: FunPtr FunTypeM8 -> FunTypeM8 -foreign import ccall "wrapper" mkFunM8 :: FunTypeM8 -> IO (FunPtr FunTypeM8) - -manyArgsM8 :: FunTypeM8 -manyArgsM8 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 = - ((((((((((fromIntegral a1 * 31 + fromIntegral a2) * 31 + - fromIntegral a3) * 31 + fromIntegral a4) * 31 + - fromIntegral a5) * 31 + fromIntegral a6) * 31 + - fromIntegral a7) * 31 + a8) * 31 + - fromIntegral a9) * 31 + fromIntegral a10) * 31 + - fromIntegral a11) * 31 + fromIntegral a12 - -testM8 :: IO () -testM8 = do - a1 <- randomIO - a2 <- randomIO - a3 <- randomIO - a4 <- randomIO - a5 <- randomIO - a6 <- randomIO - a7 <- randomIO - a8 <- randomIO - a9 <- randomIO - a10 <- randomIO - a11 <- randomIO - a12 <- randomIO - funAddr <- mkFunM8 manyArgsM8 - print (callFunM8 funAddr a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 == - manyArgsM8 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12) - freeHaskellFunPtr funAddr - --------------------------------------------------------------------------------- - -type FunTypeM9 = Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Double - -> Int -> Int -> Int -> Double - -foreign import ccall "dynamic" callFunM9 :: FunPtr FunTypeM9 -> FunTypeM9 -foreign import ccall "wrapper" mkFunM9 :: FunTypeM9 -> IO (FunPtr FunTypeM9) - -manyArgsM9 :: FunTypeM9 -manyArgsM9 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 = - ((((((((((fromIntegral a1 * 31 + fromIntegral a2) * 31 + - fromIntegral a3) * 31 + fromIntegral a4) * 31 + - fromIntegral a5) * 31 + fromIntegral a6) * 31 + - fromIntegral a7) * 31 + fromIntegral a8) * 31 + - a9) * 31 + fromIntegral a10) * 31 + - fromIntegral a11) * 31 + fromIntegral a12 - -testM9 :: IO () -testM9 = do - a1 <- randomIO - a2 <- randomIO - a3 <- randomIO - a4 <- randomIO - a5 <- randomIO - a6 <- randomIO - a7 <- randomIO - a8 <- randomIO - a9 <- randomIO - a10 <- randomIO - a11 <- randomIO - a12 <- randomIO - funAddr <- mkFunM9 manyArgsM9 - print (callFunM9 funAddr a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 == - manyArgsM9 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12) - freeHaskellFunPtr funAddr - --------------------------------------------------------------------------------- - -type FunTypeM10 = Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int - -> Double -> Int -> Int -> Double - -foreign import ccall "dynamic" callFunM10 :: FunPtr FunTypeM10 -> FunTypeM10 -foreign import ccall "wrapper" mkFunM10 :: FunTypeM10 -> IO (FunPtr FunTypeM10) - -manyArgsM10 :: FunTypeM10 -manyArgsM10 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 = - ((((((((((fromIntegral a1 * 31 + fromIntegral a2) * 31 + - fromIntegral a3) * 31 + fromIntegral a4) * 31 + - fromIntegral a5) * 31 + fromIntegral a6) * 31 + - fromIntegral a7) * 31 + fromIntegral a8) * 31 + - fromIntegral a9) * 31 + a10) * 31 + - fromIntegral a11) * 31 + fromIntegral a12 - -testM10 :: IO () -testM10 = do - a1 <- randomIO - a2 <- randomIO - a3 <- randomIO - a4 <- randomIO - a5 <- randomIO - a6 <- randomIO - a7 <- randomIO - a8 <- randomIO - a9 <- randomIO - a10 <- randomIO - a11 <- randomIO - a12 <- randomIO - funAddr <- mkFunM10 manyArgsM10 - print (callFunM10 funAddr a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 == - manyArgsM10 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12) - freeHaskellFunPtr funAddr - --------------------------------------------------------------------------------- - -type FunTypeM11 = Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int - -> Int -> Double -> Int -> Double - -foreign import ccall "dynamic" callFunM11 :: FunPtr FunTypeM11 -> FunTypeM11 -foreign import ccall "wrapper" mkFunM11 :: FunTypeM11 -> IO (FunPtr FunTypeM11) - -manyArgsM11 :: FunTypeM11 -manyArgsM11 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 = - ((((((((((fromIntegral a1 * 31 + fromIntegral a2) * 31 + - fromIntegral a3) * 31 + fromIntegral a4) * 31 + - fromIntegral a5) * 31 + fromIntegral a6) * 31 + - fromIntegral a7) * 31 + fromIntegral a8) * 31 + - fromIntegral a9) * 31 + fromIntegral a10) * 31 + - a11) * 31 + fromIntegral a12 - -testM11 :: IO () -testM11 = do - a1 <- randomIO - a2 <- randomIO - a3 <- randomIO - a4 <- randomIO - a5 <- randomIO - a6 <- randomIO - a7 <- randomIO - a8 <- randomIO - a9 <- randomIO - a10 <- randomIO - a11 <- randomIO - a12 <- randomIO - funAddr <- mkFunM11 manyArgsM11 - print (callFunM11 funAddr a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 == - manyArgsM11 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12) - freeHaskellFunPtr funAddr - --------------------------------------------------------------------------------- - -type FunTypeM12 = Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int - -> Int -> Int -> Double -> Double - -foreign import ccall "dynamic" callFunM12 :: FunPtr FunTypeM12 -> FunTypeM12 -foreign import ccall "wrapper" mkFunM12 :: FunTypeM12 -> IO (FunPtr FunTypeM12) - -manyArgsM12 :: FunTypeM12 -manyArgsM12 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 = - ((((((((((fromIntegral a1 * 31 + fromIntegral a2) * 31 + - fromIntegral a3) * 31 + fromIntegral a4) * 31 + - fromIntegral a5) * 31 + fromIntegral a6) * 31 + - fromIntegral a7) * 31 + fromIntegral a8) * 31 + - fromIntegral a9) * 31 + fromIntegral a10) * 31 + - fromIntegral a11) * 31 + a12 - -testM12 :: IO () -testM12 = do - a1 <- randomIO - a2 <- randomIO - a3 <- randomIO - a4 <- randomIO - a5 <- randomIO - a6 <- randomIO - a7 <- randomIO - a8 <- randomIO - a9 <- randomIO - a10 <- randomIO - a11 <- randomIO - a12 <- randomIO - funAddr <- mkFunM12 manyArgsM12 - print (callFunM12 funAddr a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 == - manyArgsM12 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12) - freeHaskellFunPtr funAddr - --------------------------------------------------------------------------------- - -rep :: String -> IO () -> IO () -rep msg tst = do - putStrLn ("Testing " ++ msg ++ "...") - sequence_ (replicate 10 tst) - -main :: IO () -main = do - setStdGen (mkStdGen 4711) - rep "5 Int arguments" test5I - rep "11 Double arguments" test11D - rep "11 mixed arguments" test11M - rep "Double as 1st argument, rest Int" testM1 - rep "Double as 2nd argument, rest Int" testM2 - rep "Double as 3rd argument, rest Int" testM3 - rep "Double as 4th argument, rest Int" testM4 - rep "Double as 5th argument, rest Int" testM5 - rep "Double as 6th argument, rest Int" testM6 - rep "Double as 7th argument, rest Int" testM7 - rep "Double as 8th argument, rest Int" testM8 - rep "Double as 9th argument, rest Int" testM9 - rep "Double as 10th argument, rest Int" testM10 - rep "Double as 11th argument, rest Int" testM11 - rep "Double as 12th argument, rest Int" testM12 |