From d43f0bcd42b17a08a391203421afd38686bcdfae Mon Sep 17 00:00:00 2001 From: Adam Wick Date: Mon, 8 Oct 2018 20:34:36 -0700 Subject: [PATCH] Add the ability to ignore tests, so that day-to-day testing only takes a little while. --- generate.hs | 46 +++---- src/unsigned/add.rs | 46 ++++--- src/unsigned/barrett.rs | 96 ++++++++------ src/unsigned/base.rs | 52 +++++--- src/unsigned/cmp.rs | 52 +++++--- src/unsigned/div.rs | 42 +++--- src/unsigned/invoc.rs | 282 ++++++++++++++++++++-------------------- src/unsigned/modexp.rs | 94 ++++++++------ src/unsigned/modmul.rs | 98 ++++++++------ src/unsigned/modsq.rs | 86 +++++++----- src/unsigned/mul.rs | 34 +++-- src/unsigned/shifts.rs | 68 ++++++---- src/unsigned/square.rs | 30 +++-- src/unsigned/sub.rs | 38 ++++-- 14 files changed, 618 insertions(+), 446 deletions(-) diff --git a/generate.hs b/generate.hs index 8263389..6252958 100644 --- a/generate.hs +++ b/generate.hs @@ -104,9 +104,9 @@ numberOfTests :: Int numberOfTests = 1000 generateTestBlock :: Handle -> - String -> Operation -> Bool -> [Int -> Int] -> + String -> Operation -> Bool -> Int -> [Int -> Int] -> IO () -generateTestBlock hndl name level useRT addOns = +generateTestBlock hndl name level useRT ignoreAt addOns = do hPutStrLn hndl (" mod " ++ name ++ " {") when useRT $ do hPutStrLn hndl (" use super::super::*;") @@ -115,7 +115,9 @@ generateTestBlock hndl name level useRT addOns = forM_ requirements $ \ (Req size kind) -> when (kind == level) $ hPutStrLn hndl (" generate_" ++ name ++ - "_tests!(U" ++ show size ++ ", " ++ + "_tests!(" ++ + (if size >= ignoreAt then "ignore " else "") ++ + "U" ++ show size ++ ", " ++ "u" ++ show size ++ concatMap (\ f -> ", U" ++ show (f size)) addOns ++ ");") @@ -142,25 +144,25 @@ generateInvocs = hPutStrLn hndl "" hPutStrLn hndl "\n#[cfg(test)]" hPutStrLn hndl "mod tests {" - generateTestBlock hndl "base" BaseOps True [] - generateTestBlock hndl "conversion" BaseOps False [] - generateTestBlock hndl "codec" BaseOps False [] - generateTestBlock hndl "cmp" BaseOps True [] - generateTestBlock hndl "sub" Sub True [] - generateTestBlock hndl "shiftl" Shifts True [] - generateTestBlock hndl "shiftr" Shifts True [] - generateTestBlock hndl "add" Add True [(+ 64)] - generateTestBlock hndl "mul" Mul True [(* 2)] - generateTestBlock hndl "div" Div True [] - generateTestBlock hndl "barrett_gen" Barretts True [(+ 64)] - generateTestBlock hndl "barrett_red" Barretts True [(+ 64), (* 2)] - generateTestBlock hndl "modsq" ModSq True [] - generateTestBlock hndl "modmul" ModMul True [] - generateTestBlock hndl "modexp" ModExp True [] - generateTestBlock hndl "square" Square True [(* 2)] - generateTestBlock hndl "barrett_modsq" Barretts True [(+ 64)] - generateTestBlock hndl "barrett_modmul" Barretts True [(+ 64)] - generateTestBlock hndl "barrett_modexp" Barretts True [(+ 64)] + generateTestBlock hndl "base" BaseOps True 16384 [] + generateTestBlock hndl "conversion" BaseOps False 90000 [] + generateTestBlock hndl "codec" BaseOps False 90000 [] + generateTestBlock hndl "cmp" BaseOps True 16384 [] + generateTestBlock hndl "sub" Sub True 9000 [] + generateTestBlock hndl "shiftl" Shifts True 9000 [] + generateTestBlock hndl "shiftr" Shifts True 9000 [] + generateTestBlock hndl "add" Add True 9000 [(+ 64)] + generateTestBlock hndl "mul" Mul True 9000 [(* 2)] + generateTestBlock hndl "div" Div True 2049 [] + generateTestBlock hndl "barrett_gen" Barretts True 2000 [(+ 64)] + generateTestBlock hndl "barrett_red" Barretts True 4000 [(+ 64), (* 2)] + generateTestBlock hndl "modsq" ModSq True 4000 [] + generateTestBlock hndl "modmul" ModMul True 4000 [] + generateTestBlock hndl "modexp" ModExp True 512 [] + generateTestBlock hndl "square" Square True 4000 [(* 2)] + generateTestBlock hndl "barrett_modsq" Barretts True 4000 [(+ 64)] + generateTestBlock hndl "barrett_modmul" Barretts True 4000 [(+ 64)] + generateTestBlock hndl "barrett_modexp" Barretts True 1024 [(+ 64)] hPutStrLn hndl "}" log :: String -> IO () diff --git a/src/unsigned/add.rs b/src/unsigned/add.rs index 097370b..5d702df 100644 --- a/src/unsigned/add.rs +++ b/src/unsigned/add.rs @@ -103,24 +103,34 @@ macro_rules! generate_add_tests { ($name: ident, $lname: ident, $plus1: ident) => { #[test] fn $lname() { - let fname = format!("testdata/add/{}.tests", stringify!($name)); - run_test(fname.to_string(), 3, |case| { - let (neg0, abytes) = case.get("a").unwrap(); - let (neg1, bbytes) = case.get("b").unwrap(); - let (neg2, cbytes) = case.get("c").unwrap(); - assert!(!neg0 && !neg1 && !neg2); - - let a = $name::from_bytes(abytes); - let b = $name::from_bytes(bbytes); - let c = $plus1::from_bytes(cbytes); - assert_eq!(c, &a + &b); - - if c.value[c.value.len()-1] == 0 { - let mut aprime = a.clone(); - aprime += b; - assert_eq!($name::from(c), aprime); - } - }); + generate_add_tests!(body $name, $lname, $plus1); } }; + (ignore $name: ident, $lname: ident, $plus1: ident) => { + #[test] + #[ignore] + fn $lname() { + generate_add_tests!(body $name, $lname, $plus1); + } + }; + (body $name: ident, $lname: ident, $plus1: ident) => { + let fname = format!("testdata/add/{}.tests", stringify!($name)); + run_test(fname.to_string(), 3, |case| { + let (neg0, abytes) = case.get("a").unwrap(); + let (neg1, bbytes) = case.get("b").unwrap(); + let (neg2, cbytes) = case.get("c").unwrap(); + assert!(!neg0 && !neg1 && !neg2); + + let a = $name::from_bytes(abytes); + let b = $name::from_bytes(bbytes); + let c = $plus1::from_bytes(cbytes); + assert_eq!(c, &a + &b); + + if c.value[c.value.len()-1] == 0 { + let mut aprime = a.clone(); + aprime += b; + assert_eq!($name::from(c), aprime); + } + }); + }; } \ No newline at end of file diff --git a/src/unsigned/barrett.rs b/src/unsigned/barrett.rs index 5c8af11..abde097 100644 --- a/src/unsigned/barrett.rs +++ b/src/unsigned/barrett.rs @@ -75,27 +75,37 @@ macro_rules! generate_barrett_gen_tests { ($name: ident, $lname: ident, $bname: ident) => { #[test] fn $lname() { - let fname = format!("testdata/barrett_gen/{}.tests", stringify!($name)); - run_test(fname.to_string(), 3, |case| { - let (neg0, mbytes) = case.get("m").unwrap(); - let (neg1, kbytes) = case.get("k").unwrap(); - let (neg2, ubytes) = case.get("u").unwrap(); - assert!(!neg0 && !neg1 && !neg2); - - let m = $name::from_bytes(mbytes); - let kbig = $name::from_bytes(kbytes); - let mu = $bname::from_bytes(ubytes); - // - let mbig = $bname::from(&m); - let k = usize::from(&kbig); - // - let bar = m.generate_barrett(); - assert_eq!(k, bar.k); - assert_eq!(mbig, bar.m); - assert_eq!(mu, bar.mu); - }); + generate_barrett_gen_tests!(body $name, $lname, $bname); } }; + (ignore $name: ident, $lname: ident, $bname: ident) => { + #[test] + #[ignore] + fn $lname() { + generate_barrett_gen_tests!(body $name, $lname, $bname); + } + }; + (body $name: ident, $lname: ident, $bname: ident) => { + let fname = format!("testdata/barrett_gen/{}.tests", stringify!($name)); + run_test(fname.to_string(), 3, |case| { + let (neg0, mbytes) = case.get("m").unwrap(); + let (neg1, kbytes) = case.get("k").unwrap(); + let (neg2, ubytes) = case.get("u").unwrap(); + assert!(!neg0 && !neg1 && !neg2); + + let m = $name::from_bytes(mbytes); + let kbig = $name::from_bytes(kbytes); + let mu = $bname::from_bytes(ubytes); + // + let mbig = $bname::from(&m); + let k = usize::from(&kbig); + // + let bar = m.generate_barrett(); + assert_eq!(k, bar.k); + assert_eq!(mbig, bar.m); + assert_eq!(mu, bar.mu); + }); + }; } #[cfg(test)] @@ -103,25 +113,35 @@ macro_rules! generate_barrett_red_tests { ($name: ident, $lname: ident, $bname: ident, $dbl: ident) => { #[test] fn $lname() { - let fname = format!("testdata/barrett_reduce/{}.tests", stringify!($name)); - run_test(fname.to_string(), 5, |case| { - let (neg0, mbytes) = case.get("m").unwrap(); - let (neg1, kbytes) = case.get("k").unwrap(); - let (neg2, ubytes) = case.get("u").unwrap(); - let (neg3, xbytes) = case.get("x").unwrap(); - let (neg4, rbytes) = case.get("r").unwrap(); - assert!(!neg0 && !neg1 && !neg2 && !neg3 && !neg4); - - let m = $name::from_bytes(mbytes); - let kbig = $name::from_bytes(kbytes); - let k = usize::from(&kbig); - let mu = $bname::from_bytes(ubytes); - let bar = $name::new_barrett(usize::from(k), $bname::from(m), mu); - let x = $dbl::from_bytes(xbytes); - let r = $name::from_bytes(rbytes); - // - assert_eq!(r, bar.reduce(&x)); - }); + generate_barrett_red_tests!(body $name, $lname, $bname, $dbl); } }; + (ignore $name: ident, $lname: ident, $bname: ident, $dbl: ident) => { + #[test] + #[ignore] + fn $lname() { + generate_barrett_red_tests!(body $name, $lname, $bname, $dbl); + } + }; + (body $name: ident, $lname: ident, $bname: ident, $dbl: ident) => { + let fname = format!("testdata/barrett_reduce/{}.tests", stringify!($name)); + run_test(fname.to_string(), 5, |case| { + let (neg0, mbytes) = case.get("m").unwrap(); + let (neg1, kbytes) = case.get("k").unwrap(); + let (neg2, ubytes) = case.get("u").unwrap(); + let (neg3, xbytes) = case.get("x").unwrap(); + let (neg4, rbytes) = case.get("r").unwrap(); + assert!(!neg0 && !neg1 && !neg2 && !neg3 && !neg4); + + let m = $name::from_bytes(mbytes); + let kbig = $name::from_bytes(kbytes); + let k = usize::from(&kbig); + let mu = $bname::from_bytes(ubytes); + let bar = $name::new_barrett(usize::from(k), $bname::from(m), mu); + let x = $dbl::from_bytes(xbytes); + let r = $name::from_bytes(rbytes); + // + assert_eq!(r, bar.reduce(&x)); + }); + }; } \ No newline at end of file diff --git a/src/unsigned/base.rs b/src/unsigned/base.rs index 94c9337..78fd9be 100644 --- a/src/unsigned/base.rs +++ b/src/unsigned/base.rs @@ -69,27 +69,37 @@ macro_rules! generate_base_tests ($name: ident, $lname: ident) => { #[test] fn $lname() { - let fname = format!("testdata/base/{}.tests", stringify!($name)); - run_test(fname.to_string(), 6, |case| { - let (neg0, xbytes) = case.get("x").unwrap(); - let (neg1, mbytes) = case.get("m").unwrap(); - let (neg2, zbytes) = case.get("z").unwrap(); - let (neg3, ebytes) = case.get("e").unwrap(); - let (neg4, obytes) = case.get("o").unwrap(); - let (neg5, rbytes) = case.get("r").unwrap(); - assert!(!neg0 && !neg1 && !neg2 && !neg3 && !neg4 && !neg5); - let mut x = $name::from_bytes(xbytes); - let m = $name::from_bytes(mbytes); - let z = 1 == zbytes[0]; - let e = 1 == ebytes[0]; - let o = 1 == obytes[0]; - let r = $name::from_bytes(rbytes); - assert_eq!(x.is_zero(), z); - assert_eq!(x.is_even(), e); - assert_eq!(x.is_odd(), o); - x.mask(usize::from(&m)); - assert_eq!(x, r); - }); + generate_base_tests!(body $name, $lname); } + }; + (ignore $name: ident, $lname: ident) => { + #[test] + #[ignore] + fn $lname() { + generate_base_tests!(body $name, $lname); + } + }; + (body $name: ident, $lname: ident) => { + let fname = format!("testdata/base/{}.tests", stringify!($name)); + run_test(fname.to_string(), 6, |case| { + let (neg0, xbytes) = case.get("x").unwrap(); + let (neg1, mbytes) = case.get("m").unwrap(); + let (neg2, zbytes) = case.get("z").unwrap(); + let (neg3, ebytes) = case.get("e").unwrap(); + let (neg4, obytes) = case.get("o").unwrap(); + let (neg5, rbytes) = case.get("r").unwrap(); + assert!(!neg0 && !neg1 && !neg2 && !neg3 && !neg4 && !neg5); + let mut x = $name::from_bytes(xbytes); + let m = $name::from_bytes(mbytes); + let z = 1 == zbytes[0]; + let e = 1 == ebytes[0]; + let o = 1 == obytes[0]; + let r = $name::from_bytes(rbytes); + assert_eq!(x.is_zero(), z); + assert_eq!(x.is_even(), e); + assert_eq!(x.is_odd(), o); + x.mask(usize::from(&m)); + assert_eq!(x, r); + }); } } \ No newline at end of file diff --git a/src/unsigned/cmp.rs b/src/unsigned/cmp.rs index 1379744..7992f08 100644 --- a/src/unsigned/cmp.rs +++ b/src/unsigned/cmp.rs @@ -46,27 +46,37 @@ macro_rules! generate_cmp_tests { ($name: ident, $lname: ident) => { #[test] fn $lname() { - let fname = format!("testdata/cmp/{}.tests", stringify!($name)); - run_test(fname.to_string(), 5, |case| { - let (neg0, abytes) = case.get("a").unwrap(); - let (neg1, bbytes) = case.get("b").unwrap(); - let (neg2, ebytes) = case.get("e").unwrap(); - let (neg3, gbytes) = case.get("g").unwrap(); - let (neg4, lbytes) = case.get("l").unwrap(); - assert!(!neg0 && !neg1 && !neg2 && !neg3 && !neg4); - let a = $name::from_bytes(abytes); - let b = $name::from_bytes(bbytes); - let e = 1 == ebytes[0]; - let g = 1 == gbytes[0]; - let l = 1 == lbytes[0]; - - assert_eq!(e, a == b); - assert_eq!(g, a > b); - assert_eq!(l, a < b); - - assert_eq!(e || g, a >= b); - assert_eq!(e || l, a <= b); - }); + generate_cmp_tests!(body $name, $lname); } }; + (ignore $name: ident, $lname: ident) => { + #[test] + #[ignore] + fn $lname() { + generate_cmp_tests!(body $name, $lname); + } + }; + (body $name: ident, $lname: ident) => { + let fname = format!("testdata/cmp/{}.tests", stringify!($name)); + run_test(fname.to_string(), 5, |case| { + let (neg0, abytes) = case.get("a").unwrap(); + let (neg1, bbytes) = case.get("b").unwrap(); + let (neg2, ebytes) = case.get("e").unwrap(); + let (neg3, gbytes) = case.get("g").unwrap(); + let (neg4, lbytes) = case.get("l").unwrap(); + assert!(!neg0 && !neg1 && !neg2 && !neg3 && !neg4); + let a = $name::from_bytes(abytes); + let b = $name::from_bytes(bbytes); + let e = 1 == ebytes[0]; + let g = 1 == gbytes[0]; + let l = 1 == lbytes[0]; + + assert_eq!(e, a == b); + assert_eq!(g, a > b); + assert_eq!(l, a < b); + + assert_eq!(e || g, a >= b); + assert_eq!(e || l, a <= b); + }); + }; } \ No newline at end of file diff --git a/src/unsigned/div.rs b/src/unsigned/div.rs index 29f30ac..35c4e49 100644 --- a/src/unsigned/div.rs +++ b/src/unsigned/div.rs @@ -226,22 +226,32 @@ macro_rules! generate_div_tests { ($name: ident, $lname: ident) => { #[test] fn $lname() { - let fname = format!("testdata/div/{}.tests", stringify!($name)); - run_test(fname.to_string(), 4, |case| { - let (neg0, abytes) = case.get("a").unwrap(); - let (neg1, bbytes) = case.get("b").unwrap(); - let (neg2, qbytes) = case.get("q").unwrap(); - let (neg3, rbytes) = case.get("r").unwrap(); - assert!(!neg0 && !neg1 && !neg2 && !neg3); - - let a = $name::from_bytes(abytes); - let b = $name::from_bytes(bbytes); - let q = $name::from_bytes(qbytes); - let r = $name::from_bytes(rbytes); - let (myq, myr) = a.divmod(&b); - assert_eq!(q, myq); - assert_eq!(r, myr); - }); + generate_div_tests!(body $name, $lname); } }; + (ignore $name: ident, $lname: ident) => { + #[test] + #[ignore] + fn $lname() { + generate_div_tests!(body $name, $lname); + } + }; + (body $name: ident, $lname: ident) => { + let fname = format!("testdata/div/{}.tests", stringify!($name)); + run_test(fname.to_string(), 4, |case| { + let (neg0, abytes) = case.get("a").unwrap(); + let (neg1, bbytes) = case.get("b").unwrap(); + let (neg2, qbytes) = case.get("q").unwrap(); + let (neg3, rbytes) = case.get("r").unwrap(); + assert!(!neg0 && !neg1 && !neg2 && !neg3); + + let a = $name::from_bytes(abytes); + let b = $name::from_bytes(bbytes); + let q = $name::from_bytes(qbytes); + let r = $name::from_bytes(rbytes); + let (myq, myr) = a.divmod(&b); + assert_eq!(q, myq); + assert_eq!(r, myr); + }); + }; } \ No newline at end of file diff --git a/src/unsigned/invoc.rs b/src/unsigned/invoc.rs index 4e15e6c..b98bd9c 100644 --- a/src/unsigned/invoc.rs +++ b/src/unsigned/invoc.rs @@ -470,22 +470,22 @@ mod tests { generate_base_tests!(U15360, u15360); generate_base_tests!(U15424, u15424); generate_base_tests!(U15488, u15488); - generate_base_tests!(U16384, u16384); - generate_base_tests!(U16448, u16448); - generate_base_tests!(U16512, u16512); - generate_base_tests!(U16576, u16576); - generate_base_tests!(U30720, u30720); - generate_base_tests!(U30784, u30784); - generate_base_tests!(U30848, u30848); - generate_base_tests!(U30912, u30912); - generate_base_tests!(U32768, u32768); - generate_base_tests!(U32832, u32832); - generate_base_tests!(U32896, u32896); - generate_base_tests!(U32960, u32960); - generate_base_tests!(U61440, u61440); - generate_base_tests!(U61504, u61504); - generate_base_tests!(U61568, u61568); - generate_base_tests!(U61632, u61632); + generate_base_tests!(ignore U16384, u16384); + generate_base_tests!(ignore U16448, u16448); + generate_base_tests!(ignore U16512, u16512); + generate_base_tests!(ignore U16576, u16576); + generate_base_tests!(ignore U30720, u30720); + generate_base_tests!(ignore U30784, u30784); + generate_base_tests!(ignore U30848, u30848); + generate_base_tests!(ignore U30912, u30912); + generate_base_tests!(ignore U32768, u32768); + generate_base_tests!(ignore U32832, u32832); + generate_base_tests!(ignore U32896, u32896); + generate_base_tests!(ignore U32960, u32960); + generate_base_tests!(ignore U61440, u61440); + generate_base_tests!(ignore U61504, u61504); + generate_base_tests!(ignore U61568, u61568); + generate_base_tests!(ignore U61632, u61632); } mod conversion { generate_conversion_tests!(U192, u192); @@ -680,22 +680,22 @@ mod tests { generate_cmp_tests!(U15360, u15360); generate_cmp_tests!(U15424, u15424); generate_cmp_tests!(U15488, u15488); - generate_cmp_tests!(U16384, u16384); - generate_cmp_tests!(U16448, u16448); - generate_cmp_tests!(U16512, u16512); - generate_cmp_tests!(U16576, u16576); - generate_cmp_tests!(U30720, u30720); - generate_cmp_tests!(U30784, u30784); - generate_cmp_tests!(U30848, u30848); - generate_cmp_tests!(U30912, u30912); - generate_cmp_tests!(U32768, u32768); - generate_cmp_tests!(U32832, u32832); - generate_cmp_tests!(U32896, u32896); - generate_cmp_tests!(U32960, u32960); - generate_cmp_tests!(U61440, u61440); - generate_cmp_tests!(U61504, u61504); - generate_cmp_tests!(U61568, u61568); - generate_cmp_tests!(U61632, u61632); + generate_cmp_tests!(ignore U16384, u16384); + generate_cmp_tests!(ignore U16448, u16448); + generate_cmp_tests!(ignore U16512, u16512); + generate_cmp_tests!(ignore U16576, u16576); + generate_cmp_tests!(ignore U30720, u30720); + generate_cmp_tests!(ignore U30784, u30784); + generate_cmp_tests!(ignore U30848, u30848); + generate_cmp_tests!(ignore U30912, u30912); + generate_cmp_tests!(ignore U32768, u32768); + generate_cmp_tests!(ignore U32832, u32832); + generate_cmp_tests!(ignore U32896, u32896); + generate_cmp_tests!(ignore U32960, u32960); + generate_cmp_tests!(ignore U61440, u61440); + generate_cmp_tests!(ignore U61504, u61504); + generate_cmp_tests!(ignore U61568, u61568); + generate_cmp_tests!(ignore U61632, u61632); } mod sub { use super::super::*; @@ -724,19 +724,19 @@ mod tests { generate_sub_tests!(U8192, u8192); generate_sub_tests!(U8256, u8256); generate_sub_tests!(U8320, u8320); - generate_sub_tests!(U12288, u12288); - generate_sub_tests!(U12416, u12416); - generate_sub_tests!(U15424, u15424); - generate_sub_tests!(U16384, u16384); - generate_sub_tests!(U16448, u16448); - generate_sub_tests!(U16512, u16512); - generate_sub_tests!(U30720, u30720); - generate_sub_tests!(U30784, u30784); - generate_sub_tests!(U30848, u30848); - generate_sub_tests!(U32768, u32768); - generate_sub_tests!(U32896, u32896); - generate_sub_tests!(U61440, u61440); - generate_sub_tests!(U61568, u61568); + generate_sub_tests!(ignore U12288, u12288); + generate_sub_tests!(ignore U12416, u12416); + generate_sub_tests!(ignore U15424, u15424); + generate_sub_tests!(ignore U16384, u16384); + generate_sub_tests!(ignore U16448, u16448); + generate_sub_tests!(ignore U16512, u16512); + generate_sub_tests!(ignore U30720, u30720); + generate_sub_tests!(ignore U30784, u30784); + generate_sub_tests!(ignore U30848, u30848); + generate_sub_tests!(ignore U32768, u32768); + generate_sub_tests!(ignore U32896, u32896); + generate_sub_tests!(ignore U61440, u61440); + generate_sub_tests!(ignore U61568, u61568); } mod shiftl { use super::super::*; @@ -767,15 +767,15 @@ mod tests { generate_shiftl_tests!(U8192, u8192); generate_shiftl_tests!(U8256, u8256); generate_shiftl_tests!(U8320, u8320); - generate_shiftl_tests!(U15360, u15360); - generate_shiftl_tests!(U15424, u15424); - generate_shiftl_tests!(U15488, u15488); - generate_shiftl_tests!(U16384, u16384); - generate_shiftl_tests!(U16448, u16448); - generate_shiftl_tests!(U16512, u16512); - generate_shiftl_tests!(U30720, u30720); - generate_shiftl_tests!(U30784, u30784); - generate_shiftl_tests!(U30848, u30848); + generate_shiftl_tests!(ignore U15360, u15360); + generate_shiftl_tests!(ignore U15424, u15424); + generate_shiftl_tests!(ignore U15488, u15488); + generate_shiftl_tests!(ignore U16384, u16384); + generate_shiftl_tests!(ignore U16448, u16448); + generate_shiftl_tests!(ignore U16512, u16512); + generate_shiftl_tests!(ignore U30720, u30720); + generate_shiftl_tests!(ignore U30784, u30784); + generate_shiftl_tests!(ignore U30848, u30848); } mod shiftr { use super::super::*; @@ -806,15 +806,15 @@ mod tests { generate_shiftr_tests!(U8192, u8192); generate_shiftr_tests!(U8256, u8256); generate_shiftr_tests!(U8320, u8320); - generate_shiftr_tests!(U15360, u15360); - generate_shiftr_tests!(U15424, u15424); - generate_shiftr_tests!(U15488, u15488); - generate_shiftr_tests!(U16384, u16384); - generate_shiftr_tests!(U16448, u16448); - generate_shiftr_tests!(U16512, u16512); - generate_shiftr_tests!(U30720, u30720); - generate_shiftr_tests!(U30784, u30784); - generate_shiftr_tests!(U30848, u30848); + generate_shiftr_tests!(ignore U15360, u15360); + generate_shiftr_tests!(ignore U15424, u15424); + generate_shiftr_tests!(ignore U15488, u15488); + generate_shiftr_tests!(ignore U16384, u16384); + generate_shiftr_tests!(ignore U16448, u16448); + generate_shiftr_tests!(ignore U16512, u16512); + generate_shiftr_tests!(ignore U30720, u30720); + generate_shiftr_tests!(ignore U30784, u30784); + generate_shiftr_tests!(ignore U30848, u30848); } mod add { use super::super::*; @@ -843,19 +843,19 @@ mod tests { generate_add_tests!(U8192, u8192, U8256); generate_add_tests!(U8256, u8256, U8320); generate_add_tests!(U8320, u8320, U8384); - generate_add_tests!(U12288, u12288, U12352); - generate_add_tests!(U12416, u12416, U12480); - generate_add_tests!(U15424, u15424, U15488); - generate_add_tests!(U16384, u16384, U16448); - generate_add_tests!(U16448, u16448, U16512); - generate_add_tests!(U16512, u16512, U16576); - generate_add_tests!(U30720, u30720, U30784); - generate_add_tests!(U30784, u30784, U30848); - generate_add_tests!(U30848, u30848, U30912); - generate_add_tests!(U32768, u32768, U32832); - generate_add_tests!(U32896, u32896, U32960); - generate_add_tests!(U61440, u61440, U61504); - generate_add_tests!(U61568, u61568, U61632); + generate_add_tests!(ignore U12288, u12288, U12352); + generate_add_tests!(ignore U12416, u12416, U12480); + generate_add_tests!(ignore U15424, u15424, U15488); + generate_add_tests!(ignore U16384, u16384, U16448); + generate_add_tests!(ignore U16448, u16448, U16512); + generate_add_tests!(ignore U16512, u16512, U16576); + generate_add_tests!(ignore U30720, u30720, U30784); + generate_add_tests!(ignore U30784, u30784, U30848); + generate_add_tests!(ignore U30848, u30848, U30912); + generate_add_tests!(ignore U32768, u32768, U32832); + generate_add_tests!(ignore U32896, u32896, U32960); + generate_add_tests!(ignore U61440, u61440, U61504); + generate_add_tests!(ignore U61568, u61568, U61632); } mod mul { use super::super::*; @@ -887,12 +887,12 @@ mod tests { generate_mul_tests!(U7744, u7744, U15488); generate_mul_tests!(U8192, u8192, U16384); generate_mul_tests!(U8256, u8256, U16512); - generate_mul_tests!(U15360, u15360, U30720); - generate_mul_tests!(U15424, u15424, U30848); - generate_mul_tests!(U16384, u16384, U32768); - generate_mul_tests!(U16448, u16448, U32896); - generate_mul_tests!(U30720, u30720, U61440); - generate_mul_tests!(U30784, u30784, U61568); + generate_mul_tests!(ignore U15360, u15360, U30720); + generate_mul_tests!(ignore U15424, u15424, U30848); + generate_mul_tests!(ignore U16384, u16384, U32768); + generate_mul_tests!(ignore U16448, u16448, U32896); + generate_mul_tests!(ignore U30720, u30720, U61440); + generate_mul_tests!(ignore U30784, u30784, U61568); } mod div { use super::super::*; @@ -909,19 +909,19 @@ mod tests { generate_div_tests!(U1152, u1152); generate_div_tests!(U1216, u1216); generate_div_tests!(U2048, u2048); - generate_div_tests!(U2112, u2112); - generate_div_tests!(U4096, u4096); - generate_div_tests!(U4160, u4160); - generate_div_tests!(U6144, u6144); - generate_div_tests!(U6208, u6208); - generate_div_tests!(U8192, u8192); - generate_div_tests!(U8256, u8256); - generate_div_tests!(U15360, u15360); - generate_div_tests!(U15424, u15424); - generate_div_tests!(U16384, u16384); - generate_div_tests!(U16448, u16448); - generate_div_tests!(U30720, u30720); - generate_div_tests!(U30784, u30784); + generate_div_tests!(ignore U2112, u2112); + generate_div_tests!(ignore U4096, u4096); + generate_div_tests!(ignore U4160, u4160); + generate_div_tests!(ignore U6144, u6144); + generate_div_tests!(ignore U6208, u6208); + generate_div_tests!(ignore U8192, u8192); + generate_div_tests!(ignore U8256, u8256); + generate_div_tests!(ignore U15360, u15360); + generate_div_tests!(ignore U15424, u15424); + generate_div_tests!(ignore U16384, u16384); + generate_div_tests!(ignore U16448, u16448); + generate_div_tests!(ignore U30720, u30720); + generate_div_tests!(ignore U30784, u30784); } mod barrett_gen { use super::super::*; @@ -933,12 +933,12 @@ mod tests { generate_barrett_gen_tests!(U512, u512, U576); generate_barrett_gen_tests!(U576, u576, U640); generate_barrett_gen_tests!(U1024, u1024, U1088); - generate_barrett_gen_tests!(U2048, u2048, U2112); - generate_barrett_gen_tests!(U3072, u3072, U3136); - generate_barrett_gen_tests!(U4096, u4096, U4160); - generate_barrett_gen_tests!(U7680, u7680, U7744); - generate_barrett_gen_tests!(U8192, u8192, U8256); - generate_barrett_gen_tests!(U15360, u15360, U15424); + generate_barrett_gen_tests!(ignore U2048, u2048, U2112); + generate_barrett_gen_tests!(ignore U3072, u3072, U3136); + generate_barrett_gen_tests!(ignore U4096, u4096, U4160); + generate_barrett_gen_tests!(ignore U7680, u7680, U7744); + generate_barrett_gen_tests!(ignore U8192, u8192, U8256); + generate_barrett_gen_tests!(ignore U15360, u15360, U15424); } mod barrett_red { use super::super::*; @@ -952,10 +952,10 @@ mod tests { generate_barrett_red_tests!(U1024, u1024, U1088, U2048); generate_barrett_red_tests!(U2048, u2048, U2112, U4096); generate_barrett_red_tests!(U3072, u3072, U3136, U6144); - generate_barrett_red_tests!(U4096, u4096, U4160, U8192); - generate_barrett_red_tests!(U7680, u7680, U7744, U15360); - generate_barrett_red_tests!(U8192, u8192, U8256, U16384); - generate_barrett_red_tests!(U15360, u15360, U15424, U30720); + generate_barrett_red_tests!(ignore U4096, u4096, U4160, U8192); + generate_barrett_red_tests!(ignore U7680, u7680, U7744, U15360); + generate_barrett_red_tests!(ignore U8192, u8192, U8256, U16384); + generate_barrett_red_tests!(ignore U15360, u15360, U15424, U30720); } mod modsq { use super::super::*; @@ -969,10 +969,10 @@ mod tests { generate_modsq_tests!(U1024, u1024); generate_modsq_tests!(U2048, u2048); generate_modsq_tests!(U3072, u3072); - generate_modsq_tests!(U4096, u4096); - generate_modsq_tests!(U7680, u7680); - generate_modsq_tests!(U8192, u8192); - generate_modsq_tests!(U15360, u15360); + generate_modsq_tests!(ignore U4096, u4096); + generate_modsq_tests!(ignore U7680, u7680); + generate_modsq_tests!(ignore U8192, u8192); + generate_modsq_tests!(ignore U15360, u15360); } mod modmul { use super::super::*; @@ -986,10 +986,10 @@ mod tests { generate_modmul_tests!(U1024, u1024); generate_modmul_tests!(U2048, u2048); generate_modmul_tests!(U3072, u3072); - generate_modmul_tests!(U4096, u4096); - generate_modmul_tests!(U7680, u7680); - generate_modmul_tests!(U8192, u8192); - generate_modmul_tests!(U15360, u15360); + generate_modmul_tests!(ignore U4096, u4096); + generate_modmul_tests!(ignore U7680, u7680); + generate_modmul_tests!(ignore U8192, u8192); + generate_modmul_tests!(ignore U15360, u15360); } mod modexp { use super::super::*; @@ -998,15 +998,15 @@ mod tests { generate_modexp_tests!(U192, u192); generate_modexp_tests!(U256, u256); generate_modexp_tests!(U384, u384); - generate_modexp_tests!(U512, u512); - generate_modexp_tests!(U576, u576); - generate_modexp_tests!(U1024, u1024); - generate_modexp_tests!(U2048, u2048); - generate_modexp_tests!(U3072, u3072); - generate_modexp_tests!(U4096, u4096); - generate_modexp_tests!(U7680, u7680); - generate_modexp_tests!(U8192, u8192); - generate_modexp_tests!(U15360, u15360); + generate_modexp_tests!(ignore U512, u512); + generate_modexp_tests!(ignore U576, u576); + generate_modexp_tests!(ignore U1024, u1024); + generate_modexp_tests!(ignore U2048, u2048); + generate_modexp_tests!(ignore U3072, u3072); + generate_modexp_tests!(ignore U4096, u4096); + generate_modexp_tests!(ignore U7680, u7680); + generate_modexp_tests!(ignore U8192, u8192); + generate_modexp_tests!(ignore U15360, u15360); } mod square { use super::super::*; @@ -1020,10 +1020,10 @@ mod tests { generate_square_tests!(U1024, u1024, U2048); generate_square_tests!(U2048, u2048, U4096); generate_square_tests!(U3072, u3072, U6144); - generate_square_tests!(U4096, u4096, U8192); - generate_square_tests!(U7680, u7680, U15360); - generate_square_tests!(U8192, u8192, U16384); - generate_square_tests!(U15360, u15360, U30720); + generate_square_tests!(ignore U4096, u4096, U8192); + generate_square_tests!(ignore U7680, u7680, U15360); + generate_square_tests!(ignore U8192, u8192, U16384); + generate_square_tests!(ignore U15360, u15360, U30720); } mod barrett_modsq { use super::super::*; @@ -1037,10 +1037,10 @@ mod tests { generate_barrett_modsq_tests!(U1024, u1024, U1088); generate_barrett_modsq_tests!(U2048, u2048, U2112); generate_barrett_modsq_tests!(U3072, u3072, U3136); - generate_barrett_modsq_tests!(U4096, u4096, U4160); - generate_barrett_modsq_tests!(U7680, u7680, U7744); - generate_barrett_modsq_tests!(U8192, u8192, U8256); - generate_barrett_modsq_tests!(U15360, u15360, U15424); + generate_barrett_modsq_tests!(ignore U4096, u4096, U4160); + generate_barrett_modsq_tests!(ignore U7680, u7680, U7744); + generate_barrett_modsq_tests!(ignore U8192, u8192, U8256); + generate_barrett_modsq_tests!(ignore U15360, u15360, U15424); } mod barrett_modmul { use super::super::*; @@ -1054,10 +1054,10 @@ mod tests { generate_barrett_modmul_tests!(U1024, u1024, U1088); generate_barrett_modmul_tests!(U2048, u2048, U2112); generate_barrett_modmul_tests!(U3072, u3072, U3136); - generate_barrett_modmul_tests!(U4096, u4096, U4160); - generate_barrett_modmul_tests!(U7680, u7680, U7744); - generate_barrett_modmul_tests!(U8192, u8192, U8256); - generate_barrett_modmul_tests!(U15360, u15360, U15424); + generate_barrett_modmul_tests!(ignore U4096, u4096, U4160); + generate_barrett_modmul_tests!(ignore U7680, u7680, U7744); + generate_barrett_modmul_tests!(ignore U8192, u8192, U8256); + generate_barrett_modmul_tests!(ignore U15360, u15360, U15424); } mod barrett_modexp { use super::super::*; @@ -1068,12 +1068,12 @@ mod tests { generate_barrett_modexp_tests!(U384, u384, U448); generate_barrett_modexp_tests!(U512, u512, U576); generate_barrett_modexp_tests!(U576, u576, U640); - generate_barrett_modexp_tests!(U1024, u1024, U1088); - generate_barrett_modexp_tests!(U2048, u2048, U2112); - generate_barrett_modexp_tests!(U3072, u3072, U3136); - generate_barrett_modexp_tests!(U4096, u4096, U4160); - generate_barrett_modexp_tests!(U7680, u7680, U7744); - generate_barrett_modexp_tests!(U8192, u8192, U8256); - generate_barrett_modexp_tests!(U15360, u15360, U15424); + generate_barrett_modexp_tests!(ignore U1024, u1024, U1088); + generate_barrett_modexp_tests!(ignore U2048, u2048, U2112); + generate_barrett_modexp_tests!(ignore U3072, u3072, U3136); + generate_barrett_modexp_tests!(ignore U4096, u4096, U4160); + generate_barrett_modexp_tests!(ignore U7680, u7680, U7744); + generate_barrett_modexp_tests!(ignore U8192, u8192, U8256); + generate_barrett_modexp_tests!(ignore U15360, u15360, U15424); } } diff --git a/src/unsigned/modexp.rs b/src/unsigned/modexp.rs index 42d5f9e..67b1322 100644 --- a/src/unsigned/modexp.rs +++ b/src/unsigned/modexp.rs @@ -41,52 +41,72 @@ macro_rules! generate_modexp_tests { ($name: ident, $lname: ident) => { #[test] fn $lname() { - let fname = format!("testdata/modexp/{}.tests", stringify!($name)); - run_test(fname.to_string(), 6, |case| { - let (neg0, bbytes) = case.get("b").unwrap(); - let (neg1, ebytes) = case.get("e").unwrap(); - let (neg2, mbytes) = case.get("m").unwrap(); - let (neg3, rbytes) = case.get("r").unwrap(); - assert!(!neg0 && !neg1 && !neg2 && !neg3); - - let b = $name::from_bytes(bbytes); - let e = $name::from_bytes(ebytes); - let m = $name::from_bytes(mbytes); - let r = $name::from_bytes(rbytes); - assert_eq!(r, b.modexp(&e, &m)); - }); + generate_modexp_tests!(body $name, $lname); } }; + (ignore $name: ident, $lname: ident) => { + #[test] + #[ignore] + fn $lname() { + generate_modexp_tests!(body $name, $lname); + } + }; + (body $name: ident, $lname: ident) => { + let fname = format!("testdata/modexp/{}.tests", stringify!($name)); + run_test(fname.to_string(), 6, |case| { + let (neg0, bbytes) = case.get("b").unwrap(); + let (neg1, ebytes) = case.get("e").unwrap(); + let (neg2, mbytes) = case.get("m").unwrap(); + let (neg3, rbytes) = case.get("r").unwrap(); + assert!(!neg0 && !neg1 && !neg2 && !neg3); + + let b = $name::from_bytes(bbytes); + let e = $name::from_bytes(ebytes); + let m = $name::from_bytes(mbytes); + let r = $name::from_bytes(rbytes); + assert_eq!(r, b.modexp(&e, &m)); + }); + }; } #[cfg(test)] macro_rules! generate_barrett_modexp_tests { + (ignore $name: ident, $lname: ident, $bname: ident) => { + #[test] + #[ignore] + fn $lname() { + generate_barrett_modexp_tests!(body $name, $lname, $bname); + } + }; ($name: ident, $lname: ident, $bname: ident) => { #[test] fn $lname() { - let fname = format!("testdata/modexp/{}.tests", stringify!($name)); - run_test(fname.to_string(), 6, |case| { - let (neg0, bbytes) = case.get("b").unwrap(); - let (neg1, ebytes) = case.get("e").unwrap(); - let (neg2, mbytes) = case.get("m").unwrap(); - let (neg3, rbytes) = case.get("r").unwrap(); - let (neg4, kbytes) = case.get("k").unwrap(); - let (neg5, ubytes) = case.get("u").unwrap(); - assert!(!neg0 && !neg1 && !neg2 && !neg3 && !neg4 && !neg5); - - let b = $name::from_bytes(bbytes); - let e = $name::from_bytes(ebytes); - let m = $name::from_bytes(mbytes); - let r = $name::from_bytes(rbytes); - let kbig = $name::from_bytes(kbytes); - let k = usize::from(kbig); - let mu = $bname::from_bytes(ubytes); - let bar = $name::new_barrett(k, $bname::from(m), mu); - - if k == b.value.len() { - assert_eq!(r, b.modexp(&e, &bar)); - } - }); + generate_barrett_modexp_tests!(body $name, $lname, $bname); } }; + (body $name: ident, $lname: ident, $bname: ident) => { + let fname = format!("testdata/modexp/{}.tests", stringify!($name)); + run_test(fname.to_string(), 6, |case| { + let (neg0, bbytes) = case.get("b").unwrap(); + let (neg1, ebytes) = case.get("e").unwrap(); + let (neg2, mbytes) = case.get("m").unwrap(); + let (neg3, rbytes) = case.get("r").unwrap(); + let (neg4, kbytes) = case.get("k").unwrap(); + let (neg5, ubytes) = case.get("u").unwrap(); + assert!(!neg0 && !neg1 && !neg2 && !neg3 && !neg4 && !neg5); + + let b = $name::from_bytes(bbytes); + let e = $name::from_bytes(ebytes); + let m = $name::from_bytes(mbytes); + let r = $name::from_bytes(rbytes); + let kbig = $name::from_bytes(kbytes); + let k = usize::from(kbig); + let mu = $bname::from_bytes(ubytes); + let bar = $name::new_barrett(k, $bname::from(m), mu); + + if k == b.value.len() { + assert_eq!(r, b.modexp(&e, &bar)); + } + }); + }; } \ No newline at end of file diff --git a/src/unsigned/modmul.rs b/src/unsigned/modmul.rs index 2e6f188..8cdbda4 100644 --- a/src/unsigned/modmul.rs +++ b/src/unsigned/modmul.rs @@ -27,22 +27,32 @@ macro_rules! generate_modmul_tests { ($name: ident, $lname: ident) => { #[test] fn $lname() { - let fname = format!("testdata/modmul/{}.tests", stringify!($name)); - run_test(fname.to_string(), 6, |case| { - let (neg0, abytes) = case.get("a").unwrap(); - let (neg1, bbytes) = case.get("b").unwrap(); - let (neg2, mbytes) = case.get("m").unwrap(); - let (neg3, cbytes) = case.get("c").unwrap(); - assert!(!neg0 && !neg1 && !neg2 && !neg3); - - let a = $name::from_bytes(abytes); - let b = $name::from_bytes(bbytes); - let m = $name::from_bytes(mbytes); - let c = $name::from_bytes(cbytes); - assert_eq!(c, a.modmul(&b, &m)); - }); + generate_modmul_tests!(body $name, $lname); } }; + (ignore $name: ident, $lname: ident) => { + #[test] + #[ignore] + fn $lname() { + generate_modmul_tests!(body $name, $lname); + } + }; + (body $name: ident, $lname: ident) => { + let fname = format!("testdata/modmul/{}.tests", stringify!($name)); + run_test(fname.to_string(), 6, |case| { + let (neg0, abytes) = case.get("a").unwrap(); + let (neg1, bbytes) = case.get("b").unwrap(); + let (neg2, mbytes) = case.get("m").unwrap(); + let (neg3, cbytes) = case.get("c").unwrap(); + assert!(!neg0 && !neg1 && !neg2 && !neg3); + + let a = $name::from_bytes(abytes); + let b = $name::from_bytes(bbytes); + let m = $name::from_bytes(mbytes); + let c = $name::from_bytes(cbytes); + assert_eq!(c, a.modmul(&b, &m)); + }); + }; } #[cfg(test)] @@ -50,31 +60,41 @@ macro_rules! generate_barrett_modmul_tests { ($name: ident, $lname: ident, $bname: ident) => { #[test] fn $lname() { - let fname = format!("testdata/modmul/{}.tests", stringify!($name)); - run_test(fname.to_string(), 6, |case| { - let (neg0, abytes) = case.get("a").unwrap(); - let (neg1, bbytes) = case.get("b").unwrap(); - let (neg2, mbytes) = case.get("m").unwrap(); - let (neg3, cbytes) = case.get("c").unwrap(); - let (neg4, kbytes) = case.get("k").unwrap(); - let (neg5, ubytes) = case.get("u").unwrap(); - assert!(!neg0 && !neg1 && !neg2 && !neg3 && !neg4 && !neg5); - - let a = $name::from_bytes(abytes); - let b = $name::from_bytes(bbytes); - let m = $name::from_bytes(mbytes); - let c = $name::from_bytes(cbytes); - let kbig = $name::from_bytes(kbytes); - let k = usize::from(kbig); - let mu = $bname::from_bytes(ubytes); - let bar = $name::new_barrett(k, $bname::from(m), mu); - - if k == a.value.len() { - assert_eq!(c, a.modmul(&b, &bar)); - } - - - }); + generate_barrett_modmul_tests!(body $name, $lname, $bname); } }; + (ignore $name: ident, $lname: ident, $bname: ident) => { + #[test] + #[ignore] + fn $lname() { + generate_barrett_modmul_tests!(body $name, $lname, $bname); + } + }; + (body $name: ident, $lname: ident, $bname: ident) => { + let fname = format!("testdata/modmul/{}.tests", stringify!($name)); + run_test(fname.to_string(), 6, |case| { + let (neg0, abytes) = case.get("a").unwrap(); + let (neg1, bbytes) = case.get("b").unwrap(); + let (neg2, mbytes) = case.get("m").unwrap(); + let (neg3, cbytes) = case.get("c").unwrap(); + let (neg4, kbytes) = case.get("k").unwrap(); + let (neg5, ubytes) = case.get("u").unwrap(); + assert!(!neg0 && !neg1 && !neg2 && !neg3 && !neg4 && !neg5); + + let a = $name::from_bytes(abytes); + let b = $name::from_bytes(bbytes); + let m = $name::from_bytes(mbytes); + let c = $name::from_bytes(cbytes); + let kbig = $name::from_bytes(kbytes); + let k = usize::from(kbig); + let mu = $bname::from_bytes(ubytes); + let bar = $name::new_barrett(k, $bname::from(m), mu); + + if k == a.value.len() { + assert_eq!(c, a.modmul(&b, &bar)); + } + + + }); + }; } \ No newline at end of file diff --git a/src/unsigned/modsq.rs b/src/unsigned/modsq.rs index fef1431..d8cfcba 100644 --- a/src/unsigned/modsq.rs +++ b/src/unsigned/modsq.rs @@ -27,20 +27,30 @@ macro_rules! generate_modsq_tests { ($name: ident, $lname: ident) => { #[test] fn $lname() { - let fname = format!("testdata/modsq/{}.tests", stringify!($name)); - run_test(fname.to_string(), 5, |case| { - let (neg0, abytes) = case.get("a").unwrap(); - let (neg1, mbytes) = case.get("m").unwrap(); - let (neg2, cbytes) = case.get("c").unwrap(); - assert!(!neg0 && !neg1 && !neg2); - - let a = $name::from_bytes(abytes); - let m = $name::from_bytes(mbytes); - let c = $name::from_bytes(cbytes); - assert_eq!(c, a.modsq(&m)); - }); + generate_modsq_tests!(body $name, $lname); } }; + (ignore $name: ident, $lname: ident) => { + #[test] + #[ignore] + fn $lname() { + generate_modsq_tests!(body $name, $lname); + } + }; + (body $name: ident, $lname: ident) => { + let fname = format!("testdata/modsq/{}.tests", stringify!($name)); + run_test(fname.to_string(), 5, |case| { + let (neg0, abytes) = case.get("a").unwrap(); + let (neg1, mbytes) = case.get("m").unwrap(); + let (neg2, cbytes) = case.get("c").unwrap(); + assert!(!neg0 && !neg1 && !neg2); + + let a = $name::from_bytes(abytes); + let m = $name::from_bytes(mbytes); + let c = $name::from_bytes(cbytes); + assert_eq!(c, a.modsq(&m)); + }); + }; } #[cfg(test)] @@ -48,27 +58,37 @@ macro_rules! generate_barrett_modsq_tests { ($name: ident, $lname: ident, $bname: ident) => { #[test] fn $lname() { - let fname = format!("testdata/modsq/{}.tests", stringify!($name)); - run_test(fname.to_string(), 5, |case| { - let (neg0, abytes) = case.get("a").unwrap(); - let (neg1, mbytes) = case.get("m").unwrap(); - let (neg2, cbytes) = case.get("c").unwrap(); - let (neg3, kbytes) = case.get("k").unwrap(); - let (neg4, ubytes) = case.get("u").unwrap(); - assert!(!neg0 && !neg1 && !neg2 && !neg3 && !neg4); - - let a = $name::from_bytes(abytes); - let m = $name::from_bytes(mbytes); - let c = $name::from_bytes(cbytes); - let kbig = $name::from_bytes(kbytes); - let k = usize::from(kbig); - let mu = $bname::from_bytes(ubytes); - let bar = $name::new_barrett(k, $bname::from(m), mu); - - if k == a.value.len() { - assert_eq!(c, a.modsq(&bar)); - } - }); + generate_barrett_modsq_tests!(body $name, $lname, $bname); } }; + (ignore $name: ident, $lname: ident, $bname: ident) => { + #[test] + #[ignore] + fn $lname() { + generate_barrett_modsq_tests!(body $name, $lname, $bname); + } + }; + (body $name: ident, $lname: ident, $bname: ident) => { + let fname = format!("testdata/modsq/{}.tests", stringify!($name)); + run_test(fname.to_string(), 5, |case| { + let (neg0, abytes) = case.get("a").unwrap(); + let (neg1, mbytes) = case.get("m").unwrap(); + let (neg2, cbytes) = case.get("c").unwrap(); + let (neg3, kbytes) = case.get("k").unwrap(); + let (neg4, ubytes) = case.get("u").unwrap(); + assert!(!neg0 && !neg1 && !neg2 && !neg3 && !neg4); + + let a = $name::from_bytes(abytes); + let m = $name::from_bytes(mbytes); + let c = $name::from_bytes(cbytes); + let kbig = $name::from_bytes(kbytes); + let k = usize::from(kbig); + let mu = $bname::from_bytes(ubytes); + let bar = $name::new_barrett(k, $bname::from(m), mu); + + if k == a.value.len() { + assert_eq!(c, a.modsq(&bar)); + } + }); + }; } \ No newline at end of file diff --git a/src/unsigned/mul.rs b/src/unsigned/mul.rs index 1cdaa38..b4e0e3c 100644 --- a/src/unsigned/mul.rs +++ b/src/unsigned/mul.rs @@ -70,18 +70,28 @@ macro_rules! generate_mul_tests ($name: ident, $lname: ident, $dbl: ident) => { #[test] fn $lname() { - let fname = format!("testdata/mul/{}.tests", stringify!($name)); - run_test(fname.to_string(), 3, |case| { - let (neg0, abytes) = case.get("a").unwrap(); - let (neg1, bbytes) = case.get("b").unwrap(); - let (neg2, cbytes) = case.get("c").unwrap(); - assert!(!neg0 && !neg1 && !neg2); - - let a = $name::from_bytes(abytes); - let b = $name::from_bytes(bbytes); - let c = $dbl::from_bytes(cbytes); - assert_eq!(c, &a * &b); - }); + generate_mul_tests!(body $name, $lname, $dbl); } }; + (ignore $name: ident, $lname: ident, $dbl: ident) => { + #[test] + #[ignore] + fn $lname() { + generate_mul_tests!(body $name, $lname, $dbl); + } + }; + (body $name: ident, $lname: ident, $dbl: ident) => { + let fname = format!("testdata/mul/{}.tests", stringify!($name)); + run_test(fname.to_string(), 3, |case| { + let (neg0, abytes) = case.get("a").unwrap(); + let (neg1, bbytes) = case.get("b").unwrap(); + let (neg2, cbytes) = case.get("c").unwrap(); + assert!(!neg0 && !neg1 && !neg2); + + let a = $name::from_bytes(abytes); + let b = $name::from_bytes(bbytes); + let c = $dbl::from_bytes(cbytes); + assert_eq!(c, &a * &b); + }); + }; } \ No newline at end of file diff --git a/src/unsigned/shifts.rs b/src/unsigned/shifts.rs index 04c8737..012b1a5 100644 --- a/src/unsigned/shifts.rs +++ b/src/unsigned/shifts.rs @@ -94,20 +94,30 @@ macro_rules! generate_shiftl_tests { ($name: ident, $lname: ident) => { #[test] fn $lname() { - let fname = format!("testdata/shiftl/{}.tests", stringify!($name)); - run_test(fname.to_string(), 3, |case| { - let (neg0, abytes) = case.get("a").unwrap(); - let (neg1, lbytes) = case.get("l").unwrap(); - let (neg2, rbytes) = case.get("r").unwrap(); - assert!(!neg0 && !neg1 && !neg2); - - let a = $name::from_bytes(abytes); - let l = $name::from_bytes(lbytes); - let r = $name::from_bytes(rbytes); - assert_eq!(r, a << usize::from(l)); - }); + generate_shiftl_tests!(body $name, $lname); } }; + (ignore $name: ident, $lname: ident) => { + #[test] + #[ignore] + fn $lname() { + generate_shiftl_tests!(body $name, $lname); + } + }; + (body $name: ident, $lname: ident) => { + let fname = format!("testdata/shiftl/{}.tests", stringify!($name)); + run_test(fname.to_string(), 3, |case| { + let (neg0, abytes) = case.get("a").unwrap(); + let (neg1, lbytes) = case.get("l").unwrap(); + let (neg2, rbytes) = case.get("r").unwrap(); + assert!(!neg0 && !neg1 && !neg2); + + let a = $name::from_bytes(abytes); + let l = $name::from_bytes(lbytes); + let r = $name::from_bytes(rbytes); + assert_eq!(r, a << usize::from(l)); + }); + }; } #[cfg(test)] @@ -115,18 +125,28 @@ macro_rules! generate_shiftr_tests { ($name: ident, $lname: ident) => { #[test] fn $lname() { - let fname = format!("testdata/shiftr/{}.tests", stringify!($name)); - run_test(fname.to_string(), 3, |case| { - let (neg0, abytes) = case.get("a").unwrap(); - let (neg1, lbytes) = case.get("l").unwrap(); - let (neg2, rbytes) = case.get("r").unwrap(); - assert!(!neg0 && !neg1 && !neg2); - - let a = $name::from_bytes(abytes); - let l = $name::from_bytes(lbytes); - let r = $name::from_bytes(rbytes); - assert_eq!(r, a >> usize::from(l)); - }); + generate_shiftr_tests!(body $name, $lname); } }; + (ignore $name: ident, $lname: ident) => { + #[test] + #[ignore] + fn $lname() { + generate_shiftr_tests!(body $name, $lname); + } + }; + (body $name: ident, $lname: ident) => { + let fname = format!("testdata/shiftr/{}.tests", stringify!($name)); + run_test(fname.to_string(), 3, |case| { + let (neg0, abytes) = case.get("a").unwrap(); + let (neg1, lbytes) = case.get("l").unwrap(); + let (neg2, rbytes) = case.get("r").unwrap(); + assert!(!neg0 && !neg1 && !neg2); + + let a = $name::from_bytes(abytes); + let l = $name::from_bytes(lbytes); + let r = $name::from_bytes(rbytes); + assert_eq!(r, a >> usize::from(l)); + }); + }; } \ No newline at end of file diff --git a/src/unsigned/square.rs b/src/unsigned/square.rs index 3ec6a9e..63cca56 100644 --- a/src/unsigned/square.rs +++ b/src/unsigned/square.rs @@ -57,16 +57,26 @@ macro_rules! generate_square_tests { ($name: ident, $lname: ident, $dbl: ident) => { #[test] fn $lname() { - let fname = format!("testdata/square/{}.tests", stringify!($name)); - run_test(fname.to_string(), 2, |case| { - let (neg0, abytes) = case.get("a").unwrap(); - let (neg1, rbytes) = case.get("r").unwrap(); - assert!(!neg0 && !neg1); - - let a = $name::from_bytes(abytes); - let r = $dbl::from_bytes(rbytes); - assert_eq!(r, a.square()); - }); + generate_square_tests!(body $name, $lname, $dbl); } }; + (ignore $name: ident, $lname: ident, $dbl: ident) => { + #[test] + #[ignore] + fn $lname() { + generate_square_tests!(body $name, $lname, $dbl); + } + }; + (body $name: ident, $lname: ident, $dbl: ident) => { + let fname = format!("testdata/square/{}.tests", stringify!($name)); + run_test(fname.to_string(), 2, |case| { + let (neg0, abytes) = case.get("a").unwrap(); + let (neg1, rbytes) = case.get("r").unwrap(); + assert!(!neg0 && !neg1); + + let a = $name::from_bytes(abytes); + let r = $dbl::from_bytes(rbytes); + assert_eq!(r, a.square()); + }); + }; } \ No newline at end of file diff --git a/src/unsigned/sub.rs b/src/unsigned/sub.rs index 8eb7164..e63de39 100644 --- a/src/unsigned/sub.rs +++ b/src/unsigned/sub.rs @@ -78,20 +78,30 @@ macro_rules! generate_sub_tests { ($name: ident, $lname: ident) => { #[test] fn $lname() { - let fname = format!("testdata/sub/{}.tests", stringify!($name)); - run_test(fname.to_string(), 3, |case| { - let (neg0, abytes) = case.get("a").unwrap(); - let (neg1, bbytes) = case.get("b").unwrap(); - let (neg2, cbytes) = case.get("c").unwrap(); - assert!(!neg0 && !neg1 && !neg2); - - let mut a = $name::from_bytes(abytes); - let b = $name::from_bytes(bbytes); - let c = $name::from_bytes(cbytes); - assert_eq!(c, &a - &b); - a -= b; - assert_eq!(c, a); - }); + generate_sub_tests!(body $name, $lname); } }; + (ignore $name: ident, $lname: ident) => { + #[test] + #[ignore] + fn $lname() { + generate_sub_tests!(body $name, $lname); + } + }; + (body $name: ident, $lname: ident) => { + let fname = format!("testdata/sub/{}.tests", stringify!($name)); + run_test(fname.to_string(), 3, |case| { + let (neg0, abytes) = case.get("a").unwrap(); + let (neg1, bbytes) = case.get("b").unwrap(); + let (neg2, cbytes) = case.get("c").unwrap(); + assert!(!neg0 && !neg1 && !neg2); + + let mut a = $name::from_bytes(abytes); + let b = $name::from_bytes(bbytes); + let c = $name::from_bytes(cbytes); + assert_eq!(c, &a - &b); + a -= b; + assert_eq!(c, a); + }); + }; } \ No newline at end of file