Switch to a more dynamic, time-based test generation scheme.

2020-03-01 16:56:17 -08:00
parent 71451617f9
commit 9c76d7e0b4
12 changed files with 212 additions and 374 deletions
--- a/generation/src/Add.hs
+++ b/generation/src/Add.hs
@@ -16,11 +16,8 @@ import Language.Rust.Data.Ident
 import Language.Rust.Data.Position
 import Language.Rust.Quote
 import Language.Rust.Syntax
-import System.Random(RandomGen)
-
 import RustModule
-numTestCases :: Int
-numTestCases = 3000
+import System.Random(RandomGen)

 safeAddOps :: RustModule
 safeAddOps = RustModule {
@@ -28,7 +25,7 @@ safeAddOps = RustModule {
    outputName = "safe_add",
    isUnsigned = True,
    generator = declareSafeAddOperators,
-    testCase = Just generateSafeTests
+    testCase = Just generateSafeTest
 }

 unsafeAddOps :: RustModule
@@ -37,7 +34,7 @@ unsafeAddOps = RustModule {
    outputName = "unsafe_add",
    isUnsigned = True,
    generator = declareUnsafeAddOperators,
-    testCase = Just generateUnsafeTests
+    testCase = Just generateUnsafeTest
 }

 safeSignedAddOps :: RustModule
@@ -46,7 +43,7 @@ safeSignedAddOps = RustModule {
    outputName = "safe_sadd",
    isUnsigned = False,
    generator = declareSafeSignedAddOperators,
-    testCase = Just generateSafeSignedTests
+    testCase = Just generateSafeSignedTest
 }

 unsafeSignedAddOps :: RustModule
@@ -55,7 +52,7 @@ unsafeSignedAddOps = RustModule {
    outputName = "unsafe_sadd",
    isUnsigned = False,
    generator = declareUnsafeSignedAddOperators,
-    testCase = Just generateUnsafeSignedTests
+    testCase = Just generateUnsafeSignedTest
 }

 declareSafeAddOperators :: Word -> [Word] -> SourceFile Span
@@ -374,48 +371,32 @@ generateSetters useLastCarry maxI resName i
 where
  target = mkIdent resName

-generateSafeTests :: RandomGen g => Word -> g -> [Map String String]
-generateSafeTests size g = go g numTestCases
+generateSafeTest :: RandomGen g => Word -> g -> (Map String String, g)
+generateSafeTest size g0 = (tcase, g2)
 where
-  go _  0 = []
-  go g0 i =
-    let (x, g1) = generateNum g0 size
+  (x, g1) = generateNum g0 size
  (y, g2) = generateNum g1 size
-        tcase   = Map.fromList [("x", showX x), ("y", showX y),
-                                ("z", showX (x + y))]
-    in tcase : go g2 (i - 1)
+  tcase   = Map.fromList [("x", showX x), ("y", showX y), ("z", showX (x + y))]

-generateUnsafeTests :: RandomGen g => Word -> g -> [Map String String]
-generateUnsafeTests size g = go g numTestCases
+generateUnsafeTest :: RandomGen g => Word -> g -> (Map String String, g)
+generateUnsafeTest size g0 = (tcase, g2)
 where
-  go _  0 = []
-  go g0 i =
-    let (x, g1) = generateNum g0 size
+  (x, g1) = generateNum g0 size
  (y, g2) = generateNum g1 size
  z       = (x + y) .&. ((2 ^ size) - 1)
-        tcase   = Map.fromList [("x", showX x), ("y", showX y),
-                                ("z", showX z)]
-    in tcase : go g2 (i - 1)
+  tcase   = Map.fromList [("x", showX x), ("y", showX y), ("z", showX z)]

-generateSafeSignedTests :: RandomGen g => Word -> g -> [Map String String]
-generateSafeSignedTests size g = go g numTestCases
+generateSafeSignedTest :: RandomGen g => Word -> g -> (Map String String, g)
+generateSafeSignedTest size g0 = (tcase, g2)
 where
-  go _  0 = []
-  go g0 i =
-    let (x, g1) = generateSignedNum g0 size
+  (x, g1) = generateSignedNum g0 size
  (y, g2) = generateSignedNum g1 size
-        tcase   = Map.fromList [("x", showX x), ("y", showX y),
-                                ("z", showX (x + y))]
-    in tcase : go g2 (i - 1)
+  tcase   = Map.fromList [("x", showX x), ("y", showX y), ("z", showX (x + y))]

-generateUnsafeSignedTests :: RandomGen g => Word -> g -> [Map String String]
-generateUnsafeSignedTests size g = go g numTestCases
+generateUnsafeSignedTest :: RandomGen g => Word -> g -> (Map String String, g)
+generateUnsafeSignedTest size g0 = (tcase, g2)
 where
-  go _  0 = []
-  go g0 i =
-    let (x, g1) = generateSignedNum g0 size
+  (x, g1) = generateSignedNum g0 size
  (y, g2) = generateSignedNum g1 size
  z       = (x + y) .&. ((2 ^ size) - 1)
-        tcase   = Map.fromList [("x", showX x), ("y", showX y),
-                                ("z", showX z)]
-    in tcase : go g2 (i - 1)
+  tcase   = Map.fromList [("x", showX x), ("y", showX y), ("z", showX z)]
--- a/generation/src/BinaryOps.hs
+++ b/generation/src/BinaryOps.hs
@@ -16,16 +16,13 @@ import Language.Rust.Syntax
 import RustModule
 import System.Random(RandomGen)

-numTestCases :: Int
-numTestCases = 3000
-
 binaryOps :: RustModule
 binaryOps = RustModule {
    predicate = \ _ _ -> True,
    outputName = "binary",
    isUnsigned = True,
    generator = declareBinaryOperators,
-    testCase = Just generateTests
+    testCase = Just generateTest
 }

 declareBinaryOperators :: Word -> [Word] -> SourceFile Span
@@ -240,16 +237,13 @@ generateAllTheVariants traitname func sname oper entries = [
                           [expr| $$(right).value[$$(i)] |]
                           mempty) mempty

-generateTests :: RandomGen g => Word -> g -> [Map String String]
-generateTests size g = go g numTestCases
+generateTest :: RandomGen g => Word -> g -> (Map String String, g)
+generateTest size g0 = (tcase, g2)
 where
-  go _  0 = []
-  go g0 i =
-   let (x, g1) = generateNum g0 size
+  (x, g1) = generateNum g0 size
  (y, g2) = generateNum g1 size
  tcase   = Map.fromList [("x", showX x), ("y", showX y),
                          ("a", showX (x .&. y)),
                          ("o", showX (x .|. y)),
                          ("e", showX (x `xor` y)),
                          ("n", showX ( ((2 ^ size) - 1) `xor` x ))]
-   in tcase : go g2 (i - 1)
--- a/generation/src/Compare.hs
+++ b/generation/src/Compare.hs
@@ -12,16 +12,13 @@ import Language.Rust.Syntax
 import RustModule
 import System.Random(RandomGen)

-numTestCases :: Int
-numTestCases = 3000
-
 comparisons :: RustModule
 comparisons = RustModule {
  predicate = \ _ _ -> True,
  outputName = "compare",
  isUnsigned = True,
  generator = declareComparators,
-  testCase = Just generateTests
+  testCase = Just generateTest
 }

 signedComparisons :: RustModule
@@ -30,7 +27,7 @@ signedComparisons = RustModule {
  outputName = "scompare",
  isUnsigned = False,
  generator = declareSignedComparators,
-  testCase = Just generateSignedTests
+  testCase = Just generateSignedTest
 }

 declareComparators :: Word -> [Word] -> SourceFile Span
@@ -249,12 +246,10 @@ buildCompareExp i numEntries
 where
  x = Lit [] (Int Dec (fromIntegral i) Unsuffixed mempty) mempty

-generateTests :: RandomGen g => Word -> g -> [Map String String]
-generateTests size g = go g numTestCases
+generateTest :: RandomGen g => Word -> g -> (Map String String, g)
+generateTest size g0 = (tcase, g2)
 where
-  go _  0 = []
-  go g0 i =
-   let (x, g1) = generateNum g0 size
+  (x, g1) = generateNum g0 size
  (y, g2) = generateNum g1 size
  tcase   = Map.fromList [("x", showX x), ("y", showX y),
                          ("e", showB (x == y)),
@@ -263,14 +258,11 @@ generateTests size g = go g numTestCases
                          ("h", showB (x >= y)),
                          ("l", showB (x <  y)),
                          ("k", showB (x <= y))]
-   in tcase : go g2 (i - 1)

-generateSignedTests :: RandomGen g => Word -> g -> [Map String String]
-generateSignedTests size g = go g numTestCases
+generateSignedTest :: RandomGen g => Word -> g -> (Map String String, g)
+generateSignedTest size g0 = (tcase, g2)
 where
-  go _  0 = []
-  go g0 i =
-   let (x, g1) = generateSignedNum g0 size
+  (x, g1) = generateSignedNum g0 size
  (y, g2) = generateSignedNum g1 size
  tcase   = Map.fromList [("x", showX x), ("y", showX y),
                          ("e", showB (x == y)),
@@ -279,4 +271,3 @@ generateSignedTests size g = go g numTestCases
                          ("h", showB (x >= y)),
                          ("l", showB (x <  y)),
                          ("k", showB (x <= y))]
-   in tcase : go g2 (i - 1)
--- a/generation/src/CryptoNum.hs
+++ b/generation/src/CryptoNum.hs
@@ -16,16 +16,13 @@ import Language.Rust.Syntax
 import RustModule
 import System.Random(RandomGen)

-numTestCases :: Int
-numTestCases = 3000
-
 cryptoNum :: RustModule
 cryptoNum = RustModule {
  predicate = \ _ _ -> True,
  outputName = "cryptonum",
  isUnsigned = True,
  generator = declareCryptoNumInstance,
-  testCase = Just generateTests
+  testCase = Just generateTest
 }

 declareCryptoNumInstance :: Word -> [Word] -> SourceFile Span
@@ -176,12 +173,10 @@ generateZeroTests i entries
      in [stmt| result &= self.value[$$(ilit)] == 0; |] :
         generateZeroTests (i + 1) entries

-generateTests :: RandomGen g => Word -> g -> [Map String String]
-generateTests size g = go g numTestCases
+generateTest :: RandomGen g => Word -> g -> (Map String String, g)
+generateTest size g0 = (tcase, g3)
 where
-  go _  0 = []
-  go g0 i =
-   let (x, g1) = generateNum g0 size
+  (x, g1) = generateNum g0 size
  (m, g2) = generateNum g1 size
  (b, g3) = generateNum g2 16
  m'      = m `mod` (fromIntegral size `div` 64)
@@ -191,5 +186,3 @@ generateTests size g = go g numTestCases
                          ("e", showB (even x)), ("o", showB (odd x)),
                          ("m", showX m'),       ("r", showX r),
                          ("b", showX b),        ("t", showB t)]
-   in tcase : go g3 (i - 1)
-
--- a/generation/src/Division.hs
+++ b/generation/src/Division.hs
@@ -13,16 +13,13 @@ import Language.Rust.Syntax
 import RustModule
 import System.Random(RandomGen)

-numTestCases :: Int
-numTestCases = 3000
-
 divisionOps :: RustModule
 divisionOps = RustModule {
    predicate = \ _ _ -> True,
    outputName = "divmod",
    isUnsigned = True,
    generator = declareDivision,
-    testCase = Just generateDivisionTests
+    testCase = Just generateDivisionTest
 }

 declareDivision :: Word -> [Word] -> SourceFile Span
@@ -196,17 +193,15 @@ doCopy i =
    let liti = toLit i
    in [stmt| self.value[$$(liti)] = res.value[$$(liti)]; |]

-generateDivisionTests :: RandomGen g => Word -> g -> [Map String String]
-generateDivisionTests size g = go g numTestCases
+generateDivisionTest :: RandomGen g => Word -> g -> (Map String String, g)
+generateDivisionTest size g = go g
 where
-  go _  0 = []
-  go g0 i =
+  go g0 =
    let (x, g1) = generateNum g0 size
        (y, g2) = generateNum g1 size
        tcase   = Map.fromList [("x", showX x), ("y", showX y),
                                ("z", showX (x `div` y)),
                                ("r", showX (x `mod` y))]
    in if y == 0
-         then go g2 i
-         else tcase : go g2 (i - 1)
-
+         then go g2
+         else (tcase, g2)
--- a/generation/src/ModInv.hs
+++ b/generation/src/ModInv.hs
@@ -17,16 +17,13 @@ import Language.Rust.Syntax
 import RustModule
 import System.Random(RandomGen)

-numTestCases :: Int
-numTestCases = 100
-
 generateModInvOps :: RustModule
 generateModInvOps = RustModule {
    predicate = \ me others -> (me + 64) `elem` others,
    outputName = "modinv",
    isUnsigned = True,
    generator = declareModInv,
-    testCase = Just generateModInvTests
+    testCase = Just generateModInvTest
 }

 declareModInv :: Word -> [Word] -> SourceFile Span 
@@ -221,11 +218,10 @@ declareModInv bitsize _ =
        }
     |]

-generateModInvTests :: RandomGen g => Word -> g -> [Map String String]
-generateModInvTests size g = go g numTestCases
+generateModInvTest :: RandomGen g => Word -> g -> (Map String String, g)
+generateModInvTest size g = go g
 where
-  go _  0 = []
-  go g0 i =
+  go g0 =
   let (x, g1)   = generateNum g0 size
       (y, g2)   = generateNum g1 size
       z         = recipModInteger x y
@@ -234,12 +230,12 @@ generateModInvTests size g = go g numTestCases
                                 ("z", showX z), ("a", showX a),
                                 ("b", showX b), ("v", showX v)]
   in if z == 0
-        then go g2 i
+        then go g2
        else assert (z < y) $
             assert ((x * z) `mod` y == 1) $
             assert (((a * x) + (b * y)) == v) $
             assert (v == gcd x y) $
-             tcase : go g2 (i - 1)
+             (tcase, g2)

 extendedGCD :: Integer -> Integer -> (Integer, Integer, Integer)
 extendedGCD x y = (a, b, g * (v finalState))
--- a/generation/src/ModOps.hs
+++ b/generation/src/ModOps.hs
@@ -13,16 +13,13 @@ import Language.Rust.Syntax
 import RustModule
 import System.Random(RandomGen)

-numTestCases :: Int
-numTestCases = 1000
-
 modulusOps :: RustModule
 modulusOps = RustModule {
    predicate = \ me others -> (me * 2) `elem` others,
    outputName = "modops",
    isUnsigned = True,
    generator = declareModOps,
-    testCase = Just generateModulusTests
+    testCase = Just generateModulusTest
 }

 declareModOps :: Word -> [Word] -> SourceFile Span
@@ -110,11 +107,10 @@ declareModOps bitsize _ =
        }
     |]

-generateModulusTests :: RandomGen g => Word -> g -> [Map String String]
-generateModulusTests size g = go g numTestCases
+generateModulusTest :: RandomGen g => Word -> g -> (Map String String, g)
+generateModulusTest size g = go g
 where
-  go _  0 = []
-  go g0 i =
+  go g0 =
    let (x, g1) = generateNum g0 size
        (y, g2) = generateNum g1 size
        (m, g3) = generateNum g2 size
@@ -126,7 +122,7 @@ generateModulusTests size g = go g numTestCases
                                ("e", showX (powModInteger x y m))
                               ]
    in if y < 2
-         then go g3 i
-         else tcase : go g3 (i - 1)
+         then go g3
+         else (tcase, g3)


--- a/generation/src/Multiply.hs
+++ b/generation/src/Multiply.hs
@@ -19,16 +19,13 @@ import Language.Rust.Syntax
 import RustModule
 import System.Random(RandomGen)

-numTestCases :: Int
-numTestCases = 3000
-
 safeMultiplyOps :: RustModule
 safeMultiplyOps = RustModule {
    predicate = \ me others -> (me * 2) `elem` others,
    outputName = "safe_mul",
    isUnsigned = True,
    generator = declareSafeMulOperators,
-    testCase = Just generateSafeTests
+    testCase = Just generateSafeTest
 }

 unsafeMultiplyOps :: RustModule
@@ -37,7 +34,7 @@ unsafeMultiplyOps = RustModule {
    outputName = "unsafe_mul",
    isUnsigned = True,
    generator = declareUnsafeMulOperators,
-    testCase = Just generateUnsafeTests
+    testCase = Just generateUnsafeTest
 }

 declareSafeMulOperators :: Word -> [Word] -> SourceFile Span
@@ -289,31 +286,17 @@ inVars instr =

 -- -----------------------------------------------------------------------------

-generateSafeTests :: RandomGen g => Word -> g -> [Map String String]
-generateSafeTests size g = go g numTestCases
+generateSafeTest :: RandomGen g => Word -> g -> (Map String String, g)
+generateSafeTest size g0 = (tcase, g2)
 where
-  go _  0 = [
-      Map.fromList [("x", "0"), ("y", "0"), ("z", "0")]
-    , (let x = (2 ^ size) - 1
-           y = (2 ^ size) - 1
-           z = x * y
-        in Map.fromList [("x", showX x), ("y", showX y), ("z", showX z)])
-     ]
-  go g0 i =
-    let (x, g1) = generateNum g0 size
+  (x, g1) = generateNum g0 size
  (y, g2) = generateNum g1 size
-        tcase   = Map.fromList [("x", showX x), ("y", showX y),
-                                ("z", showX (x * y))]
-    in tcase : go g2 (i - 1)
+  tcase   = Map.fromList [("x", showX x), ("y", showX y), ("z", showX (x * y))]

-generateUnsafeTests :: RandomGen g => Word -> g -> [Map String String]
-generateUnsafeTests size g = go g numTestCases
+generateUnsafeTest :: RandomGen g => Word -> g -> (Map String String, g)
+generateUnsafeTest size g0 = (tcase, g2)
 where
-  go _  0 = []
-  go g0 i =
-    let (x, g1) = generateNum g0 size
+  (x, g1) = generateNum g0 size
  (y, g2) = generateNum g1 size
  z       = (x * y) .&. ((2 ^ size) - 1)
-        tcase   = Map.fromList [("x", showX x), ("y", showX y),
-                                ("z", showX z)]
-    in tcase : go g2 (i - 1)
+  tcase   = Map.fromList [("x", showX x), ("y", showX y), ("z", showX z)]
--- a/generation/src/RustModule.hs
+++ b/generation/src/RustModule.hs
@@ -8,7 +8,7 @@ module RustModule(
       )
 where

-import Control.Monad(forM_)
+import Control.Monad(forM_, unless)
 import Data.Char(toUpper)
 import Data.List(isPrefixOf, partition)
 import Data.Map.Strict(Map)
@@ -19,15 +19,29 @@ import Language.Rust.Data.Position(Span, spanOf)
 import Language.Rust.Pretty(writeSourceFile)
 import Language.Rust.Quote(item, sourceFile)
 import Language.Rust.Syntax(Item(..), SourceFile(..), Visibility(..))
+import System.CPUTime(getCPUTime)
 import System.IO(Handle,hPutStrLn)
 import System.Random(RandomGen(..))

+minimumTestCases :: Int
+minimumTestCases = 10
+
+maximumTestCases :: Int
+maximumTestCases = 5000
+
+targetTestGenerationTime :: Float
+targetTestGenerationTime = 5.0 -- in seconds
+
+targetTestGenerationPicos :: Integer
+targetTestGenerationPicos =
+  floor (targetTestGenerationTime * 1000000000000.0)
+
 data RustModule = RustModule {
    predicate :: Word -> [Word] -> Bool,
    outputName :: String,
    isUnsigned :: Bool,
    generator :: Word -> [Word] -> SourceFile Span,
-    testCase :: forall g. RandomGen g => Maybe (Word -> g -> [Map String String])
+    testCase :: forall g. RandomGen g => Maybe (Word -> g -> (Map String String, g))
 }

 data Task = Task {
@@ -96,96 +110,34 @@ generateTests :: RandomGen g =>
                 Maybe Task
 generateTests size rng m = fmap builder (testCase m)
 where
-  builder testGeneration =
+  builder testGenerator =
    let outFile = "testdata/" ++ outputName m ++ "/" ++ testFile (isUnsigned m) size
-        testGenAction hndl = writeTestCase hndl (testGeneration size (snd (split rng)))
+        testGenAction hndl = writeTestCases hndl (snd (split rng)) (testGenerator size)
    in Task outFile testGenAction

--   basicTasks ++ moduleTasks
-- where
--  basicTasks = go rng files sizes
--  moduleTasks = generateModules basicTasks
--  --
--  go :: RandomGen g => g -> [RustModule] -> [Word] -> [Task]
--  go _ []             _  = []
--  go g (_:rest)       [] = go g rest sizes
--  go g files'@(file:_) (size:rest)
--    | not (predicate file size sizes) = go g files' rest
--    | otherwise =
--        let (myg, theirg) = split g
--            tasks = go theirg files' rest
--            (signedBit, prefix) | isUnsigned file = ("unsigned", "u")
--                                | otherwise       = ("signed", "i")
--            mainTask = Task {
--              outputFile = "src" </> signedBit </> (prefix ++ show size) </>
--                           outputName file ++ ".rs",
--              writer = \ hndl -> writeSourceFile hndl (generator file size sizes)
--            }
--        in case testCase file of
--             Nothing ->
--               mainTask : tasks
--             Just caseGenerator ->
--               let testTask = Task {
--                     outputFile = "testdata" </> outputName file </> testFile (isUnsigned file) size,
--                     writer = \ hndl -> writeTestCase hndl (caseGenerator size myg)
--                   }
--               in testTask : mainTask : tasks
--
--generateModules :: [Task] -> [Task]
--generateModules tasks = Map.foldrWithKey maddModule [] fileMap ++ [signedTask, unsignedTask]
-- where
--  maddModule path mods acc
--   | ("src/unsigned" `isPrefixOf` path) || ("src/signed" `isPrefixOf` path) =
--        let (basePath, lowerName) = splitFileName (init path)
--            upperName = map toUpper lowerName
--            task = Task {
--              outputFile = basePath </> lowerName ++ ".rs",
--              writer = \ hndl ->
--                do forM_ mods $ \ modl ->
--                     hPutStrLn hndl ("mod " ++ modl ++ ";")
--                   hPutStrLn hndl ("pub use base::" ++ upperName ++ ";")
--            }
--        in task : acc
--   | otherwise =
--        acc
--  fileMap = foldr buildBaseMap Map.empty tasks
--  buildBaseMap task acc =
--    let (dir, fileext) = splitFileName (outputFile task)
--        file = dropExtension fileext
--    in Map.insertWith (++) dir [file] acc
--  --
--  signedTask = moduleTask "signed"
--  unsignedTask = moduleTask "unsigned"
--  moduleTask kind =
--    let mods = Map.foldrWithKey (topModule kind) [] fileMap
--        pubuses = Map.foldrWithKey (pubUse kind) [] fileMap
--    in Task {
--         outputFile = "src" </> (kind ++ ".rs"),
--         writer = \ hndl ->
--           writeSourceFile hndl [sourceFile|
--             $@{mods}
--             $@{pubuses}
--          |]
--       }
--  topModule kind path _ acc
--   | ("src/" ++ kind) `isPrefixOf` path =
--        let lowerName = takeFileName (init path)
--            modl = mkIdent lowerName
--        in [item| mod $$modl; |] : acc
--   | otherwise =
--        acc
--  pubUse kind path _ acc
--   | ("src/" ++ kind) `isPrefixOf` path =
--        let lowerName = takeFileName (init path)
--            tname = mkIdent (map toUpper lowerName)
--            modl = mkIdent lowerName
--        in [item| pub use $$modl::$$tname; |] : acc
--   | otherwise =
--        acc
--
--
-writeTestCase :: Handle -> [Map String String] -> IO ()
-writeTestCase hndl tests =
-  forM_ tests $ \ test ->
+writeTestCases :: RandomGen g =>
+                  Handle -> g ->
+                  (g -> (Map String String, g)) ->
+                  IO ()
+writeTestCases hndl rng nextTest =
+  do startTime <- getCPUTime
+     let stopTime = startTime + targetTestGenerationPicos
+     go 0 stopTime rng
+ where
+  go x endTime g
+   | x >= maximumTestCases = return ()
+   | x <  minimumTestCases = emit x endTime g
+   | otherwise =
+       do now <- getCPUTime
+          unless (now >= endTime) $
+            emit x endTime g
+  --
+  emit x endTime g =
+    do let (test, g') = nextTest g
+       writeTestCase hndl test
+       go (x + 1) endTime g'
+
+writeTestCase :: Handle -> Map String String -> IO ()
+writeTestCase hndl test =
  forM_ (Map.toList test) $ \ (key, value) ->
    hPutStrLn hndl (key ++ ": " ++ value)
--- a/generation/src/Scale.hs
+++ b/generation/src/Scale.hs
@@ -17,16 +17,13 @@ import Language.Rust.Syntax
 import RustModule
 import System.Random(RandomGen)

-numTestCases :: Int
-numTestCases = 3000
-
 safeScaleOps :: RustModule
 safeScaleOps = RustModule {
    predicate = \ me others -> (me + 64) `elem` others,
    outputName = "safe_scale",
    isUnsigned = True,
    generator = declareSafeScaleOperators,
-    testCase = Just generateSafeTests
+    testCase = Just generateSafeTest
 }

 unsafeScaleOps :: RustModule
@@ -35,7 +32,7 @@ unsafeScaleOps = RustModule {
    outputName = "unsafe_scale",
    isUnsigned = True,
    generator = declareUnsafeScaleOperators,
-    testCase = Just generateUnsafeTests
+    testCase = Just generateUnsafeTest
 }

 declareSafeScaleOperators :: Word -> [Word] -> SourceFile Span
@@ -256,26 +253,17 @@ generateScaletiplier full size input output = loaders ++ [bigy] ++ ripples ++

 -- -----------------------------------------------------------------------------

-generateSafeTests :: RandomGen g => Word -> g -> [Map String String]
-generateSafeTests size g = go g numTestCases
+generateSafeTest :: RandomGen g => Word -> g -> (Map String String, g)
+generateSafeTest size g0 = (tcase, g2)
 where
-  go _  0 = []
-  go g0 i =
-    let (x, g1) = generateNum g0 size
+  (x, g1) = generateNum g0 size
  (y, g2) = generateNum g1 64
-        tcase   = Map.fromList [("x", showX x), ("y", showX y),
-                                ("z", showX (x * y))]
-    in tcase : go g2 (i - 1)
+  tcase   = Map.fromList [("x", showX x), ("y", showX y), ("z", showX (x * y))]

-generateUnsafeTests :: RandomGen g => Word -> g -> [Map String String]
-generateUnsafeTests size g = go g numTestCases
+generateUnsafeTest :: RandomGen g => Word -> g -> (Map String String, g)
+generateUnsafeTest size g0 = (tcase, g2)
 where
-  go _  0 = []
-  go g0 i =
-    let (x, g1) = generateNum g0 size
+  (x, g1) = generateNum g0 size
  (y, g2) = generateNum g1 64
  z       = (x * y) .&. ((2 ^ size) - 1)
-        tcase   = Map.fromList [("x", showX x), ("y", showX y),
-                                ("z", showX z)]
-    in tcase : go g2 (i - 1)
-
+  tcase   = Map.fromList [("x", showX x), ("y", showX y), ("z", showX z)]
--- a/generation/src/Shift.hs
+++ b/generation/src/Shift.hs
@@ -14,16 +14,13 @@ import Language.Rust.Syntax
 import RustModule
 import System.Random(RandomGen)

-numTestCases :: Int
-numTestCases = 3000
-
 shiftOps :: RustModule
 shiftOps = RustModule {
    predicate = \ _ _ -> True,
    outputName = "shift",
    isUnsigned = True,
    generator = declareShiftOperators,
-    testCase = Just generateTests
+    testCase = Just generateTest
 }

 signedShiftOps :: RustModule
@@ -32,7 +29,7 @@ signedShiftOps = RustModule {
    outputName = "sshift",
    isUnsigned = False,
    generator = declareSignedShiftOperators,
-    testCase = Just generateSignedTests
+    testCase = Just generateSignedTest
 }

 declareShiftOperators :: Word -> [Word] -> SourceFile Span
@@ -298,31 +295,24 @@ generateBaseImpls sname upper_shift lower_shift assign_shift lassign_shift right
    |]
  ]

-generateTests :: RandomGen g => Word -> g -> [Map String String]
-generateTests size g = go g numTestCases
+generateTest :: RandomGen g => Word -> g -> (Map String String, g)
+generateTest size g0 = (tcase, g2)
 where
-  go _  0 = []
-  go g0 i =
-   let (x, g1) = generateNum g0 size
+  (x, g1) = generateNum g0 size
  (y, g2) = generateNum g1 size
  s       = y `mod` fromIntegral size
  l       = modulate (x `shiftL` fromIntegral s) size
  r       = modulate (x `shiftR` fromIntegral s) size
  tcase   = Map.fromList [("x", showX x), ("s", showX s),
                          ("l", showX l), ("r", showX r)]
-   in tcase : go g2 (i - 1)

-
-generateSignedTests :: RandomGen g => Word -> g -> [Map String String]
-generateSignedTests size g = go g numTestCases
+generateSignedTest :: RandomGen g => Word -> g -> (Map String String, g)
+generateSignedTest size g0 = (tcase, g2)
 where
-  go _  0 = []
-  go g0 i =
-   let (x, g1) = generateSignedNum g0 size
+  (x, g1) = generateSignedNum g0 size
  (y, g2) = generateNum g1 size
  s       = y `mod` fromIntegral size
  l       = modulate (x `shiftL` fromIntegral s) size
  r       = modulate (x `shiftR` fromIntegral s) size
  tcase   = Map.fromList [("x", showX x), ("s", showX s),
                          ("l", showX l), ("r", showX r)]
-   in tcase : go g2 (i - 1)
--- a/generation/src/Subtract.hs
+++ b/generation/src/Subtract.hs
@@ -19,16 +19,13 @@ import Language.Rust.Syntax
 import RustModule
 import System.Random(RandomGen)

-numTestCases :: Int
-numTestCases = 3000
-
 safeSubtractOps :: RustModule
 safeSubtractOps = RustModule {
    predicate = \ me others -> (me + 64) `elem` others,
    outputName = "safe_sub",
    isUnsigned = True,
    generator = declareSafeSubtractOperators,
-    testCase = Just generateSafeTests
+    testCase = Just generateSafeTest
 }

 safeSignedSubtractOps :: RustModule
@@ -37,7 +34,7 @@ safeSignedSubtractOps = RustModule {
    outputName = "safe_ssub",
    isUnsigned = False,
    generator = declareSafeSignedSubtractOperators,
-    testCase = Just generateSafeSignedTests
+    testCase = Just generateSafeSignedTest
 }

 unsafeSubtractOps :: RustModule
@@ -46,7 +43,7 @@ unsafeSubtractOps = RustModule {
    outputName = "unsafe_sub",
    isUnsigned = True,
    generator = declareUnsafeSubtractOperators,
-    testCase = Just generateUnsafeTests
+    testCase = Just generateUnsafeTest
 }

 unsafeSignedSubtractOps :: RustModule
@@ -55,7 +52,7 @@ unsafeSignedSubtractOps = RustModule {
    outputName = "unsafe_ssub",
    isUnsigned = False,
    generator = declareUnsafeSignedSubtractOperators,
-    testCase = Just generateUnsafeSignedTests
+    testCase = Just generateUnsafeSignedTest
 }

 declareSafeSubtractOperators :: Word -> [Word] -> SourceFile Span
@@ -321,54 +318,36 @@ generateSetters useLastCarry maxI resName i
 where
  target = mkIdent resName

-generateSafeTests :: RandomGen g => Word -> g -> [Map String String]
-generateSafeTests size g = go g numTestCases
+generateSafeTest :: RandomGen g => Word -> g -> (Map String String, g)
+generateSafeTest size g0 = (tcase, g2)
 where
-  go _  0 = []
-  go g0 i =
-    let (x, g1)       = generateNum g0 size
+  (x, g1)       = generateNum g0 size
  (y, g2)       = generateNum g1 size
  r | x < y     = (2 ^ (size + 64)) + (x - y)
    | otherwise = x - y
-        tcase         = Map.fromList [("x", showX x),
-                                      ("y", showX y),
-                                      ("z", showX r)]
-    in tcase : go g2 (i - 1)
+  tcase         = Map.fromList [("x", showX x), ("y", showX y), ("z", showX r)]

-generateSafeSignedTests :: RandomGen g => Word -> g -> [Map String String]
-generateSafeSignedTests size g = go g numTestCases
+generateSafeSignedTest :: RandomGen g => Word -> g -> (Map String String, g)
+generateSafeSignedTest size g0 = (tcase, g2)
 where
-  go _  0 = []
-  go g0 i =
-    let (x, g1)       = generateSignedNum g0 size
+  (x, g1)       = generateSignedNum g0 size
  (y, g2)       = generateSignedNum g1 size
  r | x < y     = (2 ^ (size + 64)) + (x - y)
    | otherwise = x - y
-        tcase         = Map.fromList [("x", showX x),
-                                      ("y", showX y),
-                                      ("z", showX r)]
-    in tcase : go g2 (i - 1)
+  tcase         = Map.fromList [("x", showX x), ("y", showX y), ("z", showX r)]

-generateUnsafeTests :: RandomGen g => Word -> g -> [Map String String]
-generateUnsafeTests size g = go g numTestCases
+generateUnsafeTest :: RandomGen g => Word -> g -> (Map String String, g)
+generateUnsafeTest size g0 = (tcase, g2)
 where
-  go _  0 = []
-  go g0 i =
-    let (x, g1) = generateNum g0 size
+  (x, g1) = generateNum g0 size
  (y, g2) = generateNum g1 size
  z       = (x - y) .&. ((2 ^ size) - 1)
-        tcase   = Map.fromList [("x", showX x), ("y", showX y),
-                                ("z", showX z)]
-    in tcase : go g2 (i - 1)
+  tcase   = Map.fromList [("x", showX x), ("y", showX y), ("z", showX z)]

-generateUnsafeSignedTests :: RandomGen g => Word -> g -> [Map String String]
-generateUnsafeSignedTests size g = go g numTestCases
+generateUnsafeSignedTest :: RandomGen g => Word -> g -> (Map String String, g)
+generateUnsafeSignedTest size g0 = (tcase, g2)
 where
-  go _  0 = []
-  go g0 i =
-    let (x, g1) = generateSignedNum g0 size
+  (x, g1) = generateSignedNum g0 size
  (y, g2) = generateSignedNum g1 size
  z       = (x - y) .&. ((2 ^ size) - 1)
-        tcase   = Map.fromList [("x", showX x), ("y", showX y),
-                                ("z", showX z)]
-    in tcase : go g2 (i - 1)
+  tcase   = Map.fromList [("x", showX x), ("y", showX y), ("z", showX z)]