Adding test cases for common operations on bits

Author: Deepak Malik

src/com/deepak/algorithms/BitManipulation/CommonOperations.java

@@ -10,7 +10,7 @@
  * @author Deepak
  */
 public class CommonOperations {
-	
+
 	/**
 	 * Returns the bit present at the position, either true(1) or false(0)
 	 * 
@@ -22,19 +22,6 @@ public static boolean getBit(int num, int i) {
 		return ((num & (1 << i)) != 0);
 	}
 
-	/**
-	 * Returns the number after updating the bit to either 0 or 1
-	 * 
-	 * @param num - Number
-	 * @param i - Position, for which bit has to be updated
-	 * @param v - Value of new bit
-	 * @return {@link int} - New updated number
-	 */
-	public static int updateBit(int num, int i, int v) {
-		int mask = ~(1 << i);
-		return (num & mask) | (v << i);
-	}
-	
 	/**
 	 * Returns the number after setting the bit to 1 at given position
 	 * If bit at that position is already 1, then it returns the same number
@@ -60,87 +47,63 @@ public static int clearBit(int num, int i) {
 		return num & mask;
 	}
 
-	public static int clearBitsMSBthroughI(int num, int i) {
+	/**
+	 * Returns the number after updating the bit to either 0 or 1
+	 * 
+	 * @param num - Number
+	 * @param i - Position, for which bit has to be updated
+	 * @param v - Value of new bit
+	 * @return {@link int} - New updated number
+	 */
+	public static int updateBit(int num, int i, int v) {
+		int mask = ~(1 << i);
+		return (num & mask) | (v << i);
+	}
+
+	/**
+	 * Method to clear most significant bits through I
+	 * 
+	 * @param num - Number
+	 * @param i - Position of the bit
+	 * @return {@link int} - New updated number
+	 */
+	public static int clearMSBthroughI(int num, int i) {
 		int mask = (1 << i) - 1;
 		return num & mask;
 	}
 
-	public static int clearBitsIthrough0(int num, int i) {
+	/**
+	 * Method to clear least significant bits through I
+	 *  
+	 * @param num - Number
+	 * @param i - Position of the bit
+	 * @return {@link int} - New updated number
+	 */
+	public static int clearLSBthroughI(int num, int i) {
 		int mask = ~((1 << (i + 1)) - 1);
 		return num & mask;
 	}
 
 	/**
-	 * Prints the full binary number in String format
+	 * Prints the integer number into binary string format
 	 * 
-	 * @param num - Number
+	 * @param num
+	 * @return {@link String}
 	 */
-	private static void toFullBinaryString(int num) {
+	public static String toFullBinaryString(int num) {
+		StringBuilder builder = new StringBuilder();
 		/* Create a display mask on the last bit */
 		int displayMask = 1 << 7;
 		/* Loop through all the bits and print accordingly */
 		for (int bit = 1; bit <= 8; bit++) {
-			System.out.print((num & displayMask) == 0 ? '0' : '1');
+			builder.append((num & displayMask) == 0 ? '0' : '1');
 			num <<= 1;
 			/* Create space after 4 bits */
 			if ((bit % 4) == 0) {
-				System.out.print(' ');
-			}
-		}
-	}
-
-	/**
-	 * Dealing with 8 bit representation to make it simple
-	 * @param args
-	 */
-	// TODO : Clean this up
-	public static void main(String[] args) {
-		int number = 21;
-		System.out.println("Testing with number: " + number);
-		toFullBinaryString(number);
-		
-		/* Get bit */
-		System.out.println();
-		System.out.println("\nGet Bit (Original)");
-		for (int i = 7; i >= 0; i--) {
-			int res = getBit(number, i) ? 1 : 0;
-			System.out.print(res);
-			if ((i % 4) == 0) {
-				System.out.print(' ');
+				builder.append(' ');
 			}
 		}
-		
-		/* Set bit */
-		System.out.println("\n\nSetting Bit at position 3");
-		int res1 = setBit(number, 3);
-		toFullBinaryString(res1);
-
-		/* Update Bit */
-		System.out.println("\n\nUpdating Bit at position 2 with 0");
-		int result = updateBit(number, 2, 0);
-		toFullBinaryString(result);
-		
-		/* Clear Bit */
-		System.out.println("\n\nClearing Bit at position 0");	
-		int clearedBitResult = clearBit(number, 0);
-		toFullBinaryString(clearedBitResult);
-		
-		/**/
-		int number1 = 255;
-		System.out.println("\n\nBinary representation of " + number1);
-		toFullBinaryString(number1);
-		System.out.println("\nClear bits MSB through 4");	
-		int num3 = clearBitsMSBthroughI(number1, 4);
-		toFullBinaryString(num3);
-		
-			
-		int number2 = 255;
-		System.out.println("\n\nBinary representation of " + number2);
-		toFullBinaryString(number2);
-		System.out.println("\nClear bits 3 through 0");
-		int num4 = clearBitsIthrough0(number2, 3);
-		toFullBinaryString(num4);
-		
+		return builder.toString().trim();
 	}
 
 }

test/com/deepak/algorithms/BitManipulation/CommonOperations_Test.java

@@ -0,0 +1,99 @@
+/**
+ * Algorithms-in-Java
+ * CommonOperations.java
+ */
+package com.deepak.algorithms.BitManipulation;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Test cases for common operations on bits
+ * 
+ * @author Deepak
+ */
+public class CommonOperations_Test {
+
+	/* Initialize variables */
+	int eightBitNumber;
+	int secondNumber;
+
+	/* Setup test cases */
+	@Before
+	public void setup() {
+		eightBitNumber = 21;
+		secondNumber = 255;
+	}
+
+	/**
+	 * Test case to check get bit operation
+	 */
+	@Test
+	public void testGetBitOperation() {
+		Assert.assertEquals(CommonOperations.toFullBinaryString(eightBitNumber), "0001 0101");
+		Assert.assertTrue(CommonOperations.getBit(21, 2));
+		Assert.assertFalse(CommonOperations.getBit(21, 5));
+	}
+
+	/**
+	 * Test case to check set bit operation
+	 */
+	@Test
+	public void testSetBitOperation() {
+		Assert.assertEquals(CommonOperations.toFullBinaryString(eightBitNumber), "0001 0101");
+		/* It remains the same number, since bit at 2nd position is already 1 */
+		Assert.assertEquals(CommonOperations.setBit(21, 2), 21);
+		/* Number becomes 29 once we flip the bit at position three */
+		Assert.assertEquals(CommonOperations.setBit(21, 3), 29);
+	}
+
+	/**
+	 * Test case to check clear bit operation
+	 */
+	@Test
+	public void testClearBitOperation() {
+		Assert.assertEquals(CommonOperations.toFullBinaryString(eightBitNumber), "0001 0101");
+		/* It remains the same number, since bit at 3rd position is already 1 */
+		Assert.assertEquals(CommonOperations.clearBit(21, 3), 21);
+		/* Number becomes 17 once we flip the bit to 0 at position 2 */
+		Assert.assertEquals(CommonOperations.clearBit(21, 2), 17);
+	}
+
+	/**
+	 * Test case to check update bit operation
+	 */
+	@Test
+	public void testUpdateBitOperation() {
+		Assert.assertEquals(CommonOperations.toFullBinaryString(eightBitNumber), "0001 0101");
+		/* It remains the same, since at 1st position, it's already 0 */
+		Assert.assertEquals(CommonOperations.updateBit(21, 0, 1), 21);
+		/* Number became 20 once we flip the bit at 0th position to 0 */
+		Assert.assertEquals(CommonOperations.updateBit(21, 0, 0), 20);
+		/* Number became 29 once we flip the bit at 3rd position to 1 */
+		Assert.assertEquals(CommonOperations.updateBit(21, 3, 1), 29);
+	}
+
+	/**
+	 * Test case to clear most significant bits through I
+	 * NOTE : Count starts from 1 i.e 4 Bits means total 4 bits
+	 */
+	@Test
+	public void testClearMSBThroughI() {
+		Assert.assertEquals(CommonOperations.toFullBinaryString(secondNumber), "1111 1111");
+		Assert.assertEquals(CommonOperations.toFullBinaryString(CommonOperations.clearMSBthroughI(255, 4)), "0000 1111");
+		Assert.assertEquals(CommonOperations.clearMSBthroughI(255, 4), 15);
+	}
+
+	/**
+	 * Test case to clear least significant bits through I
+	 * NOTE : Count starts from 0 i.e 4 means total of 5 bits
+	 */
+	@Test
+	public void testClearLSBThroughI() {
+		Assert.assertEquals(CommonOperations.toFullBinaryString(secondNumber), "1111 1111");
+		Assert.assertEquals(CommonOperations.toFullBinaryString(CommonOperations.clearLSBthroughI(255, 3)), "1111 0000");
+		Assert.assertEquals(CommonOperations.clearLSBthroughI(255, 4), 224);
+	}
+
+}