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
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 ()

46
src/unsigned/add.rs
View File

@@ -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);
}
});
};
}

96
src/unsigned/barrett.rs
View File

@@ -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));
});
};
}

52
src/unsigned/base.rs
View File

@@ -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);
});
}
}

52
src/unsigned/cmp.rs
View File

@@ -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);
});
};
}

42
src/unsigned/div.rs
View File

@@ -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);
});
};
}

282
src/unsigned/invoc.rs
View File

@@ -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);
}
}

94
src/unsigned/modexp.rs
View File

@@ -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));
}
});
};
}

98
src/unsigned/modmul.rs
View File

@@ -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));
}
});
};
}

86
src/unsigned/modsq.rs
View File

@@ -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));
}
});
};
}

34
src/unsigned/mul.rs
View File

@@ -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);
});
};
}

68
src/unsigned/shifts.rs
View File

@@ -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));
});
};
}

30
src/unsigned/square.rs
View File

@@ -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());
});
};
}

38
src/unsigned/sub.rs
View File

@@ -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);
});
};
}