Tests, that work!

generation/src/Compare.hs

@@ -2,11 +2,18 @@
 module Compare(comparisons)
  where
 
+import Data.Map.Strict(Map)
+import qualified Data.Map.Strict as Map
 import File
+import Generators
 import Language.Rust.Data.Ident
 import Language.Rust.Data.Position
 import Language.Rust.Quote
 import Language.Rust.Syntax
+import System.Random(RandomGen)
+
+numTestCases :: Int
+numTestCases = 3000
 
 comparisons :: File
 comparisons = File {
@@ -14,7 +21,7 @@ comparisons = File {
   outputName = "compare",
   isUnsigned = True,
   generator = declareComparators,
-  testCase = Nothing
+  testCase = Just generateTests
 }
 
 declareComparators :: Word -> SourceFile Span
@@ -23,9 +30,14 @@ declareComparators bitsize =
       entries = bitsize `div` 64
       eqStatements = buildEqStatements 0 entries
       compareExp = buildCompareExp 0 entries
+      testFileLit = Lit [] (Str (testFile bitsize) Cooked Unsuffixed mempty) mempty
   in [sourceFile|
        use core::cmp::{Eq,Ordering,PartialEq};
        #[cfg(test)]
+       use crate::CryptoNum;
+       #[cfg(test)]
+       use crate::testing::{build_test_path,run_test};
+       #[cfg(test)]
        use quickcheck::quickcheck;
        use super::$$sname;
 
@@ -73,7 +85,41 @@ declareComparators bitsize =
            if a <= b && b <= c { a <= c } else { true }
          }
        }
-     |]
+
+       #[cfg(test)]
+       #[allow(non_snake_case)]
+       #[test]
+       fn KATs() {
+         run_test(build_test_path("compare", $$(testFileLit)), 8, |case| {
+           let (neg0, xbytes) = case.get("x").unwrap();
+           let (neg1, ybytes) = case.get("y").unwrap();
+           let (neg2, ebytes) = case.get("e").unwrap();
+           let (neg3, nbytes) = case.get("n").unwrap();
+           let (neg4, gbytes) = case.get("g").unwrap();
+           let (neg5, hbytes) = case.get("h").unwrap();
+           let (neg6, lbytes) = case.get("l").unwrap();
+           let (neg7, kbytes) = case.get("k").unwrap();
+
+           assert!(!neg0 && !neg1 && !neg2 && !neg3 &&
+                   !neg4 && !neg5 && !neg6 && !neg7);
+           let x = $$sname::from_bytes(&xbytes);
+           let y = $$sname::from_bytes(&ybytes);
+           let e = 1 == ebytes[0];
+           let n = 1 == nbytes[0];
+           let g = 1 == gbytes[0];
+           let h = 1 == hbytes[0];
+           let l = 1 == lbytes[0];
+           let k = 1 == kbytes[0];
+
+           assert_eq!(e, x == y);
+           assert_eq!(n, x != y);
+           assert_eq!(g, x >  y);
+           assert_eq!(h, x >= y);
+           assert_eq!(l, x <  y);
+           assert_eq!(k, x <= y);
+         });
+       }
+    |]
 
 buildEqStatements :: Word -> Word -> [Stmt Span]
 buildEqStatements i numEntries
@@ -95,3 +141,19 @@ buildCompareExp i numEntries
       in [expr| $$(rest).then(self.value[$$(x)].cmp(&other.value[$$(x)])) |]
  where
   x = Lit [] (Int Dec (fromIntegral i) Unsuffixed mempty) mempty
+
+generateTests :: RandomGen g => Word -> g -> [Map String String]
+generateTests size g = go g numTestCases
+ where
+  go _  0 = []
+  go g0 i =
+   let (x, g1) = generateNum g0 size
+       (y, g2) = generateNum g1 size
+       tcase   = Map.fromList [("x", showX x), ("y", showX y),
+                               ("e", showB (x == y)),
+                               ("n", showB (x /= y)),
+                               ("g", showB (x >  y)),
+                               ("h", showB (x >= y)),
+                               ("l", showB (x <  y)),
+                               ("k", showB (x <= y))]
+   in tcase : go g2 (i - 1)