Add a testbit() operationg.

src/signed/base.rs

@@ -87,6 +87,10 @@ macro_rules! signed_impls {
             fn mask(&mut self, len: usize) {
                 self.value.mask(len);
             }
+
+            fn testbit(&self, bit: usize) -> bool {
+                self.value.testbit(bit)
+            }
         }
 
         #[cfg(test)]

src/unsigned/base.rs

@@ -13,6 +13,9 @@ pub trait CryptoNum {
     /// Mask off the high parts of the number. In particular, it
     /// zeros the bits above (len * 64).
     fn mask(&mut self, len: usize);
+    /// Test if the given bit is zero, where bits are numbered in
+    /// least-significant order (0 is the LSB, etc.).
+    fn testbit(&self, bit: usize) -> bool;
 }
 
 macro_rules! generate_base
@@ -50,6 +53,17 @@ macro_rules! generate_base
                     self.value[i] = 0;
                 }
             }
+
+            fn testbit(&self, bit: usize) -> bool {
+                let idx = bit / 64;
+                let offset = bit % 64;
+                println!("Testing bit {} of {:X}", bit, self);
+                if idx >= $size {
+                    return false;
+                }
+                println!("{:x} & {:x} == {:x}", self.value[idx], 1u64 << offset, self.value[idx] & (1u64 << offset));
+                (self.value[idx] & (1u64 << offset)) != 0
+            }
         }
 
         #[cfg(test)]
@@ -93,23 +107,31 @@ macro_rules! generate_base_tests
     };
     (body $name: ident, $lname: ident) => {
         let fname = build_test_path("base", stringify!($name));
-        run_test(fname.to_string(), 6, |case| {
+        run_test(fname.to_string(), 8, |case| {
             let (neg0, xbytes) = case.get("x").unwrap();
             let (neg1, mbytes) = case.get("m").unwrap();
             let (neg2, zbytes) = case.get("z").unwrap();
             let (neg3, ebytes) = case.get("e").unwrap();
             let (neg4, obytes) = case.get("o").unwrap();
             let (neg5, rbytes) = case.get("r").unwrap();
-            assert!(!neg0 && !neg1 && !neg2 && !neg3 && !neg4 && !neg5);
+            let (neg6, bbytes) = case.get("b").unwrap();
+            let (neg7, tbytes) = case.get("t").unwrap();
+            assert!(!neg0&&!neg1&&!neg2&&!neg3&&!neg4&&!neg5&&!neg6&&!neg7);
             let mut x = $name::from_bytes(xbytes);
+            println!("---------");
+            println!("x: {:x}", x);
             let m = $name::from_bytes(mbytes);
             let z = 1 == zbytes[0];
             let e = 1 == ebytes[0];
             let o = 1 == obytes[0];
             let r = $name::from_bytes(rbytes);
-            assert_eq!(x.is_zero(), z);
+            let b = usize::from($name::from_bytes(bbytes));
-            assert_eq!(x.is_even(), e);
+            println!("b: {:x}", b);
-            assert_eq!(x.is_odd(),  o);
+            let t = 1 == tbytes[0];
+            assert_eq!(x.is_zero(),  z);
+            assert_eq!(x.is_even(),  e);
+            assert_eq!(x.is_odd(),   o);
+            assert_eq!(x.testbit(b), t);
             x.mask(usize::from(&m));
             assert_eq!(x, r);
         });

test-generator/Tests.hs

@@ -6,7 +6,7 @@ module Tests(
  where
 
 import           Control.Exception(assert)
-import           Data.Bits(shiftL,shiftR)
+import           Data.Bits(shiftL,shiftR,testBit)
 import           Data.Map.Strict(Map)
 import qualified Data.Map.Strict as Map
 import           Database
@@ -80,12 +80,15 @@ baseTest :: Test
 baseTest size memory0 =
   let (x, memory1) = generateNum memory0 "x" size
       (m, memory2) = generateNum memory1 "m" size
+      (b, memory3) = generateNum memory2 "b" 16
       m'           = m `mod` (fromIntegral size `div` 64)
       r            = x `mod` (2 ^ (64 * m'))
+      t            = x `testBit` (fromIntegral b)
       res          = Map.fromList [("x", showX x),        ("z", showB (x == 0)),
                                    ("e", showB (even x)), ("o", showB (odd x)),
-                                   ("m", showX m'),       ("r", showX r)]
+                                   ("m", showX m'),       ("r", showX r),
-  in (res, x, memory2)
+                                   ("b", showX b),        ("t", showB t)]
+  in (res, x, memory3)
 
 compareTest :: Test
 compareTest size memory0 =