acw/cryptonum
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add the ability to ignore tests, so that day-to-day testing only takes a little while.

Browse Source
This commit is contained in:
Adam Wick
2018-10-08 20:34:36 -07:00
parent a251b7a294
commit d43f0bcd42
14 changed files with 618 additions and 446 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
generate.hs
View File

@@ -104,9 +104,9 @@ numberOfTests :: Int
numberOfTests = 1000 numberOfTests = 1000
generateTestBlock :: Handle -> generateTestBlock :: Handle ->
String -> Operation -> Bool -> [Int -> Int] -> String -> Operation -> Bool -> Int -> [Int -> Int] ->
IO () IO ()
generateTestBlock hndl name level useRT addOns = generateTestBlock hndl name level useRT ignoreAt addOns =
do hPutStrLn hndl (" mod " ++ name ++ " {") do hPutStrLn hndl (" mod " ++ name ++ " {")
when useRT $ when useRT $
do hPutStrLn hndl (" use super::super::*;") do hPutStrLn hndl (" use super::super::*;")
@@ -115,7 +115,9 @@ generateTestBlock hndl name level useRT addOns =
forM_ requirements $ \ (Req size kind) -> forM_ requirements $ \ (Req size kind) ->
when (kind == level) $ when (kind == level) $
hPutStrLn hndl (" generate_" ++ name ++ hPutStrLn hndl (" generate_" ++ name ++
"_tests!(U" ++ show size ++ ", " ++ "_tests!(" ++
(if size >= ignoreAt then "ignore " else "") ++
"U" ++ show size ++ ", " ++
"u" ++ show size ++ "u" ++ show size ++
concatMap (\ f -> ", U" ++ show (f size)) addOns ++ concatMap (\ f -> ", U" ++ show (f size)) addOns ++
");") ");")
@@ -142,25 +144,25 @@ generateInvocs =
hPutStrLn hndl "" hPutStrLn hndl ""
hPutStrLn hndl "\n#[cfg(test)]" hPutStrLn hndl "\n#[cfg(test)]"
hPutStrLn hndl "mod tests {" hPutStrLn hndl "mod tests {"
generateTestBlock hndl "base" BaseOps True [] generateTestBlock hndl "base" BaseOps True 16384 []
generateTestBlock hndl "conversion" BaseOps False [] generateTestBlock hndl "conversion" BaseOps False 90000 []
generateTestBlock hndl "codec" BaseOps False [] generateTestBlock hndl "codec" BaseOps False 90000 []
generateTestBlock hndl "cmp" BaseOps True [] generateTestBlock hndl "cmp" BaseOps True 16384 []
generateTestBlock hndl "sub" Sub True [] generateTestBlock hndl "sub" Sub True 9000 []
generateTestBlock hndl "shiftl" Shifts True [] generateTestBlock hndl "shiftl" Shifts True 9000 []
generateTestBlock hndl "shiftr" Shifts True [] generateTestBlock hndl "shiftr" Shifts True 9000 []
generateTestBlock hndl "add" Add True [(+ 64)] generateTestBlock hndl "add" Add True 9000 [(+ 64)]
generateTestBlock hndl "mul" Mul True [(* 2)] generateTestBlock hndl "mul" Mul True 9000 [(* 2)]
generateTestBlock hndl "div" Div True [] generateTestBlock hndl "div" Div True 2049 []
generateTestBlock hndl "barrett_gen" Barretts True [(+ 64)] generateTestBlock hndl "barrett_gen" Barretts True 2000 [(+ 64)]
generateTestBlock hndl "barrett_red" Barretts True [(+ 64), (* 2)] generateTestBlock hndl "barrett_red" Barretts True 4000 [(+ 64), (* 2)]
generateTestBlock hndl "modsq" ModSq True [] generateTestBlock hndl "modsq" ModSq True 4000 []
generateTestBlock hndl "modmul" ModMul True [] generateTestBlock hndl "modmul" ModMul True 4000 []
generateTestBlock hndl "modexp" ModExp True [] generateTestBlock hndl "modexp" ModExp True 512 []
generateTestBlock hndl "square" Square True [(* 2)] generateTestBlock hndl "square" Square True 4000 [(* 2)]
generateTestBlock hndl "barrett_modsq" Barretts True [(+ 64)] generateTestBlock hndl "barrett_modsq" Barretts True 4000 [(+ 64)]
generateTestBlock hndl "barrett_modmul" Barretts True [(+ 64)] generateTestBlock hndl "barrett_modmul" Barretts True 4000 [(+ 64)]
generateTestBlock hndl "barrett_modexp" Barretts True [(+ 64)] generateTestBlock hndl "barrett_modexp" Barretts True 1024 [(+ 64)]
hPutStrLn hndl "}" hPutStrLn hndl "}"
log :: String -> IO () log :: String -> IO ()

46
src/unsigned/add.rs
View File

@@ -103,24 +103,34 @@ macro_rules! generate_add_tests {
($name: ident, $lname: ident, $plus1: ident) => { ($name: ident, $lname: ident, $plus1: ident) => {
#[test] #[test]
fn $lname() { fn $lname() {
let fname = format!("testdata/add/{}.tests", stringify!($name)); generate_add_tests!(body $name, $lname, $plus1);
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);
}
});
} }
}; };
(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);
}
});
};
} }

96
src/unsigned/barrett.rs
View File

@@ -75,27 +75,37 @@ macro_rules! generate_barrett_gen_tests {
($name: ident, $lname: ident, $bname: ident) => { ($name: ident, $lname: ident, $bname: ident) => {
#[test] #[test]
fn $lname() { fn $lname() {
let fname = format!("testdata/barrett_gen/{}.tests", stringify!($name)); generate_barrett_gen_tests!(body $name, $lname, $bname);
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);
});
} }
}; };
(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)] #[cfg(test)]
@@ -103,25 +113,35 @@ macro_rules! generate_barrett_red_tests {
($name: ident, $lname: ident, $bname: ident, $dbl: ident) => { ($name: ident, $lname: ident, $bname: ident, $dbl: ident) => {
#[test] #[test]
fn $lname() { fn $lname() {
let fname = format!("testdata/barrett_reduce/{}.tests", stringify!($name)); generate_barrett_red_tests!(body $name, $lname, $bname, $dbl);
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));
});
} }
}; };
(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));
});
};
} }

52
src/unsigned/base.rs
View File

@@ -69,27 +69,37 @@ macro_rules! generate_base_tests
($name: ident, $lname: ident) => { ($name: ident, $lname: ident) => {
#[test] #[test]
fn $lname() { fn $lname() {
let fname = format!("testdata/base/{}.tests", stringify!($name)); generate_base_tests!(body $name, $lname);
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);
});
} }
};
(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);
});
} }
} }

52
src/unsigned/cmp.rs
View File

@@ -46,27 +46,37 @@ macro_rules! generate_cmp_tests {
($name: ident, $lname: ident) => { ($name: ident, $lname: ident) => {
#[test] #[test]
fn $lname() { fn $lname() {
let fname = format!("testdata/cmp/{}.tests", stringify!($name)); generate_cmp_tests!(body $name, $lname);
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);
});
} }
}; };
(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);
});
};
} }

42
src/unsigned/div.rs
View File

@@ -226,22 +226,32 @@ macro_rules! generate_div_tests {
($name: ident, $lname: ident) => { ($name: ident, $lname: ident) => {
#[test] #[test]
fn $lname() { fn $lname() {
let fname = format!("testdata/div/{}.tests", stringify!($name)); generate_div_tests!(body $name, $lname);
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);
});
} }
}; };
(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);
});
};
} }

282
src/unsigned/invoc.rs
View File

@@ -470,22 +470,22 @@ mod tests {
generate_base_tests!(U15360, u15360); generate_base_tests!(U15360, u15360);
generate_base_tests!(U15424, u15424); generate_base_tests!(U15424, u15424);
generate_base_tests!(U15488, u15488); generate_base_tests!(U15488, u15488);
generate_base_tests!(U16384, u16384); generate_base_tests!(ignore U16384, u16384);
generate_base_tests!(U16448, u16448); generate_base_tests!(ignore U16448, u16448);
generate_base_tests!(U16512, u16512); generate_base_tests!(ignore U16512, u16512);
generate_base_tests!(U16576, u16576); generate_base_tests!(ignore U16576, u16576);
generate_base_tests!(U30720, u30720); generate_base_tests!(ignore U30720, u30720);
generate_base_tests!(U30784, u30784); generate_base_tests!(ignore U30784, u30784);
generate_base_tests!(U30848, u30848); generate_base_tests!(ignore U30848, u30848);
generate_base_tests!(U30912, u30912); generate_base_tests!(ignore U30912, u30912);
generate_base_tests!(U32768, u32768); generate_base_tests!(ignore U32768, u32768);
generate_base_tests!(U32832, u32832); generate_base_tests!(ignore U32832, u32832);
generate_base_tests!(U32896, u32896); generate_base_tests!(ignore U32896, u32896);
generate_base_tests!(U32960, u32960); generate_base_tests!(ignore U32960, u32960);
generate_base_tests!(U61440, u61440); generate_base_tests!(ignore U61440, u61440);
generate_base_tests!(U61504, u61504); generate_base_tests!(ignore U61504, u61504);
generate_base_tests!(U61568, u61568); generate_base_tests!(ignore U61568, u61568);
generate_base_tests!(U61632, u61632); generate_base_tests!(ignore U61632, u61632);
} }
mod conversion { mod conversion {
generate_conversion_tests!(U192, u192); generate_conversion_tests!(U192, u192);
@@ -680,22 +680,22 @@ mod tests {
generate_cmp_tests!(U15360, u15360); generate_cmp_tests!(U15360, u15360);
generate_cmp_tests!(U15424, u15424); generate_cmp_tests!(U15424, u15424);
generate_cmp_tests!(U15488, u15488); generate_cmp_tests!(U15488, u15488);
generate_cmp_tests!(U16384, u16384); generate_cmp_tests!(ignore U16384, u16384);
generate_cmp_tests!(U16448, u16448); generate_cmp_tests!(ignore U16448, u16448);
generate_cmp_tests!(U16512, u16512); generate_cmp_tests!(ignore U16512, u16512);
generate_cmp_tests!(U16576, u16576); generate_cmp_tests!(ignore U16576, u16576);
generate_cmp_tests!(U30720, u30720); generate_cmp_tests!(ignore U30720, u30720);
generate_cmp_tests!(U30784, u30784); generate_cmp_tests!(ignore U30784, u30784);
generate_cmp_tests!(U30848, u30848); generate_cmp_tests!(ignore U30848, u30848);
generate_cmp_tests!(U30912, u30912); generate_cmp_tests!(ignore U30912, u30912);
generate_cmp_tests!(U32768, u32768); generate_cmp_tests!(ignore U32768, u32768);
generate_cmp_tests!(U32832, u32832); generate_cmp_tests!(ignore U32832, u32832);
generate_cmp_tests!(U32896, u32896); generate_cmp_tests!(ignore U32896, u32896);
generate_cmp_tests!(U32960, u32960); generate_cmp_tests!(ignore U32960, u32960);
generate_cmp_tests!(U61440, u61440); generate_cmp_tests!(ignore U61440, u61440);
generate_cmp_tests!(U61504, u61504); generate_cmp_tests!(ignore U61504, u61504);
generate_cmp_tests!(U61568, u61568); generate_cmp_tests!(ignore U61568, u61568);
generate_cmp_tests!(U61632, u61632); generate_cmp_tests!(ignore U61632, u61632);
} }
mod sub { mod sub {
use super::super::*; use super::super::*;
@@ -724,19 +724,19 @@ mod tests {
generate_sub_tests!(U8192, u8192); generate_sub_tests!(U8192, u8192);
generate_sub_tests!(U8256, u8256); generate_sub_tests!(U8256, u8256);
generate_sub_tests!(U8320, u8320); generate_sub_tests!(U8320, u8320);
generate_sub_tests!(U12288, u12288); generate_sub_tests!(ignore U12288, u12288);
generate_sub_tests!(U12416, u12416); generate_sub_tests!(ignore U12416, u12416);
generate_sub_tests!(U15424, u15424); generate_sub_tests!(ignore U15424, u15424);
generate_sub_tests!(U16384, u16384); generate_sub_tests!(ignore U16384, u16384);
generate_sub_tests!(U16448, u16448); generate_sub_tests!(ignore U16448, u16448);
generate_sub_tests!(U16512, u16512); generate_sub_tests!(ignore U16512, u16512);
generate_sub_tests!(U30720, u30720); generate_sub_tests!(ignore U30720, u30720);
generate_sub_tests!(U30784, u30784); generate_sub_tests!(ignore U30784, u30784);
generate_sub_tests!(U30848, u30848); generate_sub_tests!(ignore U30848, u30848);
generate_sub_tests!(U32768, u32768); generate_sub_tests!(ignore U32768, u32768);
generate_sub_tests!(U32896, u32896); generate_sub_tests!(ignore U32896, u32896);
generate_sub_tests!(U61440, u61440); generate_sub_tests!(ignore U61440, u61440);
generate_sub_tests!(U61568, u61568); generate_sub_tests!(ignore U61568, u61568);
} }
mod shiftl { mod shiftl {
use super::super::*; use super::super::*;
@@ -767,15 +767,15 @@ mod tests {
generate_shiftl_tests!(U8192, u8192); generate_shiftl_tests!(U8192, u8192);
generate_shiftl_tests!(U8256, u8256); generate_shiftl_tests!(U8256, u8256);
generate_shiftl_tests!(U8320, u8320); generate_shiftl_tests!(U8320, u8320);
generate_shiftl_tests!(U15360, u15360); generate_shiftl_tests!(ignore U15360, u15360);
generate_shiftl_tests!(U15424, u15424); generate_shiftl_tests!(ignore U15424, u15424);
generate_shiftl_tests!(U15488, u15488); generate_shiftl_tests!(ignore U15488, u15488);
generate_shiftl_tests!(U16384, u16384); generate_shiftl_tests!(ignore U16384, u16384);
generate_shiftl_tests!(U16448, u16448); generate_shiftl_tests!(ignore U16448, u16448);
generate_shiftl_tests!(U16512, u16512); generate_shiftl_tests!(ignore U16512, u16512);
generate_shiftl_tests!(U30720, u30720); generate_shiftl_tests!(ignore U30720, u30720);
generate_shiftl_tests!(U30784, u30784); generate_shiftl_tests!(ignore U30784, u30784);
generate_shiftl_tests!(U30848, u30848); generate_shiftl_tests!(ignore U30848, u30848);
} }
mod shiftr { mod shiftr {
use super::super::*; use super::super::*;
@@ -806,15 +806,15 @@ mod tests {
generate_shiftr_tests!(U8192, u8192); generate_shiftr_tests!(U8192, u8192);
generate_shiftr_tests!(U8256, u8256); generate_shiftr_tests!(U8256, u8256);
generate_shiftr_tests!(U8320, u8320); generate_shiftr_tests!(U8320, u8320);
generate_shiftr_tests!(U15360, u15360); generate_shiftr_tests!(ignore U15360, u15360);
generate_shiftr_tests!(U15424, u15424); generate_shiftr_tests!(ignore U15424, u15424);
generate_shiftr_tests!(U15488, u15488); generate_shiftr_tests!(ignore U15488, u15488);
generate_shiftr_tests!(U16384, u16384); generate_shiftr_tests!(ignore U16384, u16384);
generate_shiftr_tests!(U16448, u16448); generate_shiftr_tests!(ignore U16448, u16448);
generate_shiftr_tests!(U16512, u16512); generate_shiftr_tests!(ignore U16512, u16512);
generate_shiftr_tests!(U30720, u30720); generate_shiftr_tests!(ignore U30720, u30720);
generate_shiftr_tests!(U30784, u30784); generate_shiftr_tests!(ignore U30784, u30784);
generate_shiftr_tests!(U30848, u30848); generate_shiftr_tests!(ignore U30848, u30848);
} }
mod add { mod add {
use super::super::*; use super::super::*;
@@ -843,19 +843,19 @@ mod tests {
generate_add_tests!(U8192, u8192, U8256); generate_add_tests!(U8192, u8192, U8256);
generate_add_tests!(U8256, u8256, U8320); generate_add_tests!(U8256, u8256, U8320);
generate_add_tests!(U8320, u8320, U8384); generate_add_tests!(U8320, u8320, U8384);
generate_add_tests!(U12288, u12288, U12352); generate_add_tests!(ignore U12288, u12288, U12352);
generate_add_tests!(U12416, u12416, U12480); generate_add_tests!(ignore U12416, u12416, U12480);
generate_add_tests!(U15424, u15424, U15488); generate_add_tests!(ignore U15424, u15424, U15488);
generate_add_tests!(U16384, u16384, U16448); generate_add_tests!(ignore U16384, u16384, U16448);
generate_add_tests!(U16448, u16448, U16512); generate_add_tests!(ignore U16448, u16448, U16512);
generate_add_tests!(U16512, u16512, U16576); generate_add_tests!(ignore U16512, u16512, U16576);
generate_add_tests!(U30720, u30720, U30784); generate_add_tests!(ignore U30720, u30720, U30784);
generate_add_tests!(U30784, u30784, U30848); generate_add_tests!(ignore U30784, u30784, U30848);
generate_add_tests!(U30848, u30848, U30912); generate_add_tests!(ignore U30848, u30848, U30912);
generate_add_tests!(U32768, u32768, U32832); generate_add_tests!(ignore U32768, u32768, U32832);
generate_add_tests!(U32896, u32896, U32960); generate_add_tests!(ignore U32896, u32896, U32960);
generate_add_tests!(U61440, u61440, U61504); generate_add_tests!(ignore U61440, u61440, U61504);
generate_add_tests!(U61568, u61568, U61632); generate_add_tests!(ignore U61568, u61568, U61632);
} }
mod mul { mod mul {
use super::super::*; use super::super::*;
@@ -887,12 +887,12 @@ mod tests {
generate_mul_tests!(U7744, u7744, U15488); generate_mul_tests!(U7744, u7744, U15488);
generate_mul_tests!(U8192, u8192, U16384); generate_mul_tests!(U8192, u8192, U16384);
generate_mul_tests!(U8256, u8256, U16512); generate_mul_tests!(U8256, u8256, U16512);
generate_mul_tests!(U15360, u15360, U30720); generate_mul_tests!(ignore U15360, u15360, U30720);
generate_mul_tests!(U15424, u15424, U30848); generate_mul_tests!(ignore U15424, u15424, U30848);
generate_mul_tests!(U16384, u16384, U32768); generate_mul_tests!(ignore U16384, u16384, U32768);
generate_mul_tests!(U16448, u16448, U32896); generate_mul_tests!(ignore U16448, u16448, U32896);
generate_mul_tests!(U30720, u30720, U61440); generate_mul_tests!(ignore U30720, u30720, U61440);
generate_mul_tests!(U30784, u30784, U61568); generate_mul_tests!(ignore U30784, u30784, U61568);
} }
mod div { mod div {
use super::super::*; use super::super::*;
@@ -909,19 +909,19 @@ mod tests {
generate_div_tests!(U1152, u1152); generate_div_tests!(U1152, u1152);
generate_div_tests!(U1216, u1216); generate_div_tests!(U1216, u1216);
generate_div_tests!(U2048, u2048); generate_div_tests!(U2048, u2048);
generate_div_tests!(U2112, u2112); generate_div_tests!(ignore U2112, u2112);
generate_div_tests!(U4096, u4096); generate_div_tests!(ignore U4096, u4096);
generate_div_tests!(U4160, u4160); generate_div_tests!(ignore U4160, u4160);
generate_div_tests!(U6144, u6144); generate_div_tests!(ignore U6144, u6144);
generate_div_tests!(U6208, u6208); generate_div_tests!(ignore U6208, u6208);
generate_div_tests!(U8192, u8192); generate_div_tests!(ignore U8192, u8192);
generate_div_tests!(U8256, u8256); generate_div_tests!(ignore U8256, u8256);
generate_div_tests!(U15360, u15360); generate_div_tests!(ignore U15360, u15360);
generate_div_tests!(U15424, u15424); generate_div_tests!(ignore U15424, u15424);
generate_div_tests!(U16384, u16384); generate_div_tests!(ignore U16384, u16384);
generate_div_tests!(U16448, u16448); generate_div_tests!(ignore U16448, u16448);
generate_div_tests!(U30720, u30720); generate_div_tests!(ignore U30720, u30720);
generate_div_tests!(U30784, u30784); generate_div_tests!(ignore U30784, u30784);
} }
mod barrett_gen { mod barrett_gen {
use super::super::*; use super::super::*;
@@ -933,12 +933,12 @@ mod tests {
generate_barrett_gen_tests!(U512, u512, U576); generate_barrett_gen_tests!(U512, u512, U576);
generate_barrett_gen_tests!(U576, u576, U640); generate_barrett_gen_tests!(U576, u576, U640);
generate_barrett_gen_tests!(U1024, u1024, U1088); generate_barrett_gen_tests!(U1024, u1024, U1088);
generate_barrett_gen_tests!(U2048, u2048, U2112); generate_barrett_gen_tests!(ignore U2048, u2048, U2112);
generate_barrett_gen_tests!(U3072, u3072, U3136); generate_barrett_gen_tests!(ignore U3072, u3072, U3136);
generate_barrett_gen_tests!(U4096, u4096, U4160); generate_barrett_gen_tests!(ignore U4096, u4096, U4160);
generate_barrett_gen_tests!(U7680, u7680, U7744); generate_barrett_gen_tests!(ignore U7680, u7680, U7744);
generate_barrett_gen_tests!(U8192, u8192, U8256); generate_barrett_gen_tests!(ignore U8192, u8192, U8256);
generate_barrett_gen_tests!(U15360, u15360, U15424); generate_barrett_gen_tests!(ignore U15360, u15360, U15424);
} }
mod barrett_red { mod barrett_red {
use super::super::*; use super::super::*;
@@ -952,10 +952,10 @@ mod tests {
generate_barrett_red_tests!(U1024, u1024, U1088, U2048); generate_barrett_red_tests!(U1024, u1024, U1088, U2048);
generate_barrett_red_tests!(U2048, u2048, U2112, U4096); generate_barrett_red_tests!(U2048, u2048, U2112, U4096);
generate_barrett_red_tests!(U3072, u3072, U3136, U6144); generate_barrett_red_tests!(U3072, u3072, U3136, U6144);
generate_barrett_red_tests!(U4096, u4096, U4160, U8192); generate_barrett_red_tests!(ignore U4096, u4096, U4160, U8192);
generate_barrett_red_tests!(U7680, u7680, U7744, U15360); generate_barrett_red_tests!(ignore U7680, u7680, U7744, U15360);
generate_barrett_red_tests!(U8192, u8192, U8256, U16384); generate_barrett_red_tests!(ignore U8192, u8192, U8256, U16384);
generate_barrett_red_tests!(U15360, u15360, U15424, U30720); generate_barrett_red_tests!(ignore U15360, u15360, U15424, U30720);
} }
mod modsq { mod modsq {
use super::super::*; use super::super::*;
@@ -969,10 +969,10 @@ mod tests {
generate_modsq_tests!(U1024, u1024); generate_modsq_tests!(U1024, u1024);
generate_modsq_tests!(U2048, u2048); generate_modsq_tests!(U2048, u2048);
generate_modsq_tests!(U3072, u3072); generate_modsq_tests!(U3072, u3072);
generate_modsq_tests!(U4096, u4096); generate_modsq_tests!(ignore U4096, u4096);
generate_modsq_tests!(U7680, u7680); generate_modsq_tests!(ignore U7680, u7680);
generate_modsq_tests!(U8192, u8192); generate_modsq_tests!(ignore U8192, u8192);
generate_modsq_tests!(U15360, u15360); generate_modsq_tests!(ignore U15360, u15360);
} }
mod modmul { mod modmul {
use super::super::*; use super::super::*;
@@ -986,10 +986,10 @@ mod tests {
generate_modmul_tests!(U1024, u1024); generate_modmul_tests!(U1024, u1024);
generate_modmul_tests!(U2048, u2048); generate_modmul_tests!(U2048, u2048);
generate_modmul_tests!(U3072, u3072); generate_modmul_tests!(U3072, u3072);
generate_modmul_tests!(U4096, u4096); generate_modmul_tests!(ignore U4096, u4096);
generate_modmul_tests!(U7680, u7680); generate_modmul_tests!(ignore U7680, u7680);
generate_modmul_tests!(U8192, u8192); generate_modmul_tests!(ignore U8192, u8192);
generate_modmul_tests!(U15360, u15360); generate_modmul_tests!(ignore U15360, u15360);
} }
mod modexp { mod modexp {
use super::super::*; use super::super::*;
@@ -998,15 +998,15 @@ mod tests {
generate_modexp_tests!(U192, u192); generate_modexp_tests!(U192, u192);
generate_modexp_tests!(U256, u256); generate_modexp_tests!(U256, u256);
generate_modexp_tests!(U384, u384); generate_modexp_tests!(U384, u384);
generate_modexp_tests!(U512, u512); generate_modexp_tests!(ignore U512, u512);
generate_modexp_tests!(U576, u576); generate_modexp_tests!(ignore U576, u576);
generate_modexp_tests!(U1024, u1024); generate_modexp_tests!(ignore U1024, u1024);
generate_modexp_tests!(U2048, u2048); generate_modexp_tests!(ignore U2048, u2048);
generate_modexp_tests!(U3072, u3072); generate_modexp_tests!(ignore U3072, u3072);
generate_modexp_tests!(U4096, u4096); generate_modexp_tests!(ignore U4096, u4096);
generate_modexp_tests!(U7680, u7680); generate_modexp_tests!(ignore U7680, u7680);
generate_modexp_tests!(U8192, u8192); generate_modexp_tests!(ignore U8192, u8192);
generate_modexp_tests!(U15360, u15360); generate_modexp_tests!(ignore U15360, u15360);
} }
mod square { mod square {
use super::super::*; use super::super::*;
@@ -1020,10 +1020,10 @@ mod tests {
generate_square_tests!(U1024, u1024, U2048); generate_square_tests!(U1024, u1024, U2048);
generate_square_tests!(U2048, u2048, U4096); generate_square_tests!(U2048, u2048, U4096);
generate_square_tests!(U3072, u3072, U6144); generate_square_tests!(U3072, u3072, U6144);
generate_square_tests!(U4096, u4096, U8192); generate_square_tests!(ignore U4096, u4096, U8192);
generate_square_tests!(U7680, u7680, U15360); generate_square_tests!(ignore U7680, u7680, U15360);
generate_square_tests!(U8192, u8192, U16384); generate_square_tests!(ignore U8192, u8192, U16384);
generate_square_tests!(U15360, u15360, U30720); generate_square_tests!(ignore U15360, u15360, U30720);
} }
mod barrett_modsq { mod barrett_modsq {
use super::super::*; use super::super::*;
@@ -1037,10 +1037,10 @@ mod tests {
generate_barrett_modsq_tests!(U1024, u1024, U1088); generate_barrett_modsq_tests!(U1024, u1024, U1088);
generate_barrett_modsq_tests!(U2048, u2048, U2112); generate_barrett_modsq_tests!(U2048, u2048, U2112);
generate_barrett_modsq_tests!(U3072, u3072, U3136); generate_barrett_modsq_tests!(U3072, u3072, U3136);
generate_barrett_modsq_tests!(U4096, u4096, U4160); generate_barrett_modsq_tests!(ignore U4096, u4096, U4160);
generate_barrett_modsq_tests!(U7680, u7680, U7744); generate_barrett_modsq_tests!(ignore U7680, u7680, U7744);
generate_barrett_modsq_tests!(U8192, u8192, U8256); generate_barrett_modsq_tests!(ignore U8192, u8192, U8256);
generate_barrett_modsq_tests!(U15360, u15360, U15424); generate_barrett_modsq_tests!(ignore U15360, u15360, U15424);
} }
mod barrett_modmul { mod barrett_modmul {
use super::super::*; use super::super::*;
@@ -1054,10 +1054,10 @@ mod tests {
generate_barrett_modmul_tests!(U1024, u1024, U1088); generate_barrett_modmul_tests!(U1024, u1024, U1088);
generate_barrett_modmul_tests!(U2048, u2048, U2112); generate_barrett_modmul_tests!(U2048, u2048, U2112);
generate_barrett_modmul_tests!(U3072, u3072, U3136); generate_barrett_modmul_tests!(U3072, u3072, U3136);
generate_barrett_modmul_tests!(U4096, u4096, U4160); generate_barrett_modmul_tests!(ignore U4096, u4096, U4160);
generate_barrett_modmul_tests!(U7680, u7680, U7744); generate_barrett_modmul_tests!(ignore U7680, u7680, U7744);
generate_barrett_modmul_tests!(U8192, u8192, U8256); generate_barrett_modmul_tests!(ignore U8192, u8192, U8256);
generate_barrett_modmul_tests!(U15360, u15360, U15424); generate_barrett_modmul_tests!(ignore U15360, u15360, U15424);
} }
mod barrett_modexp { mod barrett_modexp {
use super::super::*; use super::super::*;
@@ -1068,12 +1068,12 @@ mod tests {
generate_barrett_modexp_tests!(U384, u384, U448); generate_barrett_modexp_tests!(U384, u384, U448);
generate_barrett_modexp_tests!(U512, u512, U576); generate_barrett_modexp_tests!(U512, u512, U576);
generate_barrett_modexp_tests!(U576, u576, U640); generate_barrett_modexp_tests!(U576, u576, U640);
generate_barrett_modexp_tests!(U1024, u1024, U1088); generate_barrett_modexp_tests!(ignore U1024, u1024, U1088);
generate_barrett_modexp_tests!(U2048, u2048, U2112); generate_barrett_modexp_tests!(ignore U2048, u2048, U2112);
generate_barrett_modexp_tests!(U3072, u3072, U3136); generate_barrett_modexp_tests!(ignore U3072, u3072, U3136);
generate_barrett_modexp_tests!(U4096, u4096, U4160); generate_barrett_modexp_tests!(ignore U4096, u4096, U4160);
generate_barrett_modexp_tests!(U7680, u7680, U7744); generate_barrett_modexp_tests!(ignore U7680, u7680, U7744);
generate_barrett_modexp_tests!(U8192, u8192, U8256); generate_barrett_modexp_tests!(ignore U8192, u8192, U8256);
generate_barrett_modexp_tests!(U15360, u15360, U15424); generate_barrett_modexp_tests!(ignore U15360, u15360, U15424);
} }
} }

94
src/unsigned/modexp.rs
View File

@@ -41,52 +41,72 @@ macro_rules! generate_modexp_tests {
($name: ident, $lname: ident) => { ($name: ident, $lname: ident) => {
#[test] #[test]
fn $lname() { fn $lname() {
let fname = format!("testdata/modexp/{}.tests", stringify!($name)); generate_modexp_tests!(body $name, $lname);
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));
});
} }
}; };
(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)] #[cfg(test)]
macro_rules! generate_barrett_modexp_tests { 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) => { ($name: ident, $lname: ident, $bname: ident) => {
#[test] #[test]
fn $lname() { fn $lname() {
let fname = format!("testdata/modexp/{}.tests", stringify!($name)); generate_barrett_modexp_tests!(body $name, $lname, $bname);
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));
}
});
} }
}; };
(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));
}
});
};
} }

98
src/unsigned/modmul.rs
View File

@@ -27,22 +27,32 @@ macro_rules! generate_modmul_tests {
($name: ident, $lname: ident) => { ($name: ident, $lname: ident) => {
#[test] #[test]
fn $lname() { fn $lname() {
let fname = format!("testdata/modmul/{}.tests", stringify!($name)); generate_modmul_tests!(body $name, $lname);
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));
});
} }
}; };
(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)] #[cfg(test)]
@@ -50,31 +60,41 @@ macro_rules! generate_barrett_modmul_tests {
($name: ident, $lname: ident, $bname: ident) => { ($name: ident, $lname: ident, $bname: ident) => {
#[test] #[test]
fn $lname() { fn $lname() {
let fname = format!("testdata/modmul/{}.tests", stringify!($name)); generate_barrett_modmul_tests!(body $name, $lname, $bname);
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));
}
});
} }
}; };
(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));
}
});
};
} }

86
src/unsigned/modsq.rs
View File

@@ -27,20 +27,30 @@ macro_rules! generate_modsq_tests {
($name: ident, $lname: ident) => { ($name: ident, $lname: ident) => {
#[test] #[test]
fn $lname() { fn $lname() {
let fname = format!("testdata/modsq/{}.tests", stringify!($name)); generate_modsq_tests!(body $name, $lname);
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));
});
} }
}; };
(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)] #[cfg(test)]
@@ -48,27 +58,37 @@ macro_rules! generate_barrett_modsq_tests {
($name: ident, $lname: ident, $bname: ident) => { ($name: ident, $lname: ident, $bname: ident) => {
#[test] #[test]
fn $lname() { fn $lname() {
let fname = format!("testdata/modsq/{}.tests", stringify!($name)); generate_barrett_modsq_tests!(body $name, $lname, $bname);
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));
}
});
} }
}; };
(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));
}
});
};
} }

34
src/unsigned/mul.rs
View File

@@ -70,18 +70,28 @@ macro_rules! generate_mul_tests
($name: ident, $lname: ident, $dbl: ident) => { ($name: ident, $lname: ident, $dbl: ident) => {
#[test] #[test]
fn $lname() { fn $lname() {
let fname = format!("testdata/mul/{}.tests", stringify!($name)); generate_mul_tests!(body $name, $lname, $dbl);
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);
});
} }
}; };
(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);
});
};
} }

68
src/unsigned/shifts.rs
View File

@@ -94,20 +94,30 @@ macro_rules! generate_shiftl_tests {
($name: ident, $lname: ident) => { ($name: ident, $lname: ident) => {
#[test] #[test]
fn $lname() { fn $lname() {
let fname = format!("testdata/shiftl/{}.tests", stringify!($name)); generate_shiftl_tests!(body $name, $lname);
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));
});
} }
}; };
(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)] #[cfg(test)]
@@ -115,18 +125,28 @@ macro_rules! generate_shiftr_tests {
($name: ident, $lname: ident) => { ($name: ident, $lname: ident) => {
#[test] #[test]
fn $lname() { fn $lname() {
let fname = format!("testdata/shiftr/{}.tests", stringify!($name)); generate_shiftr_tests!(body $name, $lname);
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));
});
} }
}; };
(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));
});
};
} }

30
src/unsigned/square.rs
View File

@@ -57,16 +57,26 @@ macro_rules! generate_square_tests {
($name: ident, $lname: ident, $dbl: ident) => { ($name: ident, $lname: ident, $dbl: ident) => {
#[test] #[test]
fn $lname() { fn $lname() {
let fname = format!("testdata/square/{}.tests", stringify!($name)); generate_square_tests!(body $name, $lname, $dbl);
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());
});
} }
}; };
(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());
});
};
} }

38
src/unsigned/sub.rs
View File

@@ -78,20 +78,30 @@ macro_rules! generate_sub_tests {
($name: ident, $lname: ident) => { ($name: ident, $lname: ident) => {
#[test] #[test]
fn $lname() { fn $lname() {
let fname = format!("testdata/sub/{}.tests", stringify!($name)); generate_sub_tests!(body $name, $lname);
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);
});
} }
}; };
(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);
});
};
} }