Clean up old debugging infrastructure.

src/ecdsa/point.rs

@@ -246,7 +246,6 @@ macro_rules! point_tests
             fn add_scale2() {
                 let fname = build_test_path("ecc/add_scale2",stringify!($curve));
                 run_test(fname.to_string(), 8, |case| {
-                    println!("-----------------------------------------------");
                     let (negx, xbytes) = case.get("x").unwrap();
                     let (negy, ybytes) = case.get("y").unwrap();
                     let (negp, pbytes) = case.get("p").unwrap();
@@ -258,25 +257,15 @@ macro_rules! point_tests
 
                     let x = $stype::new(*negx, $utype::from_bytes(xbytes));
                     let y = $stype::new(*negy, $utype::from_bytes(ybytes));
-                    println!("x1: {:X}", x);
-                    println!("y1: {:X}", y);
                     let p = $stype::new(*negp, $utype::from_bytes(pbytes));
                     let q = $stype::new(*negq, $utype::from_bytes(qbytes));
-                    println!("x2: {:X}", p);
-                    println!("y2: {:X}", q);
                     let n = $stype::new(*negn, $utype::from_bytes(nbytes));
-                    println!("n:  {:X}", n);
                     let m = $stype::new(*negm, $utype::from_bytes(mbytes));
-                    println!("m:  {:X}", m);
                     let r = $stype::new(*negr, $utype::from_bytes(rbytes));
                     let s = $stype::new(*negs, $utype::from_bytes(sbytes));
-                    println!("rx: {:X}", r);
-                    println!("ry: {:X}", s);
                     let p1  = Point::<$curve>{ x: x, y: y };
                     let p2  = Point::<$curve>{ x: p, y: q };
                     let res = Point::<$curve>::double_scalar_mult(&n, &p1, &m, &p2);
-                    println!("mx: {:X}", res.x);
-                    println!("my: {:X}", res.y);
                     assert_eq!(r, res.x, "x equivalence");
                     assert_eq!(s, res.y, "y equivalence");
                 });

src/rsa/private.rs

@@ -36,15 +36,6 @@ pub enum RSAPrivate {
     Key15360(RSA15360Private)
 }
 
-// fn print_vector(name: &'static str, bytes: &[u8])
-// {
-//     print!("{}: (length {}) ", name, bytes.len());
-//     for x in bytes.iter() {
-//         print!("{:02X}", *x);
-//     }
-//     println!("");
-// }
-
 macro_rules! generate_rsa_private
 {
     ($rsa: ident, $num: ident, $bar: ident, $size: expr) => {

src/rsa/public.rs

@@ -102,8 +102,6 @@ impl FromASN1 for RSAPublic {
                 let nsize = n.bits();
                 let mut rsa_size = 512;
 
-                println!("n': {:X}", n);
-                println!("nsize: {}", nsize);
                 while rsa_size < nsize {
                     rsa_size = rsa_size + 256;
                 }
@@ -178,15 +176,6 @@ impl ToASN1 for RSAPublic {
     }
 }
 
-// fn print_vector(name: &'static str, bytes: &[u8])
-// {
-//     print!("{}: (length {}) ", name, bytes.len());
-//     for x in bytes.iter() {
-//         print!("{:02X}", *x);
-//     }
-//     println!("");
-// }
-
 macro_rules! generate_rsa_public
 {
     ($rsa: ident, $num: ident, $bar: ident, $var: ident, $size: expr) => {
@@ -472,7 +461,7 @@ macro_rules! generate_tests {
                         384 => privkey.decrypt(&OAEPParams::<Sha384>::new(lstr), &cipher.unwrap()),
                         512 => privkey.decrypt(&OAEPParams::<Sha512>::new(lstr), &cipher.unwrap()),
                         x   => panic!("Unknown hash number: {}", x)
-                                  };
+                    };
                     assert!(message.is_ok());
                     assert_eq!(mbytes, &message.unwrap());
                 });

src/x509/mod.rs

@@ -59,21 +59,13 @@ fn decode_certificate(x: &ASN1Block)
     //
     match x {
         &ASN1Block::Sequence(_, _, ref b0) => {
-            println!("STEP1");
             let (version,  b1) = X509Version::from_asn1(b0)?;
-            println!("STEP2");
             let (serial,   b2) = X509Serial::from_asn1(b1)?;
-            println!("STEP3");
             let (ident,    b3) = AlgorithmIdentifier::from_asn1(b2)?;
-            println!("STEP4");
             let (issuer,   b4) = InfoBlock::from_asn1(b3)?;
-            println!("STEP5");
             let (validity, b5) = Validity::from_asn1(b4)?;
-            println!("STEP6");
             let (subject,  b6) = InfoBlock::from_asn1(b5)?;
-            println!("STEP7");
             let (subkey,   _ ) = X509PublicKey::from_asn1(b6)?;
-            println!("STEP8");
             Ok(GenericCertificate {
                 version: version,
                 serial: serial,