added bit iterator tests

src/bit_iterator.rs

@@ -15,18 +15,44 @@ impl<E: AsRef<[u8]>> BitIterator<E> {
     }
 }
 
-// FIXME: tests!
 impl<E: AsRef<[u8]>> Iterator for BitIterator<E> {
     type Item = bool;
 
+    /// Iterates data bits starting with the least significant bit.
     fn next(&mut self) -> Option<bool> {
         if self.n == 0 {
             None
         } else {
             self.n -= 1;
-            let part = self.n / 8;
-            let bit = self.n - (8 * part);
-            Some(self.t.as_ref()[part] & (1 << bit) > 0)
+            let byte = self.n / 8;
+            let bit = 7 - (self.n - (8 * byte));
+            Some(self.t.as_ref()[byte] & (1 << bit) > 0)
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::BitIterator;
+    use rand::{self, Rng};
+
+    #[test]
+    fn test_bit_iterator() {
+        const LEN: usize = 20;
+        let mut rng = rand::thread_rng();
+        let u: Vec<u8> = (0..LEN).map(|_| rng.gen()).collect();
+        let mut bits = BitIterator::new(u.clone());
+        let mut v = Vec::new();
+        for _byte in 0..LEN {
+            let mut o: u8 = 0;
+            for bit in 0..8 {
+                if let Some(b) = bits.next() {
+                    o |= (b as u8) << bit;
+                }
+            }
+            v.push(o);
+        }
+        v.reverse();
+        assert_eq!(u, v);
+    }
+}

src/lib.rs

@@ -850,4 +850,34 @@ mod tests {
         let deser_sig = bincode::deserialize(&ser_sig).expect("deserialize signature");
         assert_eq!(sig, deser_sig);
     }
+
+    /// Tests of random bit distribution within signatures using `BitIterator`.
+    #[test]
+    fn test_signature_bit_iterator() {
+        let sk: SecretKey = random();
+        let msg0 = b"Tenant signature: ______";
+        let sig0 = sk.sign(msg0);
+        let bits0 = sig0.bit_iter();
+        let msg1 = b"Landlord signature: ______";
+        let sig1 = sk.sign(msg1);
+        let bits1 = sig1.bit_iter();
+        let msg2 = b"Agent signature: ______";
+        let sig2 = sk.sign(msg2);
+        let bits2 = sig2.bit_iter();
+        let mut count: usize = 0;
+        let mut count_any = 0;
+        let mut count_all = 0;
+        for (b0, (b1, b2)) in bits0.zip(bits1.zip(bits2)) {
+            count += 1;
+            if b0 || b1 || b2 {
+                count_any += 1;
+            }
+            if b0 && b1 && b2 {
+                count_all += 1;
+            }
+        }
+        assert!(count > 0);
+        assert!(count_any >= count / 3);
+        assert!(count_all < count / 3);
+    }
 }