From 6f9c89f8978b335f3fb8662e5758a06a36bf01cb Mon Sep 17 00:00:00 2001 From: Henry Schimke Date: Tue, 30 Aug 2022 16:16:53 -0500 Subject: [PATCH] bitsource tests pass --- src/common/BitSource.java | 0 src/common/BitSourceTestCase.java | 48 -------------------------- src/common/BitSourceTestCase.rs | 50 +++++++++++++++++++++++++++ src/common/mod.rs | 57 ++++++++++++++++--------------- 4 files changed, 80 insertions(+), 75 deletions(-) delete mode 100755 src/common/BitSource.java delete mode 100644 src/common/BitSourceTestCase.java create mode 100644 src/common/BitSourceTestCase.rs diff --git a/src/common/BitSource.java b/src/common/BitSource.java deleted file mode 100755 index e69de29..0000000 diff --git a/src/common/BitSourceTestCase.java b/src/common/BitSourceTestCase.java deleted file mode 100644 index 1ff714a..0000000 --- a/src/common/BitSourceTestCase.java +++ /dev/null @@ -1,48 +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; - -/** - * @author Sean Owen - */ -public final class BitSourceTestCase extends Assert { - - @Test - public void testSource() { - byte[] bytes = {(byte) 1, (byte) 2, (byte) 3, (byte) 4, (byte) 5}; - BitSource source = new BitSource(bytes); - assertEquals(40, source.available()); - assertEquals(0, source.readBits(1)); - assertEquals(39, source.available()); - assertEquals(0, source.readBits(6)); - assertEquals(33, source.available()); - assertEquals(1, source.readBits(1)); - assertEquals(32, source.available()); - assertEquals(2, source.readBits(8)); - assertEquals(24, source.available()); - assertEquals(12, source.readBits(10)); - assertEquals(14, source.available()); - assertEquals(16, source.readBits(8)); - assertEquals(6, source.available()); - assertEquals(5, source.readBits(6)); - assertEquals(0, source.available()); - } - -} \ No newline at end of file diff --git a/src/common/BitSourceTestCase.rs b/src/common/BitSourceTestCase.rs new file mode 100644 index 0000000..00a1727 --- /dev/null +++ b/src/common/BitSourceTestCase.rs @@ -0,0 +1,50 @@ +/* + * 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; + +// /** +// * @author Sean Owen +// */ +// public final class BitSourceTestCase extends Assert { + +use super::BitSource; + + #[test] + fn test_source() { + let bytes:Vec = vec![ 1, 2, 3, 4, 5]; + let mut source = BitSource::new(bytes); + assert_eq!(40, source.available()); + assert_eq!(0, source.readBits(1).unwrap()); + assert_eq!(39, source.available()); + assert_eq!(0, source.readBits(6).unwrap()); + assert_eq!(33, source.available()); + assert_eq!(1, source.readBits(1).unwrap()); + assert_eq!(32, source.available()); + assert_eq!(2, source.readBits(8).unwrap()); + assert_eq!(24, source.available()); + assert_eq!(12, source.readBits(10).unwrap()); + assert_eq!(14, source.available()); + assert_eq!(16, source.readBits(8).unwrap()); + assert_eq!(6, source.available()); + assert_eq!(5, source.readBits(6).unwrap()); + assert_eq!(0, source.available()); + } + +// } \ No newline at end of file diff --git a/src/common/mod.rs b/src/common/mod.rs index bbe035f..cf3c716 100644 --- a/src/common/mod.rs +++ b/src/common/mod.rs @@ -19,6 +19,9 @@ mod BitArrayTestCase; #[cfg(test)] mod BitMatrixTestCase; + +#[cfg(test)] +mod BitSourceTestCase; /* * Copyright (C) 2010 ZXing authors * @@ -1492,8 +1495,8 @@ pub trait ECIInput { */ pub struct BitSource { bytes: Vec, - byteOffset: usize, - bitOffset: usize, + byte_offset: usize, + bit_offset: usize, } impl BitSource { @@ -1504,8 +1507,8 @@ impl BitSource { pub fn new(bytes: Vec) -> Self { Self { bytes, - byteOffset: 0, - bitOffset: 0, + byte_offset: 0, + bit_offset: 0, } } @@ -1513,14 +1516,14 @@ impl BitSource { * @return index of next bit in current byte which would be read by the next call to {@link #readBits(int)}. */ pub fn getBitOffset(&self) -> usize { - return self.bitOffset; + return self.bit_offset; } /** * @return index of next byte in input byte array which would be read by the next call to {@link #readBits(int)}. */ pub fn getByteOffset(&self) -> usize { - return self.byteOffset; + return self.byte_offset; } /** @@ -1536,38 +1539,38 @@ impl BitSource { let mut result = 0; - let mut numBits = numBits; + let mut num_bits = numBits; // First, read remainder from current byte - if self.bitOffset > 0 { - let bitsLeft = 8 - self.bitOffset; - let toRead = cmp::min(numBits, bitsLeft); + if self.bit_offset > 0 { + let bitsLeft = 8 - self.bit_offset; + let toRead = cmp::min(num_bits, bitsLeft); let bitsToNotRead = bitsLeft - toRead; let mask = (0xFF >> (8 - toRead)) << bitsToNotRead; - result = (self.bytes[self.byteOffset] & mask) >> bitsToNotRead; - numBits -= toRead; - self.bitOffset += toRead; - if self.bitOffset == 8 { - self.bitOffset = 0; - self.byteOffset += 1; + result = (self.bytes[self.byte_offset] & mask) >> bitsToNotRead; + num_bits -= toRead; + self.bit_offset += toRead; + if self.bit_offset == 8 { + self.bit_offset = 0; + self.byte_offset += 1; } } // Next read whole bytes - if numBits > 0 { - while numBits >= 8 { - result = (result << 8) | (self.bytes[self.byteOffset] & 0xFF); - self.byteOffset += 1; - numBits -= 8; + if num_bits > 0 { + while num_bits >= 8 { + result = ((result as u16) << 8) as u8 | (self.bytes[self.byte_offset] & 0xFF); + self.byte_offset += 1; + num_bits -= 8; } // Finally read a partial byte - if numBits > 0 { - let bitsToNotRead = 8 - numBits; - let mask = (0xFF >> bitsToNotRead) << bitsToNotRead; + if num_bits > 0 { + let bits_to_not_read = 8 - num_bits; + let mask = (0xFF >> bits_to_not_read) << bits_to_not_read; result = - (result << numBits) | ((self.bytes[self.byteOffset] & mask) >> bitsToNotRead); - self.bitOffset += numBits; + (result << num_bits) | ((self.bytes[self.byte_offset] & mask) >> bits_to_not_read); + self.bit_offset += num_bits; } } @@ -1578,6 +1581,6 @@ impl BitSource { * @return number of bits that can be read successfully */ pub fn available(&self) -> usize { - return 8 * (self.bytes.len() - self.byteOffset) - self.bitOffset; + return 8 * (self.bytes.len() - self.byte_offset) - self.bit_offset; } }