Moved tests into their appropriate files

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

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

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<Int, Error>;
 
+/// More goddamn docs
 #[derive(Debug)]
 pub enum Error {
+    /// Docs for a variant, are you kidding me??
     OsRngInitialization(io::Error),
+
+    /// Jesus fuck, people
     BitLength(usize)
 }
 

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

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

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