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

Switch to the same test naming scheme across modules.

Browse Source
This commit is contained in:
Adam Wick
2018-06-10 10:36:34 -07:00
parent b5afa8fdf9
commit 5a5b48569b
3 changed files with 127 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files

107
src/cryptonum/addition.rs
View File

@@ -100,66 +100,67 @@ generate_adders!(U4096);
generate_adders!(U8192); generate_adders!(U8192);
generate_adders!(U15360); generate_adders!(U15360);
#[cfg(test)]
use testing::run_test;
#[cfg(test)]
use cryptonum::Decoder;
macro_rules! generate_tests { macro_rules! generate_tests {
($name: ident, $testname: ident, $modtestname: ident) => ( ( $( $name:ident ),* ) => {
#[cfg(test)] #[cfg(test)]
#[test] mod normal {
#[allow(non_snake_case)] use cryptonum::Decoder;
fn $testname() { use super::*;
let fname = format!("tests/math/addition{}.test", use testing::run_test;
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); #[test]
let b = $name::from_bytes(bbytes); #[allow(non_snake_case)]
let c = $name::from_bytes(cbytes); fn $name() {
assert_eq!(&a + &b, c); let fname = format!("tests/math/addition{}.test",
a += b; stringify!($name));
assert_eq!(a, c); 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!(&a + &b, c);
a += b;
assert_eq!(a, c);
});
}
)*
} }
#[cfg(test)] #[cfg(test)]
#[test] mod slow_modular {
#[allow(non_snake_case)] use cryptonum::encoding::Decoder;
fn $modtestname() { use super::*;
let fname = format!("tests/math/modadd{}.test", use testing::run_test;
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, cbytes) = case.get("c").unwrap();
let (neg3, mbytes) = case.get("m").unwrap();
assert!(!neg0 && !neg1 && !neg2 && !neg3); $(
let mut a = $name::from_bytes(abytes); #[test]
let b = $name::from_bytes(bbytes); #[allow(non_snake_case)]
let m = $name::from_bytes(mbytes); fn $name() {
let c = $name::from_bytes(cbytes); let fname = format!("tests/math/modadd{}.test",
a.modadd(&b, &m); stringify!($name));
assert_eq!(a, c); run_test(fname.to_string(), 4, |case| {
}); let (neg0, abytes) = case.get("a").unwrap();
let (neg1, bbytes) = case.get("b").unwrap();
let (neg2, cbytes) = case.get("c").unwrap();
let (neg3, mbytes) = case.get("m").unwrap();
assert!(!neg0 && !neg1 && !neg2 && !neg3);
let mut a = $name::from_bytes(abytes);
let b = $name::from_bytes(bbytes);
let m = $name::from_bytes(mbytes);
let c = $name::from_bytes(cbytes);
a.modadd(&b, &m);
assert_eq!(a, c);
});
}
)*
} }
) }
} }
generate_tests!(U192,u192,modU192); generate_tests!(U192, U256, U384, U512, U576, U1024, U2048, U3072, U4096, U8192, U15360);
generate_tests!(U256,u256,modU256);
generate_tests!(U384,u384,modU384);
generate_tests!(U512,u512,modU512);
generate_tests!(U576,u576,modU576);
generate_tests!(U1024,u1024,modU1024);
generate_tests!(U2048,u2048,modU2048);
generate_tests!(U3072,u3072,modU3072);
generate_tests!(U4096,u4096,modU4096);
generate_tests!(U8192,u8192,modU8192);
generate_tests!(U15360,u15360,modU15360);

88
src/cryptonum/division.rs
View File

@@ -197,52 +197,54 @@ fn matching_bignum_ge(x: &[u64], y: &[u64]) -> bool
} }
#[cfg(test)] #[cfg(test)]
use testing::run_test; mod normal {
#[cfg(test)] use testing::run_test;
use cryptonum::Decoder; use cryptonum::Decoder;
#[cfg(test)] use cryptonum::{U192,U256,U384,U512,U576,U1024,
use cryptonum::{U192,U256,U384,U512,U576,U1024,U2048,U3072,U4096,U8192,U15360}; U2048,U3072,U4096,U8192,U15360};
use super::*;
macro_rules! generate_tests { macro_rules! generate_tests {
($name: ident, $testname: ident) => ( ($name: ident) => (
#[cfg(test)] #[cfg(test)]
#[test] #[test]
#[allow(non_snake_case)] #[allow(non_snake_case)]
fn $testname() { fn $name() {
let fname = format!("tests/math/division{}.test", let fname = format!("tests/math/division{}.test",
stringify!($name)); stringify!($name));
run_test(fname.to_string(), 4, |case| { run_test(fname.to_string(), 4, |case| {
let (neg0, abytes) = case.get("a").unwrap(); let (neg0, abytes) = case.get("a").unwrap();
let (neg1, bbytes) = case.get("b").unwrap(); let (neg1, bbytes) = case.get("b").unwrap();
let (neg2, qbytes) = case.get("q").unwrap(); let (neg2, qbytes) = case.get("q").unwrap();
let (neg3, rbytes) = case.get("r").unwrap(); let (neg3, rbytes) = case.get("r").unwrap();
assert!(!neg0 && !neg1 && !neg2 && !neg3); assert!(!neg0 && !neg1 && !neg2 && !neg3);
let a = $name::from_bytes(abytes); let a = $name::from_bytes(abytes);
let b = $name::from_bytes(bbytes); let b = $name::from_bytes(bbytes);
let q = $name::from_bytes(qbytes); let q = $name::from_bytes(qbytes);
let r = $name::from_bytes(rbytes); let r = $name::from_bytes(rbytes);
let mut myq = $name::new(); let mut myq = $name::new();
let mut myr = $name::new(); let mut myr = $name::new();
divmod(&a.values, &b.values, &mut myq.values, &mut myr.values); divmod(&a.values, &b.values, &mut myq.values, &mut myr.values);
assert_eq!(q, myq); assert_eq!(q, myq);
assert_eq!(r, myr); assert_eq!(r, myr);
}); });
} }
) )
} }
generate_tests!(U192,u192); generate_tests!(U192);
generate_tests!(U256,u256); generate_tests!(U256);
generate_tests!(U384,u384); generate_tests!(U384);
generate_tests!(U512,u512); generate_tests!(U512);
generate_tests!(U576,u576); generate_tests!(U576);
generate_tests!(U1024,u1024); generate_tests!(U1024);
generate_tests!(U2048,u2048); generate_tests!(U2048);
generate_tests!(U3072,u3072); generate_tests!(U3072);
generate_tests!(U4096,u4096); generate_tests!(U4096);
generate_tests!(U8192,u8192); generate_tests!(U8192);
generate_tests!(U15360,u15360); generate_tests!(U15360);
}

64
src/cryptonum/subtraction.rs
View File

@@ -76,45 +76,37 @@ generate_subbers!(U4096);
generate_subbers!(U8192); generate_subbers!(U8192);
generate_subbers!(U15360); generate_subbers!(U15360);
#[cfg(test)]
use testing::run_test;
#[cfg(test)]
use cryptonum::Decoder;
macro_rules! generate_tests { macro_rules! generate_tests {
($name: ident, $testname: ident) => ( ( $( $name:ident ),* ) => {
#[cfg(test)] #[cfg(test)]
#[test] mod normal {
#[allow(non_snake_case)] use cryptonum::Decoder;
fn $testname() { use super::*;
let fname = format!("tests/math/subtraction{}.test", use testing::run_test;
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); #[test]
let b = $name::from_bytes(bbytes); #[allow(non_snake_case)]
let c = $name::from_bytes(cbytes); fn $name() {
let r = &a - &b; let fname = format!("tests/math/subtraction{}.test",
assert_eq!(r, c); stringify!($name));
a -= b; run_test(fname.to_string(), 3, |case| {
assert_eq!(a, c); 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!(&a - &b, c);
a -= b;
assert_eq!(a, c);
});
}
)*
} }
) }
} }
generate_tests!(U192,u192); generate_tests!(U192, U256, U384, U512, U576, U1024, U2048, U3072, U4096, U8192, U15360);
generate_tests!(U256,u256);
generate_tests!(U384,u384);
generate_tests!(U512,u512);
generate_tests!(U576,u576);
generate_tests!(U1024,u1024);
generate_tests!(U2048,u2048);
generate_tests!(U3072,u3072);
generate_tests!(U4096,u4096);
generate_tests!(U8192,u8192);
generate_tests!(U15360,u15360);