Now with tests for the basic algorithms.

src/unsigned/add.rs

@@ -14,7 +14,7 @@ pub fn addition(dest: &mut [u64], src: &[u64])
     dest[src.len()] = carry as u64;
 }
 
-pub fn unsafe_addition(dest: &mut [u64], src: &[u64])
+pub fn unsafe_addition(dest: &mut [u64], src: &[u64], really_unsafe: bool)
 {
     assert_eq!(dest.len(), src.len());
     let mut carry: u128 = 0;
@@ -27,7 +27,10 @@ pub fn unsafe_addition(dest: &mut [u64], src: &[u64])
         dest[i] = z128 as u64;
         carry = z128 >> 64;
     }
-    assert_eq!(carry, 0, "Unsafe overflow in AddAssign");
+
+    if !really_unsafe {
+        assert_eq!(carry, 0, "Unsafe overflow in AddAssign");
+    }
 }
 
 macro_rules! addition_impls
@@ -35,13 +38,13 @@ macro_rules! addition_impls
     ($base: ident, $bigger: ident) => {
         impl AddAssign<$base> for $base {
             fn add_assign(&mut self, rhs: $base) {
-                unsafe_addition(&mut self.value, &rhs.value);
+                unsafe_addition(&mut self.value, &rhs.value, false);
             }
         }
 
         impl<'a> AddAssign<&'a $base> for $base {
             fn add_assign(&mut self, rhs: &$base) {
-                unsafe_addition(&mut self.value, &rhs.value);
+                unsafe_addition(&mut self.value, &rhs.value, false);
             }
         }
 
@@ -95,4 +98,29 @@ macro_rules! addition_impls
     }
 }
 
-//addition_impls!(U192,   U256);
+#[cfg(test)]
+macro_rules! generate_add_tests {
+    ($name: ident, $lname: ident, $plus1: ident) => {
+        #[test]
+        fn $lname() {
+            let fname = format!("testdata/add/{}.tests", stringify!($name));
+            run_test(fname.to_string(), 3, |case| {
+                let (neg0, abytes) = case.get("a").unwrap();
+                let (neg1, bbytes) = case.get("b").unwrap();
+                let (neg2, cbytes) = case.get("c").unwrap();
+                assert!(!neg0 && !neg1 && !neg2);
+
+                let a = $name::from_bytes(abytes);
+                let b = $name::from_bytes(bbytes);
+                let c = $plus1::from_bytes(cbytes);
+                assert_eq!(c, &a + &b);
+
+                if c.value[c.value.len()-1] == 0 {
+                    let mut aprime = a.clone();
+                    aprime += b;
+                    assert_eq!($name::from(c), aprime);
+                }
+            });
+        }
+    };
+}