From da4b3b60b5ab898f3a636e4b273a90d59a29d061 Mon Sep 17 00:00:00 2001 From: Zach Dziura Date: Sat, 11 Jun 2016 15:58:28 -0400 Subject: [PATCH] Moved tests into their appropriate files --- examples/multiply.rs | 10 ++++------ src/common.rs | 46 +++++++++++++++++++++++++++++++++++++++----- src/error.rs | 7 +++++++ src/lib.rs | 19 +++--------------- src/prime.rs | 20 +++++++++++++++---- src/safe_prime.rs | 23 ++++++++++++++++++++++ 6 files changed, 94 insertions(+), 31 deletions(-) diff --git a/examples/multiply.rs b/examples/multiply.rs index 806814c..b0e96af 100644 --- a/examples/multiply.rs +++ b/examples/multiply.rs @@ -3,11 +3,9 @@ extern crate pumpkin; use pumpkin::prime; fn main() { - let p = prime::new(2048); - println!("{:x}", p); + let p = prime::new(1024).unwrap(); + let q = prime::new(1024).unwrap(); + let n = p * q; - let q = prime::new(2048); - println!("\n{:x}", q); - - println!("\n{:X}", p * q); + println!("The product of 'p' and 'q' is: {}", n); } diff --git a/src/common.rs b/src/common.rs index 3171063..4a02033 100644 --- a/src/common.rs +++ b/src/common.rs @@ -120,12 +120,12 @@ pub fn gen_prime(bit_length: usize, rngesus: &mut OsRng) -> Result { // We first want to make sure that the candidate is in the appropriate // size range before continuing. This can easily be done by setting the // two most significant bits of the candidate number to 1. - candidate.set_bit(bit_length as u32, true); - candidate.set_bit((bit_length-1) as u32, true); + candidate.set_bit(1, true); + candidate.set_bit(2, true); // Next, flip the least significant bit to 1, to make sure the candidate // is odd (no sense in testing primality on an even number, after all). - candidate.set_bit(1, true); + candidate.set_bit(bit_length as u32, true); // Now run through the actual primality check! while !is_prime(&candidate) { @@ -199,7 +199,7 @@ fn mod_exp(base: &Int, exponent: &Int, modulus: &Int) -> Int { let mut exponent = exponent.clone(); while exponent > 0_usize { - if &exponent & 1_usize == 1_usize { + if exponent.trailing_zeros() == 0 { result = (&base * result) % modulus; } @@ -240,10 +240,46 @@ fn rewrite(candidate: &Int) -> (Int, Int) { let mut d = candidate - 1_usize; let mut s = Int::zero(); - while &d & 1 == 1_usize { + while d.trailing_zeros() == 0 { // d = &d >> 1_usize; s = &s + 1_usize; } (s, d) } + +#[cfg(test)] +mod tests { + extern crate ramp; + + use ramp::Int; + use super::{fermat, miller_rabin}; + + #[test] + fn test_fermat_prime() { + let candidate = Int::from(65537); + let result = fermat(&candidate); + assert_eq!(result, true); + } + + #[test] + fn test_fermat_not_prime() { + let candidate = Int::from(65535); + let result = fermat(&candidate); + assert_eq!(result, false); + } + + #[test] + fn test_miller_rabin_prime() { + let candidate = Int::from(65537); + let result = miller_rabin(&candidate, 64); + assert_eq!(result, true); + } + + #[test] + fn test_miller_rabin_not_prime() { + let candidate = Int::from(65535); + let result = miller_rabin(&candidate, 64); + assert_eq!(result, false); + } +} diff --git a/src/error.rs b/src/error.rs index 014c599..823bf81 100644 --- a/src/error.rs +++ b/src/error.rs @@ -1,11 +1,18 @@ +//! More coming soon + use ramp::Int; use std::{error, fmt, io, result}; +/// Goddamn docs pub type Result = result::Result; +/// More goddamn docs #[derive(Debug)] pub enum Error { + /// Docs for a variant, are you kidding me?? OsRngInitialization(io::Error), + + /// Jesus fuck, people BitLength(usize) } diff --git a/src/lib.rs b/src/lib.rs index 8b59c4b..6afcd33 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -54,7 +54,7 @@ extern crate rand; extern crate test; mod common; -mod error; +pub mod error; pub mod prime; pub mod safe_prime; @@ -64,19 +64,6 @@ mod tests { use super::{prime, safe_prime}; use test::Bencher; - #[test] - #[should_panic] - fn test_new_small_prime() { - prime::new(511); - } - - #[test] - #[should_panic] - fn test_new_small_prime_from_rng() { - let mut rngesus = OsRng::new().unwrap(); - prime::from_rng(511, &mut rngesus); - } - #[bench] fn bench_generate_512_bit_prime(b: &mut Bencher) { let mut rngesus = OsRng::new().unwrap(); @@ -96,8 +83,8 @@ mod tests { } #[bench] - fn bench_generate_1024_bit_safe_prime(b: &mut Bencher) { + fn bench_generate_512_bit_safe_prime(b: &mut Bencher) { let mut rngesus = OsRng::new().unwrap(); - b.iter(|| safe_prime::from_rng(1024, &mut rngesus)); + b.iter(|| safe_prime::from_rng(512, &mut rngesus)); } } diff --git a/src/prime.rs b/src/prime.rs index b7923b3..f7fff34 100644 --- a/src/prime.rs +++ b/src/prime.rs @@ -22,11 +22,23 @@ pub fn new(bit_length: usize) -> Result { #[cfg(test)] mod tests { - use super::{new, from_rng}; + use super::new; #[test] - #[should_panic] - fn test_prime_bad_bit_length() { - new(511); + fn test_prime_bit_length_too_small() { + let p = new(511); + assert_eq!(false, match p { + Ok(_) => true, + Err(_) => false, + }); + } + + #[test] + fn test_prime() { + let p = new(512); + assert_eq!(true, match p { + Ok(_) => true, + Err(_) => false + }); } } diff --git a/src/safe_prime.rs b/src/safe_prime.rs index ee9d346..2661e10 100644 --- a/src/safe_prime.rs +++ b/src/safe_prime.rs @@ -44,3 +44,26 @@ pub fn from_rng(bit_length: usize, mut rngesus: &mut OsRng) -> Result { Ok(candidate) } } + +#[cfg(test)] +mod tests { + use super::new; + + #[test] + fn test_safe_prime_bit_length_too_small() { + let sp = new(511); + assert_eq!(false, match sp { + Ok(_) => true, + Err(_) => false + }); + } + + #[test] + fn test_safe_prime() { + let sp = new(512); + assert_eq!(true, match sp { + Ok(_) => true, + Err(_) => false + }); + } +}