adding tests to each module

Cargo.toml

@@ -32,3 +32,4 @@ features = ["rustc-serialize"]
 [[bin]]
 name = "bolt"
 path = "bin/bolt.rs"
+

Makefile

@@ -1,7 +1,12 @@
-.PHONY: all bench test update doc clean
+.PHONY: all debug bench test update doc clean
 
 all:
-	export RUST_BACKTRACE=1
+	export RUSTFLAGS=-Awarnings
+	cargo +nightly build
+	cargo +nightly run
+
+debug:
+	export RUST_BACKTRACE=1 
 	cargo +nightly build
 	cargo +nightly run
 

src/clsigs.rs

@@ -3,7 +3,6 @@
 
 use std::fmt;
 use std::str;
-//use rand::prelude::*;
 use rand::{thread_rng, Rng};
 use bn::{Group, Fr, G1, G2, Gt, pairing};
 use debug_elem_in_hex;
@@ -339,23 +338,53 @@ pub fn verifyD(mpk: &PublicParams, pk: &PublicKeyD, m: &Vec<Fr>, sig: &Signature
                pairing(mpk.g1, Ais + -Bis + -sig.b + -sig.c);
 }
 
-pub fn add_two(a: i32) -> i32 {
-    a + 2
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
-    use test::Bencher;
+    use bn::{Fr, Group};
 
     #[test]
-    fn it_works() {
-        assert_eq!(4, add_two(2));
+    fn schemeA_sign_and_verify_works() {
+        // test ability to sign/verify a single message
+        let rng = &mut thread_rng();
+
+        let mpk = setupA();
+        let keypair = keygenA(&mpk);
+
+        let mut m1 = Fr::random(rng);
+        let mut m2 = Fr::random(rng);
+
+        let signature = signA(&keypair.sk, m1);
+        //println!("{}", signature);
+
+        assert!(verifyA(&mpk, &keypair.pk, m1, &signature) == true);
+        assert!(verifyA(&mpk, &keypair.pk, m2, &signature) == false);
     }
 
-    #[bench]
-    fn bench_add_two(b: &mut Bencher) {
-        b.iter(|| add_two(2));
+    #[test]
+    fn schemeD_sign_and_verify_works() {
+        // test ability to sign/verify a vector of messages
+        let rng = &mut thread_rng();
+
+        let mpk = setupD();
+        let l = 3;
+        let keypair = keygenD(&mpk, l);
+
+        let mut m1 : Vec<Fr> = Vec::new();
+        let mut m2 : Vec<Fr> = Vec::new();
+
+        for i in 0 .. l+1 {
+            m1.push(Fr::random(rng));
+            m2.push(Fr::random(rng));
+        }
+
+        let signature = signD(&mpk, &keypair.sk, &m1);
+        //println!("{}", signature);
+
+        assert!(verifyD(&mpk, &keypair.pk, &m1, &signature) == true);
+        assert!(verifyD_unoptimized(&mpk, &keypair.pk, &m1, &signature) == true);
+        assert!(verifyD(&mpk, &keypair.pk, &m2, &signature) == false);
+
     }
 }
 
@@ -651,4 +680,4 @@ pub fn vs_verify_blind_sig(mpk: &PublicParams, pk: &PublicKeyD, proof: &ProofVS,
     }
 
     return result0 && result1 && result2 && result3;
-}
+}

src/commit_scheme.rs

@@ -145,6 +145,16 @@ pub fn setup(len: usize, pub_bases: Vec<G2>, h: G2) -> CSParams {
     return CSParams { pub_bases: p };
 }
 
+pub fn setup_gen_params(len: usize) -> CSParams {
+    let rng = &mut thread_rng();
+
+    let mut p: Vec<G2> = Vec::new();
+    for i in 0 .. len {
+        p.push(G2::random(rng));
+    }
+    return CSParams { pub_bases: p };
+}
+
 pub fn commit(csp: &CSParams, x: &Vec<Fr>, r: Fr) -> Commitment {
     let rng = &mut thread_rng();
 
@@ -169,11 +179,47 @@ pub fn decommit(csp: &CSParams, cm: &Commitment, x: &Vec<Fr>) -> bool {
     let l = x.len();
     //assert!(csp.pub_bases.len() == l);
     // pub_base[0] => h, x[0] => r
-    // TODO: check that cm.r == x[0]
+    // check that cm.r == x[0]
+    // assert!(cm.r == x[0]);
     let mut dc = csp.pub_bases[0] * cm.r;
     for i in 1 .. l {
         dc = dc + (csp.pub_bases[i] * x[i]);
     }
-    return dc == cm.c;
+    return dc == cm.c && cm.r == x[0];
 }
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use bn::{Fr, Group};
+
+    #[test]
+    fn commit_one_message_works() {
+        let rng = &mut thread_rng();
+        let pk = ped92_setup();
+
+        let m1 = Fr::random(rng);
+        let m2 = m1 + Fr::from_str("1").unwrap();
+        let r = Fr::random(rng);
+        let c = ped92_commit(&pk, m1, Some(r));
+
+        assert!(ped92_decommit(&pk, &c, m1) == true);
+        assert!(ped92_decommit(&pk, &c, m2) == false);
+    }
+
+    #[test]
+    fn commit_n_message_works() {
+        let rng = &mut thread_rng();
+        let len = 3;
+        let csp = setup_gen_params(len);
+
+        let mut m: Vec<Fr> = Vec::new();
+        for i in 0 .. len {
+            m.push(Fr::random(rng));
+        }
+        let r = m[0];
+        let c = commit(&csp, &m, r);
+
+        assert!(decommit(&csp, &c, &m) == true);
+    }
+}

src/lib.rs

@@ -9,6 +9,9 @@
 //!
 #![feature(extern_prelude)]
 
+#![cfg_attr(all(test, feature = "unstable"), feature(test))]
+#[cfg(all(test, feature = "unstable"))] extern crate test;
+
 extern crate bn;
 extern crate rand;
 extern crate rand_core;
@@ -692,7 +695,6 @@ pub mod bidirectional {
 
     pub fn init_customer(pp: &PublicParams, channel: &ChannelState, b0_customer: i32, b0_merchant: i32,
                          cm_csp: &commit_scheme::CSParams, keypair: &clsigs::KeyPairD) -> InitCustomerData {
-        println!("Run Init customer...");
         let rng = &mut rand::thread_rng();
         // generate verification key and signing key (for wallet)
         let mut schnorr = secp256k1::Secp256k1::new();
@@ -721,7 +723,6 @@ pub mod bidirectional {
     }
 
     pub fn init_merchant(pp: &PublicParams, b0_merchant: i32, keypair: &clsigs::KeyPairD) -> InitMerchantData {
-        println!("Run Init merchant...");
         let cm_csp = generate_commit_setup(&pp, &keypair.pk);
         let csk_m = MerchSecretKey { sk: keypair.sk.clone(), balance: b0_merchant };
         return InitMerchantData { T: keypair.pk.clone(), csk: csk_m, bases: cm_csp.pub_bases };
@@ -736,7 +737,6 @@ pub mod bidirectional {
     //// begin of establish channel protocol
     pub fn establish_customer_phase1(pp: &PublicParams, c_data: &InitCustomerData,
                                      m_data: &InitMerchantData) -> clsigs::ProofCV {
-        println!("Run establish_customer algorithm...");
         // obtain customer init data
         let t_c = &c_data.T;
         let csk_c = &c_data.csk;
@@ -805,7 +805,7 @@ pub mod bidirectional {
         // retrieve old balance
         let old_balance = Fr::from_str(old_w.balance.to_string().as_str()).unwrap();
 
-        let old_h_wpk = old_w.h_wpk; // hashPubKeyToFr(&old_wpk);
+        let old_h_wpk = old_w.h_wpk;
         // added the blinding factor to list of secrets
         let mut old_x: Vec<Fr> = Vec::new();
 
@@ -838,7 +838,7 @@ pub mod bidirectional {
 
     pub fn pay_by_customer_phase1(pp: &PublicParams, T: &ChannelToken, pk_m: &clsigs::PublicKeyD,
                                   old_w: &CustomerWallet, balance_increment: i32) -> (ChannelToken, CustomerWallet, PaymentProof) {
-        println!("pay_by_customer_phase1 - generate new wallet commit, PoK of commit values, and PoK of old wallet.");
+        //println!("pay_by_customer_phase1 - generate new wallet commit, PoK of commit values, and PoK of old wallet.");
         // get balance, keypair, commitment randomness and wallet sig
         let mut rng = &mut rand::thread_rng();
 
@@ -920,7 +920,6 @@ pub mod bidirectional {
     // a negative increment => decrement merchant balance, and increment customer balance
     pub fn pay_by_merchant_phase1(pp: &PublicParams, mut state: &mut ChannelState, proof: &PaymentProof,
                                   m_data: &InitMerchantData) -> clsigs::SignatureD {
-        println!("Run pay algorithm by Merchant - phase 2");
         let blind_sigs = &proof.wallet_sig;
         let proof_cv = &proof.proof2a;
         let proof_old_cv = &proof.proof2b;
@@ -1069,7 +1068,6 @@ pub mod bidirectional {
     // for customer => on input a wallet w, it outputs a customer channel closure message rc_c
     pub fn customer_refund(pp: &PublicParams, state: &ChannelState, pk_m: &clsigs::PublicKeyD,
                            w: &CustomerWallet) -> ChannelClosure_C {
-        println!("Run Refund...");
         let m;
         let balance = w.balance as usize;
         if !state.pay_init {
@@ -1124,8 +1122,6 @@ pub mod bidirectional {
     // outputs a merchant channel closure message rc_m and updated merchant state S_new
     pub fn merchant_refute(pp: &PublicParams, T_c: &ChannelToken, m_data: &InitMerchantData,
                   state: &mut ChannelState, rc_c: &ChannelClosure_C, rv_token: &secp256k1::Signature)  -> Option<ChannelClosure_M> {
-        println!("Run Refute...");
-
         let is_valid = clsigs::verifyD(&pp.cl_mpk, &T_c.pk, &rc_c.message.hash(), &rc_c.signature);
         if is_valid {
             let wpk = rc_c.message.wpk;
@@ -1154,7 +1150,6 @@ pub mod bidirectional {
     pub fn resolve(pp: &PublicParams, c: &InitCustomerData, m: &InitMerchantData, // cust and merch
                    rc_c: Option<ChannelClosure_C>, rc_m: Option<ChannelClosure_M>,
                    rt_w: Option<clsigs::SignatureD>) -> (i32, i32) {
-        println!("Run Resolve...");
         let total_balance = c.csk.balance + m.csk.balance;
         if rc_c.is_none() && rc_m.is_none() {
             panic!("resolve - Did not specify channel closure messages for either customer or merchant!");
@@ -1227,3 +1222,14 @@ pub mod bidirectional {
         panic!("resolve - Did not specify channel closure messages for either customer or merchant!");
     }
 }
+
+#[cfg(all(test, feature = "unstable"))]
+mod benches {
+    use rand::{Rng, thread_rng};
+    use test::{Bencher, black_box};
+
+    #[bench]
+    pub fn bench_one(bh: &mut Bencher) {
+        println!("Hello World!");
+    }
+}