diff --git a/src/common/BitArrayTestCase.java b/src/common/BitArrayTestCase.java
deleted file mode 100644
index d800e6d..0000000
--- a/src/common/BitArrayTestCase.java
+++ /dev/null
@@ -1,258 +0,0 @@
-/*
- * Copyright 2007 ZXing authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.google.zxing.common;
-
-import org.junit.Assert;
-import org.junit.Test;
-
-import java.util.Random;
-
-/**
- * @author Sean Owen
- */
-public final class BitArrayTestCase extends Assert {
-
-  @Test
-  public void testGetSet() {
-    BitArray array = new BitArray(33);
-    for (int i = 0; i < 33; i++) {
-      assertFalse(array.get(i));
-      array.set(i);
-      assertTrue(array.get(i));
-    }
-  }
-
-  @Test
-  public void testGetNextSet1() {
-    BitArray array = new BitArray(32);
-    for (int i = 0; i < array.getSize(); i++) {
-      assertEquals(String.valueOf(i), 32, array.getNextSet(i));
-    }
-    array = new BitArray(33);
-    for (int i = 0; i < array.getSize(); i++) {
-      assertEquals(String.valueOf(i), 33, array.getNextSet(i));
-    }
-  }
-  
-  @Test
-  public void testGetNextSet2() {
-    BitArray array = new BitArray(33);    
-    array.set(31);
-    for (int i = 0; i < array.getSize(); i++) {
-      assertEquals(String.valueOf(i), i <= 31 ? 31 : 33, array.getNextSet(i));
-    }
-    array = new BitArray(33);
-    array.set(32);
-    for (int i = 0; i < array.getSize(); i++) {
-      assertEquals(String.valueOf(i), 32, array.getNextSet(i));
-    }
-  }
-  
-  @Test
-  public void testGetNextSet3() {
-    BitArray array = new BitArray(63);    
-    array.set(31);
-    array.set(32);
-    for (int i = 0; i < array.getSize(); i++) {
-      int expected;
-      if (i <= 31) {
-        expected = 31;
-      } else if (i == 32) {
-        expected = 32;
-      } else {
-        expected = 63;
-      }
-      assertEquals(String.valueOf(i), expected, array.getNextSet(i));
-    }
-  }
-
-  @Test
-  public void testGetNextSet4() {
-    BitArray array = new BitArray(63);
-    array.set(33);
-    array.set(40);
-    for (int i = 0; i < array.getSize(); i++) {
-      int expected;
-      if (i <= 33) {
-        expected = 33;
-      } else if (i <= 40) {
-        expected = 40;
-      } else {
-        expected = 63;
-      }
-      assertEquals(String.valueOf(i), expected, array.getNextSet(i));
-    }
-  }
-  
-  @Test
-  public void testGetNextSet5() {
-    Random r = new Random(0xDEADBEEF);
-    for (int i = 0; i < 10; i++) {
-      BitArray array = new BitArray(1 + r.nextInt(100));
-      int numSet = r.nextInt(20);
-      for (int j = 0; j < numSet; j++) {
-        array.set(r.nextInt(array.getSize()));
-      }
-      int numQueries = r.nextInt(20);
-      for (int j = 0; j < numQueries; j++) {
-        int query = r.nextInt(array.getSize());
-        int expected = query;
-        while (expected < array.getSize() && !array.get(expected)) {
-          expected++;
-        }
-        int actual = array.getNextSet(query);
-        assertEquals(expected, actual);
-      }
-    }
-  }
-
-
-  @Test
-  public void testSetBulk() {
-    BitArray array = new BitArray(64);
-    array.setBulk(32, 0xFFFF0000);
-    for (int i = 0; i < 48; i++) {
-      assertFalse(array.get(i));
-    }
-    for (int i = 48; i < 64; i++) {
-      assertTrue(array.get(i));
-    }
-  }
-
-  @Test
-  public void testSetRange() {
-    BitArray array = new BitArray(64);
-    array.setRange(28, 36);
-    assertFalse(array.get(27));
-    for (int i = 28; i < 36; i++) {
-      assertTrue(array.get(i));
-    }
-    assertFalse(array.get(36));
-  }
-
-  @Test
-  public void testClear() {
-    BitArray array = new BitArray(32);
-    for (int i = 0; i < 32; i++) {
-      array.set(i);
-    }
-    array.clear();
-    for (int i = 0; i < 32; i++) {
-      assertFalse(array.get(i));
-    }
-  }
-
-  @Test
-  public void testFlip() {
-    BitArray array = new BitArray(32);
-    assertFalse(array.get(5));
-    array.flip(5);
-    assertTrue(array.get(5));
-    array.flip(5);
-    assertFalse(array.get(5));
-  }
-
-  @Test
-  public void testGetArray() {
-    BitArray array = new BitArray(64);
-    array.set(0);
-    array.set(63);
-    int[] ints = array.getBitArray();
-    assertEquals(1, ints[0]);
-    assertEquals(Integer.MIN_VALUE, ints[1]);
-  }
-
-  @Test
-  public void testIsRange() {
-    BitArray array = new BitArray(64);
-    assertTrue(array.isRange(0, 64, false));
-    assertFalse(array.isRange(0, 64, true));
-    array.set(32);
-    assertTrue(array.isRange(32, 33, true));
-    array.set(31);
-    assertTrue(array.isRange(31, 33, true));
-    array.set(34);
-    assertFalse(array.isRange(31, 35, true));
-    for (int i = 0; i < 31; i++) {
-      array.set(i);
-    }
-    assertTrue(array.isRange(0, 33, true));
-    for (int i = 33; i < 64; i++) {
-      array.set(i);
-    }
-    assertTrue(array.isRange(0, 64, true));
-    assertFalse(array.isRange(0, 64, false));
-  }
-
-  @Test
-  public void reverseAlgorithmTest() {
-    int[] oldBits = {128, 256, 512, 6453324, 50934953};
-    for (int size = 1; size < 160; size++) {
-      int[] newBitsOriginal = reverseOriginal(oldBits.clone(), size);
-      BitArray newBitArray = new BitArray(oldBits.clone(), size);
-      newBitArray.reverse();
-      int[] newBitsNew = newBitArray.getBitArray();
-      assertTrue(arraysAreEqual(newBitsOriginal, newBitsNew, size / 32 + 1));
-    }
-  }
-
-  @Test
-  public void testClone() {
-    BitArray array = new BitArray(32);
-    array.clone().set(0);
-    assertFalse(array.get(0));
-  }
-
-  @Test
-  public void testEquals() {
-    BitArray a = new BitArray(32);
-    BitArray b = new BitArray(32);
-    assertEquals(a, b);
-    assertEquals(a.hashCode(), b.hashCode());
-    assertNotEquals(a, new BitArray(31));
-    a.set(16);
-    assertNotEquals(a, b);
-    assertNotEquals(a.hashCode(), b.hashCode());
-    b.set(16);
-    assertEquals(a, b);
-    assertEquals(a.hashCode(), b.hashCode());
-  }
-
-  private static int[] reverseOriginal(int[] oldBits, int size) {
-    int[] newBits = new int[oldBits.length];
-    for (int i = 0; i < size; i++) {
-      if (bitSet(oldBits, size - i - 1)) {
-        newBits[i / 32] |= 1 << (i & 0x1F);
-      }
-    }
-    return newBits;
-  }
-
-  private static boolean bitSet(int[] bits, int i) {
-    return (bits[i / 32] & (1 << (i & 0x1F))) != 0;
-  }
-
-  private static boolean arraysAreEqual(int[] left, int[] right, int size) {
-    for (int i = 0; i < size; i++) {
-      if (left[i] != right[i]) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-}
diff --git a/src/common/BitArrayTestCase.rs b/src/common/BitArrayTestCase.rs
new file mode 100644
index 0000000..862fa25
--- /dev/null
+++ b/src/common/BitArrayTestCase.rs
@@ -0,0 +1,281 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// package com.google.zxing.common;
+
+// import org.junit.Assert;
+// import org.junit.Test;
+
+// import java.util.Random;
+
+// /**
+//  * @author Sean Owen
+//  */
+// public final class BitArrayTestCase extends Assert {
+
+use super::BitArray;
+use rand::Rng;
+
+  #[test]
+  fn test_get_set() {
+    let mut array =  BitArray::with_size(33);
+    for i in 0..33 {
+    // for (int i = 0; i < 33; i++) {
+      assert!(!array.get(i));
+      array.set(i);
+      assert!(array.get(i));
+    }
+  }
+
+  #[test]
+  fn test_get_next_set1() {
+    let array =  BitArray::with_size(32);
+    for i in 0..array.getSize() {
+    // for (int i = 0; i < array.getSize(); i++) {
+      assert_eq!( 32, array.getNextSet(i), "{}", i);
+    }
+    let array =  BitArray::with_size(33);
+    for i in 0..array.getSize(){
+    // for (int i = 0; i < array.getSize(); i++) {
+      assert_eq!( 33, array.getNextSet(i), "{}", i);
+    }
+  }
+  
+  #[test]
+  fn test_get_next_set2() {
+    let mut array =  BitArray::with_size(33);    
+    array.set(31);
+    for i in 0 ..array.getSize() {
+    // for (int i = 0; i < array.getSize(); i++) {
+      assert_eq!(if i <= 31 { 31} else {33}, array.getNextSet(i), "{}", i);
+    }
+    array =  BitArray::with_size(33);
+    array.set(32);
+    for i in 0 ..array.getSize(){
+    // for (int i = 0; i < array.getSize(); i++) {
+      assert_eq!(32, array.getNextSet(i), "{}", i);
+    }
+  }
+  
+  #[test]
+  fn test_get_next_set3() {
+    let mut array =  BitArray::with_size(63);    
+    array.set(31);
+    array.set(32);
+    for i in 0 .. array.getSize() {
+    // for (int i = 0; i < array.getSize(); i++) {
+      let expected;
+      if i <= 31 {
+        expected = 31;
+      } else if i == 32 {
+        expected = 32;
+      } else {
+        expected = 63;
+      }
+      assert_eq!(expected, array.getNextSet(i), "{}", i);
+    }
+  }
+
+  #[test]
+  fn test_get_next_set4() {
+    let mut array =  BitArray::with_size(63);
+    array.set(33);
+    array.set(40);
+    for i in 0..array.getSize(){
+    // for (int i = 0; i < array.getSize(); i++) {
+      let expected;
+      if i <= 33 {
+        expected = 33;
+      } else if i <= 40 {
+        expected = 40;
+      } else {
+        expected = 63;
+      }
+      assert_eq!( expected, array.getNextSet(i), "{}", i);
+    }
+  }
+  
+  #[test]
+  fn test_get_next_set5() {
+    let mut r = rand::thread_rng();
+    for i in 0 .. 10 {
+    // for (int i = 0; i < 10; i++) {
+      let  mut array =  BitArray::with_size(1 + r.gen_range(0..100));
+      let numSet = r.gen_range(0..20);
+      for j in 0..numSet {
+      // for (int j = 0; j < numSet; j++) {
+        array.set(r.gen_range(0..array.getSize()));
+      }
+      let numQueries = r.gen_range(0..20);
+      for j in 0..numQueries {
+      // for (int j = 0; j < numQueries; j++) {
+        let query = r.gen_range(0..array.getSize());
+        let mut expected = query;
+        while expected < array.getSize() && !array.get(expected) {
+          expected+=1;
+        }
+        let actual = array.getNextSet(query);
+        assert_eq!(expected, actual);
+      }
+    }
+  }
+
+
+  #[test]
+  fn test_set_bulk() {
+    let mut array =  BitArray::with_size(64);
+    array.setBulk(32, 0xFFFF0000);
+    for i in 0..48 {
+    // for (int i = 0; i < 48; i++) {
+      assert!(!array.get(i));
+    }
+    for i in 48..64 {
+    // for (int i = 48; i < 64; i++) {
+      assert!(array.get(i));
+    }
+  }
+
+  #[test]
+  fn test_set_range() {
+    let mut array =  BitArray::with_size(64);
+    array.setRange(28, 36).unwrap();
+    assert!(!array.get(27));
+    for i in 28..36 {
+    // for (int i = 28; i < 36; i++) {
+      assert!(array.get(i));
+    }
+    assert!(!array.get(36));
+  }
+
+  #[test]
+  fn test_clear() {
+    let mut array =  BitArray::with_size(32);
+    for i in 0..32 {
+    // for (int i = 0; i < 32; i++) {
+      array.set(i);
+    }
+    array.clear();
+    for i in 0..32 {
+    // for (int i = 0; i < 32; i++) {
+      assert!(!array.get(i));
+    }
+  }
+
+  #[test]
+  fn test_flip() {
+    let mut array =  BitArray::with_size(32);
+    assert!(!array.get(5));
+    array.flip(5);
+    assert!(array.get(5));
+    array.flip(5);
+    assert!(!array.get(5));
+  }
+
+  #[test]
+  fn test_get_array() {
+    let mut array =  BitArray::with_size(64);
+    array.set(0);
+    array.set(63);
+    let ints = array.getBitArray();
+    assert_eq!(1, ints[0]);
+    assert_eq!(0b10_00_00_00_00_00_00_00_00_00_00_00_00_00_00_00, ints[1]);
+  }
+
+  #[test]
+  fn test_is_range() {
+    let mut array =  BitArray::with_size(64);
+    assert!(array.isRange(0, 64, false).unwrap());
+    assert!(!array.isRange(0, 64, true).unwrap());
+    array.set(32);
+    assert!(array.isRange(32, 33, true).unwrap());
+    array.set(31);
+    assert!(array.isRange(31, 33, true).unwrap());
+    array.set(34);
+    assert!(!array.isRange(31, 35, true).unwrap());
+    for i in 0..31 {
+    // for (int i = 0; i < 31; i++) {
+      array.set(i);
+    }
+    assert!(array.isRange(0, 33, true).unwrap());
+    for i in 33..64 {
+    // for (int i = 33; i < 64; i++) {
+      array.set(i);
+    }
+    assert!(array.isRange(0, 64, true).unwrap());
+    assert!(!array.isRange(0, 64, false).unwrap());
+  }
+
+  #[test]
+  fn reverse_algorithm_test() {
+    let oldBits:Vec<u32> = vec![128, 256, 512, 6453324, 50934953];
+    for size in 1..160 {
+    // for (int size = 1; size < 160; size++) {
+      let newBitsOriginal = reverse_original(&oldBits.clone(), size);
+      let mut newBitArray = BitArray::with_initial_values(oldBits.clone(), size);
+      newBitArray.reverse();
+      let newBitsNew = newBitArray.getBitArray();
+      assert!(arrays_are_equal(&newBitsOriginal, &newBitsNew, size / 32 + 1));
+    }
+  }
+
+  #[test]
+  fn test_clone() {
+    let array =  BitArray::with_size(32);
+    array.clone().set(0);
+    assert!(!array.get(0));
+  }
+
+  #[test]
+  fn test_equals() {
+    let mut a =  BitArray::with_size(32);
+    let mut b =  BitArray::with_size(32);
+    assert_eq!(a, b);
+    // assert_eq!(a.hash(), b.hash());
+    assert_ne!(a, BitArray::with_size(31));
+    a.set(16);
+    assert_ne!(a, b);
+    // assert_ne!(a.hash(), b.hash());
+    b.set(16);
+    assert_eq!(a, b);
+    // assert_eq!(a.hash(), b.hash());
+  }
+
+  fn reverse_original( oldBits:&[u32],  size:usize) -> Vec<u32>{
+    let mut newBits = vec![0;oldBits.len()];
+    for i in 0..size {
+    // for (int i = 0; i < size; i++) {
+      if bit_set(oldBits, size - i - 1) {
+        newBits[i / 32 as usize] |= 1 << (i & 0x1F);
+      }
+    }
+    return newBits;
+  }
+
+  fn bit_set( bits:&[u32],  i:usize) -> bool{
+    return (bits[i / 32] & (1 << (i & 0x1F))) != 0;
+  }
+
+  fn arrays_are_equal( left :&[u32],  right:&[u32],  size:usize) -> bool{
+    for i in 0..size {
+    // for (int i = 0; i < size; i++) {
+      if left[i] != right[i] {
+        return false;
+      }
+    }
+    return true;
+  }
+
+// }
diff --git a/src/common/mod.rs b/src/common/mod.rs
index db6fbae..2540f8b 100644
--- a/src/common/mod.rs
+++ b/src/common/mod.rs
@@ -14,6 +14,8 @@ use encoding::Encoding;
 #[cfg(test)]
 mod StringUtilsTestCase;
 
+#[cfg(test)]
+mod BitArrayTestCase;
 /*
  * Copyright (C) 2010 ZXing authors
  *
@@ -393,7 +395,7 @@ impl BitArray {
             return self.size;
         }
         let mut bitsOffset = from / 32;
-        let mut currentBits = self.bits[bitsOffset] as i32;
+        let mut currentBits = self.bits[bitsOffset] as i64;
         // mask off lesser bits first
         currentBits &= -(1 << (from & 0x1F));
         while currentBits == 0 {
@@ -401,7 +403,7 @@ impl BitArray {
             if bitsOffset == self.bits.len() {
                 return self.size;
             }
-            currentBits = self.bits[bitsOffset] as i32;
+            currentBits = self.bits[bitsOffset] as i64;
         }
         let result = (bitsOffset * 32) + currentBits.trailing_zeros() as usize;
         cmp::min(result, self.size)
@@ -466,8 +468,8 @@ impl BitArray {
             let firstBit = if i > firstInt { 0 } else { start & 0x1F };
             let lastBit = if i < lastInt { 31 } else { end & 0x1F };
             // Ones from firstBit to lastBit, inclusive
-            let mask = (2 << lastBit) - (1 << firstBit);
-            self.bits[i] |= mask;
+            let mask:u64 = (2 << lastBit) - (1 << firstBit);
+            self.bits[i] |= mask as u32;
         }
         Ok(())
     }
@@ -515,11 +517,11 @@ impl BitArray {
             let firstBit = if i > firstInt { 0 } else { start & 0x1F };
             let lastBit = if i < lastInt { 31 } else { end & 0x1F };
             // Ones from firstBit to lastBit, inclusive
-            let mask = (2 << lastBit) - (1 << firstBit);
+            let mask:u64 = (2 << lastBit) - (1 << firstBit);
 
             // Return false if we're looking for 1s and the masked bits[i] isn't all 1s (that is,
             // equals the mask, or we're looking for 0s and the masked portion is not all 0s
-            if (self.bits[i] & mask) != (if value { mask } else { 0 }) {
+            if (self.bits[i] & mask as u32) != (if value { mask as u32 } else { 0 }) {
                 return Ok(false);
             }
         }