mirror of
https://github.com/starovoid/rxing.git
synced 2026-07-26 04:12:34 +00:00
bitarray passes
This commit is contained in:
Henry Schimke
@@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
281
src/common/BitArrayTestCase.rs
Normal file
281
src/common/BitArrayTestCase.rs
Normal file
@@ -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;
|
||||
}
|
||||
|
||||
// }
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user