Add clear method and fix issue with Integer/Long max and min value

Author: devnied

README.md

@@ -4,7 +4,7 @@ Bit-lib4j [![Build Status](https://travis-ci.org/devnied/Bit-lib4j.png?branch=ma
 Bit-Lib4j is an useful library to handle bytes or bits in Java.<br/>
 With this library you can read/write data in a byte array with a custom size for Java primitive types.
 
-<b>Current version : 1.4.11</b> 
+<b>Current version : 1.4.12</b> 
 
 ##Simple API
 
@@ -44,7 +44,7 @@ More documentation into the [wiki](https://github.com/devnied/Bit-lib4j/wiki)
 <dependency>
   <groupId>com.github.devnied</groupId>
   <artifactId>bit-lib4j</artifactId>
-  <version>1.4.11</version>
+  <version>1.4.12</version>
 </dependency>
 ```
 

src/main/java/fr/devnied/bitlib/BitUtils.java

@@ -4,6 +4,7 @@
 import java.nio.charset.Charset;
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
+import java.util.Arrays;
 import java.util.Date;
 
 import org.slf4j.Logger;
@@ -150,8 +151,10 @@ public boolean getNextBoolean() {
 	}
 
 	/**
-	 * Method used to get the next byte and shift read data to the beginning of the array.<br>
-	 * (Ex 00110000b if we start read 2 bit at index 2 the data returned will be 11000000b)
+	 * Method used to get the next byte and shift read data to the beginning of
+	 * the array.<br>
+	 * (Ex 00110000b if we start read 2 bit at index 2 the data returned will be
+	 * 11000000b)
 	 * 
 	 * @param pSize
 	 *            the size in bit to read
@@ -167,10 +170,13 @@ public byte[] getNextByte(final int pSize) {
 	 * @param pSize
 	 *            the size in bit to read
 	 * @param pShift
-	 *            boolean to indicate if the data read will be shift to the left.<br>
+	 *            boolean to indicate if the data read will be shift to the
+	 *            left.<br>
 	 *            <ul>
-	 *            <li>if true : (Ex 10110000b if we start read 2 bit at index 2 the returned data will be 11000000b)</li>
-	 *            <li>if false : (Ex 10110000b if we start read 2 bit at index 2 the returned data will be 00110000b)</li>
+	 *            <li>if true : (Ex 10110000b if we start read 2 bit at index 2
+	 *            the returned data will be 11000000b)</li>
+	 *            <li>if false : (Ex 10110000b if we start read 2 bit at index 2
+	 *            the returned data will be 00110000b)</li>
 	 *            </ul>
 	 * @return a byte array
 	 */
@@ -267,7 +273,6 @@ public String getNextHexaString(final int pSize) {
 		return BytesUtils.bytesToStringNoSpace(getNextByte(pSize, true));
 	}
 
-
 	/**
 	 * This method is used to get an long with the specified size
 	 * 
@@ -278,38 +283,38 @@ public String getNextHexaString(final int pSize) {
 	 * @return an long
 	 */
 	public long getNextLong(final int pLength) {
-			// allocate Size of Integer
-			ByteBuffer buffer = ByteBuffer.allocate(BYTE_SIZE * 2);
-			// final value
-			long finalValue = 0;
-			// Incremental value
-			long currentValue = 0;
-			// Size to read
-			int readSize = pLength;
-			// length max of the index
-			int max = currentBitIndex + pLength;
-			while (currentBitIndex < max) {
-				int mod = currentBitIndex % BYTE_SIZE;
-				// apply the mask to the selected byte
-				currentValue = byteTab[currentBitIndex / BYTE_SIZE] & getMask(mod, readSize) & DEFAULT_VALUE;
-				// Shift right the read value
-				int dec = Math.max(BYTE_SIZE - (mod + readSize), 0);
-				currentValue = (currentValue & DEFAULT_VALUE) >>> dec & DEFAULT_VALUE;
-				// Shift left the previously read value and add the current value
-				finalValue = finalValue << Math.min(readSize, BYTE_SIZE) | currentValue;
-				// calculate read value size
-				int val = BYTE_SIZE - mod;
-				// Decrease the size left
-				readSize = readSize - val;
-				currentBitIndex = Math.min(currentBitIndex + val, max);
-			}
-			buffer.putLong(finalValue);
-			// reset the current bytebuffer index to 0
-			buffer.rewind();
-			// return integer
-			return buffer.getLong();
+		// allocate Size of Integer
+		ByteBuffer buffer = ByteBuffer.allocate(BYTE_SIZE * 2);
+		// final value
+		long finalValue = 0;
+		// Incremental value
+		long currentValue = 0;
+		// Size to read
+		int readSize = pLength;
+		// length max of the index
+		int max = currentBitIndex + pLength;
+		while (currentBitIndex < max) {
+			int mod = currentBitIndex % BYTE_SIZE;
+			// apply the mask to the selected byte
+			currentValue = byteTab[currentBitIndex / BYTE_SIZE] & getMask(mod, readSize) & DEFAULT_VALUE;
+			// Shift right the read value
+			int dec = Math.max(BYTE_SIZE - (mod + readSize), 0);
+			currentValue = (currentValue & DEFAULT_VALUE) >>> dec & DEFAULT_VALUE;
+			// Shift left the previously read value and add the current value
+			finalValue = finalValue << Math.min(readSize, BYTE_SIZE) | currentValue;
+			// calculate read value size
+			int val = BYTE_SIZE - mod;
+			// Decrease the size left
+			readSize = readSize - val;
+			currentBitIndex = Math.min(currentBitIndex + val, max);
+		}
+		buffer.putLong(finalValue);
+		// reset the current bytebuffer index to 0
+		buffer.rewind();
+		// return integer
+		return buffer.getLong();
 	}
-	
+
 	/**
 	 * This method is used to get an integer with the specified size
 	 * 
@@ -324,7 +329,8 @@ public int getNextInteger(final int pLength) {
 	}
 
 	/**
-	 * This method is used to get the next String with the specified size with the charset ASCII
+	 * This method is used to get the next String with the specified size with
+	 * the charset ASCII
 	 * 
 	 * @param pSize
 	 *            the length of the string in bit
@@ -363,6 +369,14 @@ public void reset() {
 		setCurrentBitIndex(0);
 	}
 
+	/**
+	 * Method used to clear data and reset current bit index
+	 */
+	public void clear() {
+		Arrays.fill(byteTab, (byte) 0);
+		reset();
+	}
+
 	/**
 	 * Set to 0 the next N bits
 	 * 
@@ -423,7 +437,7 @@ public void setNextByte(final byte[] pValue, final int pLength) {
 	 * @param pLength
 	 *            the length of the data in bits
 	 * @param pPadBefore
-	 * 			  if true pad with 0
+	 *            if true pad with 0
 	 */
 	public void setNextByte(final byte[] pValue, final int pLength, final boolean pPadBefore) {
 		int totalSize = (int) Math.ceil(pLength / BYTE_SIZE_F);
@@ -510,14 +524,14 @@ public void setNextDate(final Date pValue, final String pPattern, final boolean
 	public void setNextHexaString(final String pValue, final int pLength) {
 		setNextByte(BytesUtils.fromString(pValue), pLength);
 	}
-	
+
 	/**
 	 * Add Long to the current position with the specified size
 	 * 
 	 * Be careful with java long bit sign
 	 * 
 	 * @param pValue
-	 * 			the value to set
+	 *            the value to set
 	 * 
 	 * @param pLength
 	 *            the length of the long
@@ -528,19 +542,25 @@ public void setNextLong(final long pValue, final int pLength) {
 			throw new IllegalArgumentException("Long overflow with length > 64");
 		}
 
-		setNextValue(pValue, pLength);
+		setNextValue(pValue, pLength, Long.SIZE - 1);
 	}
-	
+
 	/**
 	 * Add Value to the current position with the specified size
-	 * @param pValue value to add
-	 * @param pLength length of the value
+	 * 
+	 * @param pValue
+	 *            value to add
+	 * @param pLength
+	 *            length of the value
+	 * @param pMaxSize
+	 *            max size in bits
 	 */
-	protected void setNextValue(final long pValue, final int pLength){
+	protected void setNextValue(final long pValue, final int pLength, final int pMaxSize) {
 		long value = pValue;
 		// Set to max value if pValue cannot be stored on pLength bits.
-		if (pValue >= 1 << pLength) {
-			value = (1 << pLength) - 1;
+		long bitMax = (long) Math.pow(2, Math.min(pLength, pMaxSize));
+		if (pValue > bitMax) {
+			value = bitMax - 1;
 		}
 		// size to wrote
 		int writeSize = pLength;
@@ -568,6 +588,9 @@ protected void setNextValue(final long pValue, final int pLength){
 	 * 
 	 * Be careful with java integer bit sign
 	 * 
+	 * @param pValue
+	 *            the value to set
+	 * 
 	 * @param pLength
 	 *            the length of the integer
 	 */
@@ -577,14 +600,17 @@ public void setNextInteger(final int pValue, final int pLength) {
 			throw new IllegalArgumentException("Integer overflow with length > 32");
 		}
 
-		setNextValue(pValue, pLength);
+		setNextValue(pValue, pLength, Integer.SIZE - 1);
 	}
 
 	/**
 	 * Method to write String
 	 * 
 	 * @param pValue
 	 *            the string to write
+	 * 
+	 * @param pLength
+	 *            the length of the integer
 	 */
 	public void setNextString(final String pValue, final int pLength) {
 		setNextString(pValue, pLength, true);

src/test/java/fr/devnied/bitlib/BitUtilsTest.java

@@ -291,23 +291,47 @@ public void testSetInteger() {
 		Assertions.assertThat(bit.getNextInteger(1)).isEqualTo(0);
 		Assertions.assertThat(bit.getNextInteger(1)).isEqualTo(1);
 
-		bit.reset();
+		bit.clear();
 		try {
 			bit.setNextInteger(500, 33);
 			Assert.fail();
 		} catch (IllegalArgumentException iae) {
 		}
+		bit.clear();
+		bit.setNextInteger(127, 5);
+		bit.reset();
+		Assertions.assertThat(bit.getNextInteger(5)).isEqualTo(31);
 	}
 
 	@Test
-	public void testMaxMinValue(){
+	public void testOverflowValueInSize() {
 		BitUtils bit = new BitUtils(64);
-		bit.setNextHexaString("FFFFFFFF", 32);
+		bit.setNextInteger(Integer.MAX_VALUE, 3);
+		bit.reset();
+		Assertions.assertThat(bit.getNextInteger(3)).isEqualTo(7);
+		
+		bit.clear();
+		bit.setNextLong(Long.MAX_VALUE, 40);
 		bit.reset();
-		Assertions.assertThat(bit.getNextInteger(32)).isEqualTo(-1);
+		Assertions.assertThat(bit.getNextLong(40)).isEqualTo(1099511627775L);
 	}
-
 
+	@Test
+	public void testMaxMinValueInteger() {
+		BitUtils bit = new BitUtils(64);
+		bit.setNextInteger(Integer.MIN_VALUE, 32);
+		bit.reset();
+		Assertions.assertThat(bit.getNextHexaString(32)).isEqualTo("80000000");
+		bit.reset();
+		Assertions.assertThat(bit.getNextInteger(32)).isEqualTo(Integer.MIN_VALUE);
+		
+		bit.clear();
+		bit.setNextInteger(Integer.MAX_VALUE, 32);
+		bit.reset();
+		Assertions.assertThat(bit.getNextHexaString(32)).isEqualTo("7FFFFFFF");
+		bit.reset();
+		Assertions.assertThat(bit.getNextInteger(32)).isEqualTo(Integer.MAX_VALUE);
+	}
 
 	/**
 	 * Test the method to set an long
@@ -380,6 +404,23 @@ public void testSetLong() {
 		}
 	}
 
+	@Test
+	public void testMaxMinValueLong() {
+		BitUtils bit = new BitUtils(64);
+		bit.setNextLong(Long.MIN_VALUE, 64);
+		bit.reset();
+		Assertions.assertThat(bit.getNextHexaString(64)).isEqualTo("8000000000000000");
+		bit.reset();
+		Assertions.assertThat(bit.getNextLong(64)).isEqualTo(Long.MIN_VALUE);
+		
+		bit.clear();
+		bit.setNextLong(Long.MAX_VALUE, 64);
+		bit.reset();
+		Assertions.assertThat(bit.getNextHexaString(64)).isEqualTo("7FFFFFFFFFFFFFFF");
+		bit.reset();
+		Assertions.assertThat(bit.getNextLong(64)).isEqualTo(Long.MAX_VALUE);
+	}
+	
 	@Test
 	public void testLongMaxMinValue(){
 		BitUtils bit = new BitUtils(64);