Code Review Binary ←→ Decimal Conversion.

[praveen kumaar]

The problem is from the book Think like a programmer by V. Anton Spraul.it states:

If you’ve learned about binary numbers and how to convert from decimal
to binary and the reverse, try writing programs to do those conversions with
unlimited length numbers (but you can assume the numbers are small
enough to be stored in a standard C++ int).

C++ is used in the book,that's why he called C++ int.
Here is my code below:

public class DecimalBinaryConverter {
	private int number;

    private String binary;

	public static void main(String...args) {
		DecimalBinaryConverter decConverter = new DecimalBinaryConverter("10000000000000000000000000000000");
		DecimalBinaryConverter binConverter = new DecimalBinaryConverter(-2147483648);
		System.out.println(decConverter.binToDecimal());
		System.out.println(binConverter.decToBinaryString());
	}

	private static void ensureLengthOf(StringBuilder binaryString) {
		while (binaryString.length() != 32) {
			binaryString.append('0');
		}
	}

	private static void flipBinaryString(StringBuilder binaryString) {
		for (int i = 0; i < binaryString.length(); i++) {
			binaryString.setCharAt(i,flipBit(binaryString.charAt(i)));
		}
	}

	private static char flipBit(char i) {
		return i == '0' ? '1' : '0';
	}

	private static int twoRaisedToPow(int i) {
		return 1 << i;
	}

    // for decimal to binary conversion.
	public DecimalBinaryConverter(int number) {
		this.number = number;
	}

	// for binary to decimal conversion.
	public DecimalBinaryConverter(String binary) {
		this.binary = binary;
	}

	public String decToBinaryString() {
		StringBuilder binaryString = new StringBuilder(32);
		while (hasNextBit()) { // checks all the bits of number have been added to the binaryString and adds it if not below.
			binaryString.append(nextBit());
		}
		ensureLengthOf(binaryString); // since we are using int it will help me for maintaing total of 32 bits in string if it's less.
		return binaryString.reverse().toString(); // the reverse is done because when we add the bits to the string the order of the bits gets opposite.
	}

	public int binToDecimal() {
		StringBuilder binaryString = new StringBuilder(binary);
		if (binaryString.charAt(0) == '1') { // check for sign bit.
			flipBinaryString(binaryString);  // i had flipped bit because we have 2's complement of a number.
			// i already know the number is negative so i had find the unsigned number and used the -ve sign
			return number = -(unSignBinToDec(binaryString) + 1); // 2s complmnt = 1s complmnt + 1
		}
		else {
			return unSignBinToDec(binaryString); // for non-negative
		}
	}

	private boolean hasNextBit() {
		return number != 0;
	}

	private char nextBit() {
		boolean even = hasEvenNum();
		number >>>= 1; // number = number divided by 2
		return even ? '0' : '1';
   	}

    private boolean hasEvenNum() {
			return (number & 1) == 0;
	}

	private int unSignBinToDec(StringBuilder binaryString) {
		binaryString.reverse();
		for (int i = 0; i < binaryString.length(); i++) {
			if (binaryString.charAt(i) == '1') {
				number = number + twoRaisedToPow(i);
			}
		}
        return number
	}
}

please let me know if there should be some improvement.one thing i would like to ask if you will look in my code my some methods are static along with private.is it okay there.


Kind regards,
Praveen.

[Campbell Ritchie]

I would suggest that your // comments are too long, and they make the lines difficult to read and I suggest they shou‍ld be /* comments */ instead.
How many bits does a C++ int occupy? Are you sure it is always 32?
Why have you got so many static methods?
Main method: please put a space after the ellipsis operator.
In the ensure length method why are you appending 0s to the StringBuilder?
Why are you using magic numbers, e.g. 32, -2147483648?
What does the flip bit method do? Do you need it?
If you have one class which does the conversions, what is going to happen if you do this?

BinaryDecimalConverter converter =
      new BinaryDecimalConverter(1234567890);
System.out.println(converter.toDecimal());

I think there is a design error in your class. Can you see what I am worried about?

There are some confused bits further down. I am not convinced you have completely understood two's complement and its original definition. Remember the leftmost bit is not a sign bit the way the leftmost bit in a floating‑point number is a sign bit. It represents a value. Also, what do you understand by unsigned right‑shift?

I suggest you would do well to explain the algorithm you are using before you try writing any code. It is not difficult, but there are two algorithms, one for decimal to binary and the other for binary to decimal. They are a sort of mirror&#s2011;image of each other.

[Junilu Lacar]

As I was telling someone in a different thread, when an API is awkward, the implementation also tends to be awkward and convoluted.

Campbell hinted that your API is kind of awkward and unnatural and I feel the same way. There are many ways you could go with the design. One is to stick to an OO design. You may also choose to just go more functional and create a utility class with static methods.  A good set of unit tests to explore these different options would help you experiment and see what best fits your intent for the program(s).

I have to run out for a bit. More when I get back.

[Junilu Lacar]

If I take the code that's in your main() method and convert it to a unit test, I'd have something like this:

private DecimalBinaryConverter binConverter;
private DecimalBinaryConverter decConverter;

@Before
public void setup() {
    binConverter = new DecimalBinaryConverter("10000000000000000000000000000000");
    decConverter = new DecimalBinaryConverter(-2147483648);
}

@Test
public void convert_to_binary() {
    assert...  decConverter.binToDecimal(); // what do we expect here?
}
  
@Test
public void convert_to_decimal() {
    assert... binConverter.decToBinaryString(); // what do we expect here?
}

Already, this is raising a lot of questions in my mind about the API. See if you can separate yourself enough from the code and come at it as though you know nothing about this class. What questions come to your mind when you see that test code above? Is there a rational and logical answer you can give to those two questions? Does this test code tell a clear and coherent story about the capabilities of this converter class? Are there any classes in the standard library or a popular third-party library whose API seems like it could be a good model for this class' API?

[Junilu Lacar]

I like that you're posting your work for review because it also gives me a chance to examine my process for reviewing code.  I guess the first question I have in coming to a code review is, "Does this code make any sense?" If the answer is not immediately, "Yes!" then it's time to roll up sleeves and start picking at the nits in the design. Everyone comes to a code review with their own agenda. In my role as a technical leader of the development team, my agenda is to make the work shareable, malleable, and amenable to change by anyone and everyone on the team. My nose is tuned and primed to sniff out code and design smells and the first symptoms I look for are bad names, duplication, and lack of clarity and cohesiveness in the code. I've managed to tick off a bunch of those boxes while reading through your code.

Before I tell you what those smells are, however, it might be a worthwhile exercise for you to try and sniff out and identify some of those smells yourself.

[Junilu Lacar]

One thing that has helped me develop a nose for code smells and design smells over the years is the habit of reading lots of other people's code.

I have found that good code has a way of baiting the reader and making them curious. Good code rewards a reader's curiosity by giving them more reasons to dig and search for hidden gems.

I'll often start with the API documentation and look at code samples of how the API is used. Well written documentation and unit tests are very helpful here. Once you start digging, good code and designs make it hard to stop, giving you more and more reasons to dive into the depths of the code and gain insights into the minds of the designers and program authors and the kind of thought process that went into producing such great software.

There are also other times when you only want to know enough to be able to use the API.

The best designs and code are the ones that can satisfy readers on both ends of that spectrum. For the former, a clear and intuitive API is the bait that draws them in and wanting to see more. They want to know what's wonders lie beneath that clean API, like those wide-eyed car aficionados who just have to look under the hood of a new model of their favorite exotic car to admire the engineering that lies under the aesthetics of the exterior. For the latter, it's enough for them to be able to get in the driver's seat and enjoy a quick spin around the block.

[praveen kumaar]

Campbell Ritchie wrote:I would suggest that your // comments are too long, and they make the lines difficult to read and I suggest they shou‍ld be /* comments */ instead.

Okay i got it.

Campbell Ritchie wrote:How many bits does a C++ int occupy? Are you sure it is always 32?

Actually i am not sure about it in C++.but since i am coding in java i made a convention to deall with java int(32 bits).

Campbell Ritchie wrote:Why have you got so many static methods?

That is the most awkward thing which comes to my mind when,after writing my code,i go through it.actually they seems like a utility method for my class(so i made them static) but what would you advice should i place them in another utility class.

Campbell Ritchie wrote:Main method: please put a space after the ellipsis operator.
In the ensure length method why are you appending 0s to the StringBuilder?

okay i would use a space.actually i realize that is a bad name,i will change it.i want this method to add leading 0's in order to complete the 32 bit length(that's why i had used it,though i will make it a constant).can you advice some better name.

Campbell Ritchie wrote:What does the flip bit method do? Do you need it?

it will flip the argument bit.please look at this method:

private static void flipBinaryString(StringBuilder binaryString) {
        for (int i = 0; i < binaryString.length(); i++) {
            binaryString.setCharAt(i,flipBit(binaryString.charAt(i)));
        }
    }

if i will not use the flipBit.the statement inside the method either gets too long which seems weird and if i use a variable to store its value inside it then i think it would break the SLAP(single level of abstraction principle.)

Campbell Ritchie wrote:If you have one class which does the conversions, what is going to happen if you do this?

BinaryDecimalConverter converter =
      new BinaryDecimalConverter(1234567890);
System.out.println(converter.toDecimal());

I think there is a design error in your class. Can you see what I am worried about?

Okay i got it.it's a bug i will correct it.
I am coming again in some time...

[praveen kumaar]

Campbell wrote:...Remember the leftmost bit is not a sign bit the way the leftmost bit in a floating‑point number is a sign bit. It represents a value. Also, what do you understand by unsigned right‑shift? ...

I don't get your point.java uses a IEEE 754 standard to represent floats but still there the leftmost bit is the sign bit which,In my opinion,does only carry the sign information.have i missed something? please let me know if i have.
unsigned right shift operator(i >>> j) shifts the bits of i by the value(represented by the 5 least significant bits in i for int and by 6 least significant bits for the long).and the unfilled bits were replaced by 0's.

Kind regards,
Praveen.

[praveen kumaar]

@Junilu: I don't know what a unit test is,though i have seen this word several times in the forum,can you please let me know what it is and how to perform it.
For the code you have given,i got what you meant,there is a bug in my code.i think there should be some validation criteria to validate the constructor parameter before going towards any calculation,it just reminds me about bloch advice in his book to validate the parameters before doing any work on it.Though apart from this bug i think i have opted some bad names for my method along with the use of too many static methods,i think it's also breaking the single responsibility principle.I want to stick to OO design so what should i do.

Kind regards,
Praveen.

[Campbell Ritchie]

praveen kumaar wrote:. . . .java uses a IEEE 754 standard to represent floats but still there the leftmost bit is the sign bit . . .

But that is what I said. In a floating‑point number the leftmost bit represents the sign and nothing else. But in an integer type the leftmost bit has a value (in two's complement in 32 bit, that value is −2³¹

unsigned right shift operator(i >>> j) shifts the bits of i by the value(represented by the 5 least significant bits in i for int and by 6 least significant bits for the long).and the unfilled bits were replaced by 0's.

Kind regards,
Praveen.

No, it shifts the bits in i by the rightmost 5 bits in j. It is not the same as integer division if the left operand is negative.
You didn't get my point about the StringBuilder. I didn't ask why you were using 0s. You usually want 0s. I was asking why you are appending them.
You have still not explained why you are flipping bits. I am not sure I understand your argument, but it doesn't sound fully thought through. Converting decimal and binary numbers shou‍ld be an easy task and I don't remember flipping bits last time I tried it. You could consider changing the method name to something like addLeading0s, but ensureLength isn't too bad a name. Calling a StringBuilder binaryString is however bad. It looks very strange to set something on a String. Beware of passing StringBuilder references around. You usually would use a StringBuilder as a method‑local variable.

In its simplest form, unit testing means to test each method individually. You pass it normal and abnormal inputs and see how it handles them.

[praveen kumaar]

After all the suggestions i have tried to stick with the OO design and its principles.I have 3 classes namely BinaryNumber, DecimalNumber, and the converter and one enum type ConversionType.i design the first 2 classes for the binary number and the decimal number represantion.the another class converter will act as a functional object which does the conversion accordingly with the enum constant given to the constructor.i have design the enum type for represnting the conversion i.e., from binary to decimal and decimal to binary.later i can also add some other conversion to it with holding the backward compatibility.I have tried my best to explain the working of everything in the classes through javadoc comments.
Here is my code:
BinaryNumber.java:

import java.util.Iterator;
import java.util.NoSuchElementException;

/**
 * The {@code Immutable} class {@code BinaryNumber} wraps a string
 * representation of a binary (base 2) number.The class uses a
 * string of ASCII digits {@code '0'} and {@code '1'} to represent
 * a binary number.
 *
 * <p>In addition,this class provides a several methods like for
 * converting a binary(base 2) to a signed {@code int}, swapping
 * bits position in a binary number, finding the {@code 1}s and {@code two}s
 * complement of a binary number and several other useful methods for doing
 * a binary calculation.
 *
 * The minimum and maximum length of binary sequence that can be represented by
 * object of this class is {@code 0} and {@code Integer.MAX_VALUE} respectively.
 *
 * @author Praveen Kumar
 */
public class BinaryNumber implements Iterable<Character> {
    // wrapped binary string
    private final String binaryString;
    // length of the binary number represented by a binary string
    private final int length;

    /**
     * Constructs a newly allocated {@code BinaryNumber} object that represents
     * a specified string of ASCII digits in binary (base 2).
     *
     * @param binaryString string of ASCII digits in binary(base 2)
                           i.e.,{@code '0'} and {@code '1'}.
     * @throws IllegalArgumentException if the argument cannot represent a
                                        binary(base 2) number.
     */
    public BinaryNumber(String binaryString) {
        if (binaryString.matches("[01]+")) {
            this.binaryString = binaryString;
            length = binaryString.length();
        }
        else {
			throw new IllegalArgumentException(binaryString+": Invalid Entries for Binary representation");
		}
    }

	/**
	 * Returns the length of this {@code BinaryNumber}.the length will be equal
	 * to the total number of ASCII character in a binary string represented by
	 * this {@code BinaryNumber} object.
	 *
	 * @return int the number of the ASCII characters({@code '0'} and {@code '1'})
	               in this object.
	 */
	public int length() {
		return length;
	}

    /**
     * returns a new {@code BinaryNumber} equivalent to this {@code BinaryNumber}
     * object but having a length equals to the argument(size).
     * the new object would be padded with leading {@code 0}s or {@code 1}s accordingly the
     * unsigned decimal equivalent(with {@code 2}s complement) of this object is positive or
     * negative.
     * this method will not allow for the Narrowing conversion({@code size < length()}) and
     * throws exception in such case.
     *
     * @param size the needed size of a binary sequence represented by this object.
     * @return BinaryNumber having a length equals to the argument and is equivalent
                            to this object.
     * @throws IndexOutOfBoundsException if the specified size is less than the size
                                         of the binary sequence represented by this
                                         object.
     */
    public BinaryNumber toSize(int size) {
		if  (size < length()) {
			throw new IndexOutOfBoundsException(size+": Narrowing Conversion is not allowed.");
		}
		StringBuilder mutableBinString = new StringBuilder(binaryString);
		mutableBinString.reverse();
		while (mutableBinString.length() != size) {
			if(isNegative()) {
				mutableBinString.append('1');
			}
			else {
				mutableBinString.append('0');
			}
		}
		mutableBinString.reverse();
		BinaryNumber binaryNum = new BinaryNumber(mutableBinString.toString());
		if (isNegative()) {
		return binaryNum.swapBitsPosn(0, size - length);
		}
		return binaryNum;
	}

	/**
	 * returns a {@code String} object representing a binary sequence in this object.
	 *
	 *@return String representation of binary sequence(base 2) represented by this object.
	 */
	@Override
	public String toString() {
		return binaryString;
	}

	/**
	 * returns a new {@code BinaryNumber} having a binary sequence equivalent to performing a
	 * {@code 1}s complement on the binary sequence represented by this object.
	 *
	 * @return BinaryNumber the {@code 1}s complement of the char sequence represented by
	                        this object.
	 */
	public BinaryNumber onesComplement() {
		StringBuilder mutableBinString = new StringBuilder(binaryString);
		for (int i = 0; i < mutableBinString.length(); i++) {
			char flippedBit = (mutableBinString.charAt(i) == '0' ? '1' : '0');
			mutableBinString.setCharAt(i, flippedBit);
		}
		return new BinaryNumber(mutableBinString.toString());
	}

	private class BinaryIterator implements Iterator<Character> {
		char[] bits = binaryString.toCharArray();

		int index = 0;

		/*
		 * Tests if the iteration has more bit character left while traversing
		 * in the char sequence represented by this object.
		 *
		 * @return {@code true} if the binary sequence represented by this object
		                       has one or more bit character left for iteration;
		                       {@code false} otherwise.
		 */
		@Override
		public boolean hasNext() {
			return index < bits.length;
		}

		/*
		 * returns the next bit {@code Character} in the binary sequence represented
		 * by this object while iteration.
		 *
		 * @return Character the next bit character in the binary sequence represented
		                     by this object.
		 * @throws NoSuchElementException if the binary sequence reprsented by this
		                                  object doesnot have next bit {@code Character}.
		 */
		@Override
		public Character next() {
			if (!hasNext()) {
				throw new NoSuchElementException();
			}
			else {
				return bits[index++];
			}
		}

		/* this method will throws an exception every time when it is invoked because this
		 * operation is not supported on the binary sequence represented by this object.
		 *
		 * @throws UnsupportedOperationException every time when it is invoked.
		 */
		@Override
		public void remove() {
			throw new UnsupportedOperationException("Removal: Invalid Operation");
		}
	}

    /**
     * returns a iterator of {@code Character} over a binary sequence represented by this object.
     *
     * @return {@code Iterator<Character>} the iterator providing the iteration on bit character
                                           of the binary sequence represented by this object.
     */
	@Override
	public Iterator<Character> iterator() {
		return new BinaryIterator();
	}

    /**
     * Tests if the signed decimal(with {@code 2}s complement) equivalent of the binary sequence
     * represented by this object is negative.
     *
     * @return {@code true} if the signed decimal equivalent of the binary sequence represented by
                            this object is negative;{@code false} otherwise.
     */
	public boolean isNegative() {
		char signBit = binaryString.charAt(0);
		return signBit == '1' ? true : false;
	}

	/**
	 * returns a new {@code BinaryNumber} having a binary sequence equivalent to the binary sequence
	 * of this object but with the bits position of the {@code i}th and the {@code j}th index of the
	 * binary sequence(in this object) interchanged(in the new object).
	 *
	 * @return BinaryNumber with binary sequence having the {@code i}th and the {@code j}th index
	                        interchanged in the binary sequence represented by this object.
	 * @throws IndexOutOfBoundsException if either argument {@code i} or {@code j} is negative or
	 *                                   greater than the length of the binary sequence represented
	                                     by this object.
	 */
	public BinaryNumber swapBitsPosn(int i, int j) {
		boolean swapPossibility = (i >= 0) && (j >=0) && (i < length) && (j < length);
		if (!swapPossibility) {
			throw new IndexOutOfBoundsException("Illegal Index");
		}
		StringBuilder mutableBinString = new StringBuilder(this.binaryString);
		char ithBit = mutableBinString.charAt(i);
		mutableBinString.setCharAt(i, mutableBinString.charAt(j));
		mutableBinString.setCharAt(j, ithBit);
		return new BinaryNumber(mutableBinString.toString());
	}

    /**
     * returns a {@code int} equivalent of a binary sequence represented by
     * this object.this invocation is only allowed on the {@code BinaryNumber}
     * object having a length less than or equal to {@code Integer.SIZE}
     * ;otherwise the invocation will throw an exception.
     *
     * @return signed integer(with {@code 2}s complement) equivalent of the
     * binary sequence represented by this object.
     * @throws UnsupportedOperationException if the length of the binary sequence
                                             represented by this object is greater
                                             than the {@code Integer.SIZE}.
	 */
	public int toDecimalInt() {
		if (length() > Integer.SIZE) {
			throw new UnsupportedOperationException("Integer can only hold "+Integer.SIZE+" bits.");
		}
		int decInt = 0;
		BinaryNumber binaryNum = this;
		boolean Negative = isNegative();
		if (Negative) {
			binaryNum = twosComplement();
		}
		Iterator<Character> iterator = binaryNum.iterator();
		for (int i = 0; iterator.hasNext(); i++) {
			char next = iterator.next();
			if (next == '1') {
				decInt = decInt + twoRaisedToPow((binaryNum.length() - i - 1));
			}
		}
		return Negative ? -decInt : decInt;
	}

    private static int twoRaisedToPow(int i) {
		assert (i > 0 && i < 32) : "invalid shift";
		return 1 << i;
	}

    /**
     * returns the {@code 2}s complement representation of the binary
     * sequence represented by this object.
     *
     * @return BinaryNumber having the binary sequence equivalent to the
                            {@code 2}s complement of the binary sequence
                            represented by this object.
     */
	public BinaryNumber twosComplement() {
		BinaryNumber binNum = onesComplement();
		StringBuilder mutableBinString = new StringBuilder(binNum.binaryString);
		mutableBinString.reverse();
		for (int i = 0; i < binNum.length(); i++) {
			if (mutableBinString.charAt(i) == '1') {
				mutableBinString.setCharAt(i, '0');
				continue;
			}
			mutableBinString.setCharAt(i, '1');
			break;
		}
		mutableBinString.reverse();
		return new BinaryNumber(mutableBinString.toString());
	}
}

DecimalNumber.java:

/**
 * The {@code DecimalNumber} class wraps a primitive data type {@code int}.
 * The object of type {@code DecimalNumber} will be helpful when doing a
 * conversion of a type {@code int} to {@code BinaryNumber}.
 *
 * @author Praveen Kumar
 */
public class DecimalNumber {
    // wrapped int
    private final int value;

    /**
     * Constructs a newly allocated {@code DecimalNumber} object that represents
     * the specified {@code int} value.
     *
     * @param integer The primitive {@code int} value represented by {@code this}
     * object.
     */
    public DecimalNumber(int value) {
        this.value = value;
    }

    /**
     * Returns a {@code BinaryNumber}(base 2)
     * representation of unsigned {@code int} equivalent to {@code int}
     * represented by {@code this} object.
     * The unsigned {@code int} equivalent is the {@code int} represented by
     * this object plus 2<sup>32</sup> if the represented {@code int} is negative;
     * otherwise it is equal to the represented {@code int} of {@code this} object.
	 * for clearity here is the example: let the represented {@code int = -8} than the
	 * equivalent unsigned {@code int} will be 2<sup>32</sup> {@code + (-8)}.
	 *
	 * <p>The {@code BinaryNumber} returned by this method will contains the leading
	 * {@code 0}s if the size of the binary string equivalent to the {@code int}
	 * represented by {@code this} object is less than 32.
	 * and in that case The number of leading {@code 0}s will be 32 minus the minimum number
	 * of bits required to convert {@code int} to a binary number.
	 *
	 * @return BinaryNumber the binary equivalent of the {@code int} represented by
	           {@code this} object.
	 */
    public BinaryNumber toBinaryNumber() {
        int i = Math.abs(value);
        StringBuilder mutableBinString = new StringBuilder();
        while (i != 0) {
            mutableBinString.append(isEven(i) ? '0' : '1');
            i >>>= 1;
        }
        mutableBinString.append('0');
        mutableBinString.reverse();
        BinaryNumber binaryNum;
        if (value < 0) {
			binaryNum = new BinaryNumber(mutableBinString.toString()).twosComplement();
			return binaryNum.toSize(Integer.SIZE);
		}
        binaryNum = new BinaryNumber(mutableBinString.toString());
        return binaryNum.toSize(Integer.SIZE);
    }

    /**
     * Tests if the specified argument is a Even Number.
     *
     *@param i the {@code int} to be tested.
     *@returns {@code true} if the arugument is a Even Number;{@code false} otherwise.
     */
    public static boolean isEven(int i) {
        return (i & 1) == 0;
    }
}

Enum constant denoting the conversion type;ConversionType.java:

/**
 * Enum for conversion from one base to another like from decimal to binary,
 * binary to decimal etc.Every constant represent a specific conversion type
 * like for Example: the {@link BinaryNumber#DECIMAL_TO_BINARY DECIMAL_TO_BINARY}
 * represent a conversion from base 10 to base 2.
 *
 * @author Praveen Kumar
 */
public enum ConversionType {
    /**
     * Represents a conversion type from base 10 to base 2.
     */
    DECIMAL_TO_BINARY {
		@Override
		public String convert(String arg) throws IllegalArgumentException {
			try {
				int integer = Integer.parseInt(arg);
				DecimalNumber decimalNum = new DecimalNumber(integer);
				return decimalNum.toBinaryNumber().toString();
			}
			catch(NumberFormatException cause) {
				throw new IllegalArgumentException(cause);
			}
		}
	},
	/**
	 * Represents a conversion type from base 2 to base 10.
     */
    BINARY_TO_DECIMAL {
		@Override
		public String convert(String arg) throws IllegalArgumentException {
			try {
				BinaryNumber binaryNum = new BinaryNumber(arg);
				int value = binaryNum.toDecimalInt();
				return "" + value;
			}
			catch(IllegalArgumentException cause) {
				throw new IllegalArgumentException(cause);
			}
			catch(UnsupportedOperationException cause) {
				throw new IllegalArgumentException(cause);
			}

		}
	};

    /**
     * Converts the argument to a string representing the another base and is equivalent
     * to the base represented by the argument.the conversion will take place accordingly
     * with the Enum constant {@code ConversionType}.
     *
     * @param arg the string representation of the base to be converted to another base.
	 * @return the string representation of a converted base.
	 * @throws IllegalArgumentException if the argument string is not parsable to the
	                                    base to be converted.
     */
    public abstract String convert(String arg) throws IllegalArgumentException;
}

The final class acting as a functional object for doing the conversion;Converter.java:

public class Convertor {
    private final ConversionType conversionType;

    public Convertor(ConversionType conversionType) {
    	this.conversionType = conversionType;
    }

    public String convert(String arg) {
    	return conversionType.convert(arg);
    }

    public static void main(String... args) {
    	Convertor con = new Convertor(ConversionType.DECIMAL_TO_BINARY);
    	// conversion code goes here...
    }
}

I will request the members to review my code and suggest anything to make my code more better.

Kind regards,
Praveen.

[Junilu Lacar]

Praveen, quickly scanning over this most recent version you posted, it looks pretty decent on the surface. You've obviously made an effort to document your code with JavaDocs and for the most part, it looks like you've done a good job. One little nitpick is that the first sentence in a JavaDoc comment should be in proper sentence case; you missed a few in this respect.

You asked what a unit test is. I was referring to automated unit tests like those you'd run with JUnit.

I've been slowly learning Go and have been watching some talks by Rob Pike, one of Go's creators at Google. In one talk, Rob reminded the audience that "Documentation is for users." He explained how many programmers tend to write program documentation while still thinking about the internal implementation of their programs so their comments tend to be more about implementation rather than intent. Rob said that we should document with the user in mind and tell them more about intent and proper usage.

I think the same idea applies to unit tests. Many programmers write unit tests with a strong focus on internal implementation details. Good tests, however, tell a story. They tell how the program under test is supposed to be used. Good tests are like high-level use cases that show how to prepare the program for use, how to call its API, and what behavior and outcomes to expect. Good high-level tests reveal little to no specifics about implementation. This is how I try to write most of my unit tests.

I'm a big proponent of Test-Driven Development (TDD) and JUnit and these are key to enabling me to write unit tests the way I just described.

If you could write some high-level unit tests that show how this converter of yours is supposed to be used by others, that would be awesome. Then it would be easier to see just how well-designed and well-coded this little utility of yours is.

[Knute Snortum]

Great code!  Well formatted and documented.  I have one nitpick on the documentation too: you should have a space after punctuation.

I think at this level, code should have its own package, not the default package.

--------------

        for (int i = 0; i < binNum.length(); i++) {
            if (mutableBinString.charAt(i) == '1') {
                mutableBinString.setCharAt(i, '0');
                continue;
            }
            mutableBinString.setCharAt(i, '1');
            break;
        }

I think the above code would be better as:

        for (int i = 0; i < binNum.length(); i++) {
            if (mutableBinString.charAt(i) == '1') {
                mutableBinString.setCharAt(i, '0');
            } else {
                mutableBinString.setCharAt(i, '1');
                break;
            }
        }

--------------------

        boolean Negative = isNegative();
        if (Negative) {
            binaryNum = twosComplement();
        }

Negative should be negative, but really, you don't need the boolean variable.

        if (isNegative()) {
            binaryNum = twosComplement();
        }

--------------------------------------

        boolean swapPossibility = (i >= 0) && (j >=0) && (i < length) && (j < length);
        if (!swapPossibility) {
            throw new IndexOutOfBoundsException("Illegal Index");
        }

I think this would be better:

if (i < 0 || j < 0 || i >= length || j >= length) {

[Junilu Lacar]

Knute Snortum wrote:

        boolean swapPossibility = (i >= 0) && (j >=0) && (i < length) && (j < length);
        if (!swapPossibility) {
            throw new IndexOutOfBoundsException("Illegal Index");
        }

I think this would be better:

if (i < 0 || j < 0 || i >= length || j >= length) {

Agree with all of Knute's feedback. To add to the one above, yet another refactor wouldn't hurt: Extract Method to replace the formula with an intention revealing method name.

if (outOfBounds(i, j, length)) {
   throw new IndexOutOfBoundsException("Illegal Index");
}

and I might even argue that you should separate i and j:

if (outOfBounds(i, length) || outOfBounds(j, length)) {
   throw new IndexOutOfBoundsException("Illegal Index");
}

EDIT: It's easy to imagine someone arguing that the above refactoring is going a step too far, that the exception thrown was enough to explain the formula. There's some merit in that reasoning, however, if you had an optimizing compiler and you declared the outOfBounds() method as private or final, I can easily imagine that an optimizing compiler would see the method calls and decide to inline the one line of code that's in outOfBounds(int, int).  So, if you had an optimizing compiler that inlined the extracted code back anyway, why not just go the extra step to make the code clearer for the reader?

[Junilu Lacar]

Praveen,

Overall, I think you should be happy with the progress that you've made. Keep reading up on the things we've talked about so far, particularly the principles behind making all those improvements. And have a cow for your efforts!  

[praveen kumaar]

@Junilu: sorry for being late, actually i am teaching myself some basics of automated testing with *JUnit Framework*.i have read some articles on it and i like, written somewhere, test a little code a little.till now i had just been coding but from now i will code with confidence(i think what actually the testing provide is the confidence).i will be grateful to you and *knute* for every piece of advide you had given me.thanks a lot again.

Okay,i have also shown my code in other forums and to some of my colleagues.i got several of advices, somebody has adviced me to use char[] instead of stringbuilder(SB) and really by using char[] the readability of my code is enhanced so i have done it.next thing is someone has also adviced me to use some binary arithmetic along with bitwise operators so i have done a change in the *toDecimalInt* and *toBinaryNumber()*.i have also added a static factory as because someone has told me exception throwing in a constructor is basically a bad form because JLS mandates that the Exception be wrapped into an ExceptionInInitializerError so i have done this change.
I have also written a unit test with junit to test my code.
all the things are below:
BinaryNumber.java

package com.manishaplastics.tlp;

import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Arrays;

/**
 * The {@code Immutable} class {@code BinaryNumber} wraps a string
 * representation of a binary (base 2) number.The class uses a
 * string of ASCII digits {@code '0'} and {@code '1'} to represent
 * a binary number.
 *
 * <p>In addition,this class provides a several methods like for
 * converting a binary(base 2) to a signed {@code int}, swapping
 * bits position in a binary number, finding the {@code 1}s and {@code two}s
 * complement of a binary number and several other useful methods for doing
 * a binary calculation.
 *
 * The minimum and maximum length of binary sequence that can be represented by
 * object of this class is {@code 1} and {@code Integer.MAX_VALUE} respectively.
 *
 * @author Praveen Kumar
 */
public class BinaryNumber implements Iterable<Character> {
    // wrapped binary sequence as array
    private final char[] bitArray;

    private BinaryNumber(String binaryString) {
        bitArray = binaryString.toCharArray();
    }

    /**
	 * returns a newly allocated {@code BinaryNumber} object that represents
	 * a specified string of ASCII digits in binary (base 2).
	 *
	 * @param binaryString string of ASCII digits in binary(base 2)
	                       i.e.,{@code '0'} and {@code '1'}.
	 * @throws IllegalArgumentException if the argument cannot represent a
	                                    binary(base 2) number.
     */
    public static BinaryNumber newBinaryNumber(String binaryString) {
        if (!binaryString.matches("[01]+")) {
            throw new IllegalArgumentException(binaryString+": Invalid Entries for Binary representation");
  		}
  		return new BinaryNumber(binaryString);
    }

	/**
	 * Returns the length of this {@code BinaryNumber}.the length will be equal
	 * to the total number of ASCII character in a binary string represented by
	 * this {@code BinaryNumber} object.
	 *
	 * @return int the number of the ASCII characters({@code '0'} and {@code '1'})
	               in this object.
	 */
	public int length() {
		return bitArray.length;
	}

    /**
     * returns a new {@code BinaryNumber} equivalent to this {@code BinaryNumber}
     * object but having a length equals to the argument(size).
     * the new object would be padded with leading {@code 0}s or {@code 1}s accordingly the
     * unsigned decimal equivalent(with {@code 2}s complement) of this object is positive or
     * negative.
     * this method will not allow for the Narrowing conversion({@code size < length()}) if
     * the resulting binary sequence cannot hold all the {@code 1}s or {@code 0}s
     * (accordingly with either this binary sequence is +ve or -ve in signed decimal)in this binary
     * number and throws exception in such case.
     *
     * @param size the needed size of a binary sequence represented by this object.
     * @return BinaryNumber having a length equals to the argument and is equivalent
                            to this object.
     * @throws IndexOutOfBoundsException if the specified size is less than the size
                                         of the binary sequence(shortest possible) represented by
                                         this object.
     */
    public BinaryNumber toSize(int size) {
		String bitString = new String(bitArray);
		if (bitString.matches("[0]{2,}[01]*")) {
			bitString = bitString.replaceFirst("[0]{2,}", "0");
		}
		else if (bitString.matches("[1]{2,}[01]*")) {
			bitString = bitString.replaceFirst("[1]{2,}", "1");
		}
		if (size < bitString.length()) {
			throw new IndexOutOfBoundsException(size+": Illegal Narrowing Conversion: Loss of precision.");
		}
		char[] bitArray = bitString.toCharArray();
		char[] newBitArray = new char[size];
		Arrays.fill(newBitArray, isNegative() ? '1' : '0');
		System.arraycopy(bitArray, 0, newBitArray, size - bitArray.length, bitArray.length);
		return new BinaryNumber(new String(newBitArray));
    }

	/**
	 * returns a {@code String} object representing a binary sequence in this object.
	 *
	 *@return String representation of binary sequence(base 2) represented by this object.
	 */
	@Override
	public String toString() {
		return new String(bitArray);
	}

	/**
	 * returns a new {@code BinaryNumber} having a binary sequence equivalent to performing a
	 * {@code 1}s complement on the binary sequence represented by this object.
	 *
	 * @return BinaryNumber the {@code 1}s complement of the char sequence represented by
	                        this object.
	 */
	public BinaryNumber onesComplement() {
		char[] onesCompBitArr = new char[bitArray.length];
		for (int i = 0; i < bitArray.length; i++) {
		    onesCompBitArr[i] = bitArray[i] == '0' ? '1' : '0';
		}
		return new BinaryNumber(new String(onesCompBitArr));
	}

	private class BinaryIterator implements Iterator<Character> {
		int index = 0;

		/**
		 * Tests if the iteration has more bit character left while traversing
		 * in the char sequence represented by this object.
		 *
		 * @return {@code true} if the binary sequence represented by this object
		                       has one or more bit character left for iteration;
		                       {@code false} otherwise.
		 */
		@Override
		public boolean hasNext() {
			return index < bitArray.length;
		}

		/**
		 * returns the next bit {@code Character} in the binary sequence represented
		 * by this object while iteration.
		 *
		 * @return Character the next bit character in the binary sequence represented
		                     by this object.
		 * @throws NoSuchElementException if the binary sequence reprsented by this
		                                  object doesnot have next bit {@code Character}.
		 */
		@Override
		public Character next() {
			if (!hasNext()) {
				throw new NoSuchElementException();
			}
			else {
				return bitArray[index++];
			}
		}

		/** this method will throws an exception every time when it is invoked because this
		 * operation is not supported on the binary sequence represented by this object.
		 *
		 * @throws UnsupportedOperationException every time when it is invoked.
		 */
		@Override
		public void remove() {
			throw new UnsupportedOperationException("Removal: Invalid Operation");
		}
	}

    /**
     * returns a iterator of {@code Character} over a binary sequence represented by this object.
     *
     * @return {@code Iterator<Character>} the iterator providing the iteration on bit character
                                           of the binary sequence represented by this object.
     */
	@Override
	public Iterator<Character> iterator() {
		return new BinaryIterator();
	}

    /**
     * Tests if the signed decimal(with {@code 2}s complement) equivalent of the binary sequence
     * represented by this object is negative.
     *
     * @return {@code true} if the signed decimal equivalent of the binary sequence represented by
                            this object is negative;{@code false} otherwise.
     */
	public boolean isNegative() {
		return bitArray[0] == '1';
	}

	/**
	 * returns a new {@code BinaryNumber} having a binary sequence equivalent to the binary sequence
	 * of this object but with the bits position of the {@code i}th and the {@code j}th index of the
	 * binary sequence(in this object) interchanged(in the new object).
	 *
	 * @return BinaryNumber with binary sequence having the {@code i}th and the {@code j}th index
	                        interchanged in the binary sequence represented by this object.
	 * @throws IndexOutOfBoundsException if either argument {@code i} or {@code j} is negative or
	 *                                   greater than the length of the binary sequence represented
	                                     by this object.
	 */
	public BinaryNumber swapBitsAt(int i, int j) {
		if (outOfBounds(i, bitArray.length) || outOfBounds(j, bitArray.length)) {
			throw new IndexOutOfBoundsException("Illegal Index");
		}
		char[] arrToSwap = Arrays.copyOf(bitArray, bitArray.length);
		char temp = arrToSwap[i];
		arrToSwap[i] = arrToSwap[j];
		arrToSwap[j] = temp;
		return new BinaryNumber(new String(arrToSwap));
	}

	private boolean outOfBounds(int i, int length) {
		return i < 0 || i >= length;
	}

    /**
     * returns a {@code int} equivalent of a binary sequence represented by
     * this object.this invocation is only allowed on the {@code BinaryNumber}
     * object if the {@code int} type can hold the signed decimal equivalent of
     * the binary sequence represented by this object; otherwise the invocation
     * will throw an exception.
     *
     * @return signed integer(with {@code 2}s complement) equivalent of the
     * binary sequence represented by this object.
     * @throws UnsupportedOperationException if the length of the binary sequence
                                             represented by this object is greater
                                             than the {@code Integer.SIZE}.
     */
    public int toDecimalInt() {
		int decInt = 0;
		char[] bitArr= toSize(Integer.SIZE).bitArray;
		for (int i = 0; i < (bitArr.length - 1); i++) {
		    if (bitArr[i] == '1') {
		        decInt |= 1;
		    }
		    decInt <<= 1;
		}
		if(bitArr[bitArr.length - 1] == '1') {
		    decInt |=1;
		}
		return decInt;
    }

    /**
     * returns the {@code 2}s complement representation of the binary
     * sequence represented by this object.
     *
     * @return BinaryNumber having the binary sequence equivalent to the
                            {@code 2}s complement of the binary sequence
                            represented by this object.
     */
	public BinaryNumber twosComplement() {
	    BinaryNumber binNum = onesComplement();
	    char[] twosCompArr = Arrays.copyOf(binNum.bitArray, bitArray.length);
	    for (int i = twosCompArr.length - 1; i >= 0; i--) {
	        if (twosCompArr[i] == '1') {
	            twosCompArr[i] = '0';
		}
		else {
		    twosCompArr[i] = '1';
		    break;
		}
	    }
	    return new BinaryNumber(new String(twosCompArr));
	}

	/**
	 * Compares this {@Code BinaryNumber} to the specified object. The result is true if
	 * and only if the argument is not null and is a BinaryNumber object that 
	 * represents the same decimal value as of this object.
	 *
	 * @param o the object to be compared with this binary number.
	 * @return {@code true} if the decimal equivalent of this binary sequence is equals to the decimal
	 *         equivalent of the given object; {@code false} otherwise.
	 */
	@Override
	public boolean equals(Object o) {
		if (o == this) {
			return true;
		}
		if (!(o instanceof BinaryNumber)) {
			return false;
		}
		BinaryNumber binNum = (BinaryNumber)o;
		if (binNum.bitArray.length > bitArray.length) {
			return Arrays.equals(toSize(binNum.bitArray.length).bitArray, binNum.bitArray);
		}
		return Arrays.equals(bitArray, binNum.toSize(bitArray.length).bitArray);
	}

	/**
	 * returns a hash code for this object; equals to the hash code of the {@code String} object
	 * which is a shortest representation of the binary sequence of this object.
	 *
	 * {@code For Example:} if the binary sequence is {@code 00000001101010} then the hash code of this
	 * object will be hash code of String(01101010).
	 *
	 * @return int the hash code for this object.
	 */
	@Override
	public int hashCode() {
	    String i = new String(bitArray);
	    if (i.matches("[0]{2,}[01]*")) {
	        i = i.replaceFirst("[0]{2,}", "0");
	    }
	    else if (i.matches("[1]{2,}[01]*")) {
	        i = i.replaceFirst("[1]{2,}", "1");
	    }
	        return i.hashCode();
	}

}

BinaryNumberTest.java→All the test passed.

package com.manishaplastics.put;

import org.junit.Test;
import org.junit.Before;
import org.junit.Assert;
import java.util.Iterator;
import com.manishaplastics.tlp.BinaryNumber;
import org.junit.runner.JUnitCore;

public class BinaryNumberTest {

	/*
	 * variables are named accordingly with their value in signed decimal form
	 * with 2s Complement.
	 *
	 * I have used the 32 bit representation for testing binary numbers.
	 */
	private static final String ZERO = "00000000000000000000000000000000";
	private static final String ONE = "00000000000000000000000000000001";
	private static final String MINUS_ONE = "11111111111111111111111111111111";
	private static final String MAX = "01111111111111111111111111111111";
	private static final String MIN = "10000000000000000000000000000000";
	private static final String RANDOM1 = "10111000110010110001101100110011";
	private static final String RANDOM2 = "00001101101001110101001011100100";
	/*
	 * variable denoting the size argument for narrowing and widening
	 * conversion test.
	 */
	private static final int NARROWING_LENGTH = 16;
	private static final int WIDENING_LENGTH = 64;
	private static final int RANDOM1_INT_VALUE = -1194648781;
	private static final int RANDOM2_INT_VALUE = 229069540;

	private BinaryNumber binNumOne;
	private BinaryNumber binNumZero;
	private BinaryNumber binNumMinusOne;
	private BinaryNumber binNumMax;
	private BinaryNumber binNumMin;
	private BinaryNumber binNumRandom1;
	private BinaryNumber binNumRandom2;

	@Before
	public void setUp() throws Exception {
		setBinaryNumbers();
	}

	private void setBinaryNumbers() {
		binNumZero = BinaryNumber.newBinaryNumber(ZERO);
		binNumOne = BinaryNumber.newBinaryNumber(ONE);
		binNumMinusOne = BinaryNumber.newBinaryNumber(MINUS_ONE);
		binNumMax = BinaryNumber.newBinaryNumber(MAX);
		binNumMin = BinaryNumber.newBinaryNumber(MIN);
		binNumRandom1 = BinaryNumber.newBinaryNumber(RANDOM1);
		binNumRandom2 = BinaryNumber.newBinaryNumber(RANDOM2);
	}

	@Test(expected = IllegalArgumentException.class)
	public void test_Static_Factory_For_Illegal_Digits_As_Arg() {
		BinaryNumber.newBinaryNumber("111234");
	}

	@Test(expected = IllegalArgumentException.class)
	public void test_Static_Factory_For_Letters_As_Arg() {
		BinaryNumber.newBinaryNumber("abcd");
	}

	@Test(expected = NullPointerException.class)
	public void test_Static_Factory_For_Null_Arg() {
		BinaryNumber.newBinaryNumber(null);
	}

	@Test
	public void test_equals_With_Equal_Length() {
		BinaryNumber zero = BinaryNumber.newBinaryNumber(ZERO);
		BinaryNumber one = BinaryNumber.newBinaryNumber(ONE);
		BinaryNumber minusOne = BinaryNumber.newBinaryNumber(MINUS_ONE);
		BinaryNumber random1Equiv = BinaryNumber.newBinaryNumber(RANDOM1);
		BinaryNumber random2Equiv = BinaryNumber.newBinaryNumber(RANDOM2);
		Assert.assertEquals(zero, binNumZero);
		Assert.assertEquals(one, binNumOne);
		Assert.assertEquals(minusOne, binNumMinusOne);
		Assert.assertEquals(random1Equiv, binNumRandom1);
		Assert.assertEquals(random2Equiv, binNumRandom2);
		Assert.assertNotEquals(binNumOne, binNumZero);
		Assert.assertNotEquals(binNumOne, binNumMinusOne);
		Assert.assertNotEquals(binNumRandom1, binNumRandom2);
	}

	@Test
	public void test_equals_With_UnEqual_Length() {
		BinaryNumber zero = BinaryNumber.newBinaryNumber("0000" + ZERO);
		BinaryNumber one = BinaryNumber.newBinaryNumber("000000000" + ONE);
		BinaryNumber minusOne = BinaryNumber.newBinaryNumber("1111111" + MINUS_ONE);
		BinaryNumber random1Equiv = BinaryNumber.newBinaryNumber("1111111111111111111" + RANDOM1);
		BinaryNumber random2Equiv = BinaryNumber.newBinaryNumber("000000000000" + RANDOM2);
		Assert.assertEquals(zero, binNumZero);
		Assert.assertEquals(one, binNumOne);
		Assert.assertEquals(minusOne, binNumMinusOne);
		Assert.assertEquals(random1Equiv, binNumRandom1);
		Assert.assertEquals(random2Equiv, binNumRandom2);
		Assert.assertNotEquals(binNumOne, binNumZero);
		Assert.assertNotEquals(binNumOne, binNumMinusOne);
		Assert.assertNotEquals(binNumRandom1, binNumRandom2);
	}

	@Test(expected = IndexOutOfBoundsException.class)
	public void test_toSize_For_Narrowing_Conversion() {
		binNumRandom1.toSize(NARROWING_LENGTH);
	}

	@Test
	public void test_toSize_For_WideningConversion() {
		String zero = ZERO + ZERO;
		String one = ZERO + ONE;
		String minusOne = MINUS_ONE + MINUS_ONE;
		String max = ZERO + MAX;
		String min = MINUS_ONE + MIN;
		String random1 = MINUS_ONE + RANDOM1;
		String random2 = ZERO + RANDOM2;
		BinaryNumber widened_BinaryNumber = binNumZero.toSize(WIDENING_LENGTH);
		Assert.assertEquals(zero, widened_BinaryNumber.toString());
		widened_BinaryNumber = binNumOne.toSize(WIDENING_LENGTH);
		Assert.assertEquals(one, widened_BinaryNumber.toString());
		widened_BinaryNumber = binNumMinusOne.toSize(WIDENING_LENGTH);
		Assert.assertEquals(minusOne, widened_BinaryNumber.toString());
		widened_BinaryNumber = binNumMax.toSize(WIDENING_LENGTH);
		Assert.assertEquals(max, widened_BinaryNumber.toString());
		widened_BinaryNumber = binNumMin.toSize(WIDENING_LENGTH);
		Assert.assertEquals(min, widened_BinaryNumber.toString());
		widened_BinaryNumber = binNumRandom1.toSize(WIDENING_LENGTH);
		Assert.assertEquals(random1, widened_BinaryNumber.toString());
		widened_BinaryNumber = binNumRandom2.toSize(WIDENING_LENGTH);
		Assert.assertEquals(random2, widened_BinaryNumber.toString());
	}

	@Test
	public void test_swapBitsAt() {
		BinaryNumber binNumAfterSwap = binNumRandom1.swapBitsAt(4, 7);
		BinaryNumber expected = BinaryNumber.newBinaryNumber("10110001110010110001101100110011");
		Assert.assertEquals(expected, binNumAfterSwap);
		binNumAfterSwap = binNumRandom1.swapBitsAt(8, 29);
		expected = BinaryNumber.newBinaryNumber("10111000010010110001101100110111");
		Assert.assertEquals(expected, binNumAfterSwap);
		binNumAfterSwap = binNumRandom1.swapBitsAt(12, 21);
		expected = BinaryNumber.newBinaryNumber("10111000110000110001111100110011");
		Assert.assertEquals(expected, binNumAfterSwap);
		binNumAfterSwap = binNumRandom2.swapBitsAt(5, 9);
		expected = BinaryNumber.newBinaryNumber("00001001111001110101001011100100");
		Assert.assertEquals(expected, binNumAfterSwap);
		binNumAfterSwap = binNumRandom2.swapBitsAt(3, 17);
		expected = BinaryNumber.newBinaryNumber("00011101101001110001001011100100");
		Assert.assertEquals(expected, binNumAfterSwap);
		binNumAfterSwap = binNumRandom2.swapBitsAt(5, 8);
		expected = BinaryNumber.newBinaryNumber("00001101101001110101001011100100");
		Assert.assertEquals(expected, binNumAfterSwap);
	}

	@Test
	public void test_onesComplement() {
		BinaryNumber OnesComp_Zero = BinaryNumber.newBinaryNumber("11111111111111111111111111111111");
		BinaryNumber OnesComp_One = BinaryNumber.newBinaryNumber("11111111111111111111111111111110");
		BinaryNumber OnesComp_MinusOne = BinaryNumber.newBinaryNumber("00000000000000000000000000000000");
		BinaryNumber OnesComp_Max = BinaryNumber.newBinaryNumber("10000000000000000000000000000000");
		BinaryNumber OnesComp_Min = BinaryNumber.newBinaryNumber("01111111111111111111111111111111");
		BinaryNumber OnesComp_Random1 = BinaryNumber.newBinaryNumber("01000111001101001110010011001100");
		BinaryNumber OnesComp_Random2 = BinaryNumber.newBinaryNumber("11110010010110001010110100011011");
		Assert.assertEquals(OnesComp_Zero, binNumZero.onesComplement());
		Assert.assertEquals(OnesComp_One, binNumOne.onesComplement());
		Assert.assertEquals(OnesComp_MinusOne, binNumMinusOne.onesComplement());
		Assert.assertEquals(OnesComp_Max, binNumMax.onesComplement());
		Assert.assertEquals(OnesComp_Min, binNumMin.onesComplement());
		Assert.assertEquals(OnesComp_Random1, binNumRandom1.onesComplement());
		Assert.assertEquals(OnesComp_Random2, binNumRandom2.onesComplement());
	}

	@Test
	public void test_iterator() {
		Iterator<Character> iterator = binNumRandom1.iterator();
		char[] chars_In_Random1 = binNumRandom1.toString().toCharArray();
		for(char c : chars_In_Random1) {
			Assert.assertTrue(c == iterator.next());
		}
	}

	@Test(expected = IndexOutOfBoundsException.class)
	public void test_toDecimalInt_For_Length_Greater_Than_Integer_Size() {
		BinaryNumber.newBinaryNumber(RANDOM1 + "1").toDecimalInt();
	}

	@Test
	public void test_toDecimalInt() {
		Assert.assertTrue(binNumZero.toDecimalInt() == 0);
		Assert.assertTrue(binNumOne.toDecimalInt() == 1);
		Assert.assertTrue(binNumMinusOne.toDecimalInt() == -1);
		Assert.assertTrue(binNumMax.toDecimalInt() == Integer.MAX_VALUE);
		Assert.assertTrue(binNumMin.toDecimalInt() == Integer.MIN_VALUE);
		Assert.assertTrue(binNumRandom1.toDecimalInt() == RANDOM1_INT_VALUE);
		Assert.assertTrue(binNumRandom2.toDecimalInt() == RANDOM2_INT_VALUE);
		BinaryNumber binNum = BinaryNumber.newBinaryNumber(ZERO + ZERO);
		Assert.assertTrue(binNum.toDecimalInt() == 0);
		binNum = BinaryNumber.newBinaryNumber(ZERO + ONE);
		Assert.assertTrue(binNum.toDecimalInt() == 1);
		binNum = BinaryNumber.newBinaryNumber(MINUS_ONE + MINUS_ONE);
		Assert.assertTrue(binNum.toDecimalInt() == -1);
		binNum = BinaryNumber.newBinaryNumber(ZERO + MAX);
		Assert.assertTrue(binNum.toDecimalInt() == Integer.MAX_VALUE);
		binNum = BinaryNumber.newBinaryNumber(MINUS_ONE + MIN);
		Assert.assertTrue(binNum.toDecimalInt() == Integer.MIN_VALUE);
		binNum = BinaryNumber.newBinaryNumber(MINUS_ONE + RANDOM1);
		Assert.assertTrue(binNum.toDecimalInt() == RANDOM1_INT_VALUE);
		binNum = BinaryNumber.newBinaryNumber(ZERO + RANDOM2);
		Assert.assertTrue(binNum.toDecimalInt() == RANDOM2_INT_VALUE);
	}

	@Test
	public void test_twosComplement() {
		BinaryNumber twosComp_Zero = BinaryNumber.newBinaryNumber("00000000000000000000000000000000");
		BinaryNumber twosComp_One = BinaryNumber.newBinaryNumber("11111111111111111111111111111111");
		BinaryNumber twosComp_MinusOne = BinaryNumber.newBinaryNumber("00000000000000000000000000000001");
		BinaryNumber twosComp_Max = BinaryNumber.newBinaryNumber("10000000000000000000000000000001");
		BinaryNumber twosComp_Min = BinaryNumber.newBinaryNumber("10000000000000000000000000000000");
		BinaryNumber twosComp_Random1 = BinaryNumber.newBinaryNumber("01000111001101001110010011001101");
		BinaryNumber twosComp_Random2 = BinaryNumber.newBinaryNumber("11110010010110001010110100011100");
		Assert.assertEquals(twosComp_Zero, binNumZero.twosComplement());
		Assert.assertEquals(twosComp_One, binNumOne.twosComplement());
		Assert.assertEquals(twosComp_MinusOne, binNumMinusOne.twosComplement());
		Assert.assertEquals(twosComp_Max, binNumMax.twosComplement());
		Assert.assertEquals(twosComp_Min, binNumMin.twosComplement());
		Assert.assertEquals(twosComp_Random1, binNumRandom1.twosComplement());
		Assert.assertEquals(twosComp_Random2, binNumRandom2.twosComplement());
	}

	@Test
	public void test_hashCode() {
		BinaryNumber zero = BinaryNumber.newBinaryNumber(ZERO);
		BinaryNumber one = BinaryNumber.newBinaryNumber(ONE);
		BinaryNumber minusOne = BinaryNumber.newBinaryNumber(MINUS_ONE);
		BinaryNumber random1 = BinaryNumber.newBinaryNumber(RANDOM1);
		BinaryNumber random2 = BinaryNumber.newBinaryNumber(RANDOM2);
		Assert.assertTrue(zero.hashCode() == binNumZero.hashCode());
		Assert.assertTrue(one.hashCode() == binNumOne.hashCode());
		Assert.assertTrue(minusOne.hashCode() == binNumMinusOne.hashCode());
		Assert.assertTrue(random1.hashCode() == binNumRandom1.hashCode());
		Assert.assertTrue(random2.hashCode() == binNumRandom2.hashCode());
		Assert.assertTrue(zero.hashCode() == BinaryNumber.newBinaryNumber(ZERO +ZERO).hashCode());
		Assert.assertTrue(one.hashCode() == BinaryNumber.newBinaryNumber("00000000" + ONE).hashCode());
		Assert.assertTrue(minusOne.hashCode() == BinaryNumber.newBinaryNumber(MINUS_ONE + MINUS_ONE).hashCode());
		Assert.assertTrue(random1.hashCode() == BinaryNumber.newBinaryNumber("111111111111" + RANDOM1).hashCode());
		Assert.assertTrue(random2.hashCode() == BinaryNumber.newBinaryNumber(ZERO + RANDOM2).hashCode());
	}

	public static void main(String... args) {
		JUnitCore.main("com.manishaplastics.put.BinaryNumberTest");
	}

}

DecimalNumber.java

package com.manishaplastics.tlp;
/**
 * The {@code DecimalNumber} class wraps a primitive data type {@code int}.
 * The object of type {@code DecimalNumber} will be helpful when doing a
 * conversion of a type {@code int} to {@code BinaryNumber}.
 *
 * @author Praveen Kumar
 */
public class DecimalNumber {
    // wrapped int
    private final int value;

    /**
     * Constructs a newly allocated {@code DecimalNumber} object that represents
     * the specified {@code int} value.
     *
     * @param integer The primitive {@code int} value represented by {@code this}
     * object.
     */
    public DecimalNumber(int value) {
        this.value = value;
    }

    /**
     * Returns a {@code BinaryNumber}(base 2)
     * representation of unsigned {@code int} equivalent to {@code int}
     * represented by {@code this} object.
     * The unsigned {@code int} equivalent is the {@code int} represented by
     * this object plus 2<sup>32</sup> if the represented {@code int} is negative;
     * otherwise it is equal to the represented {@code int} of {@code this} object.
	 * for clearity here is the example: let the represented {@code int = -8} than the
	 * equivalent unsigned {@code int} will be 2<sup>32</sup> {@code + (-8)}.
	 *
	 * <p>The {@code BinaryNumber} returned by this method will contains the leading
	 * {@code 0}s if the size of the binary string equivalent to the {@code int}
	 * represented by {@code this} object is less than 32.
	 * and in that case The number of leading {@code 0}s will be 32 minus the minimum number
	 * of bits required to convert {@code int} to a binary number.
	 *
	 * @return BinaryNumber the binary equivalent of the {@code int} represented by
	           {@code this} object.
	 */
    public BinaryNumber toBinaryNumber() {
        char[] bitArray = new char[Integer.SIZE];
        int i = value;
        for (int j = Integer.SIZE - 1; j >=0; j--) {
        	bitArray[j] = ((i & 1) == 0 ? '0' : '1');
        	i >>>= 1;
		}
		return BinaryNumber.newBinaryNumber(new String(bitArray));
    }

    @Override
    public String toString() {
		return value + "";
	}
	
}

DecimalNumberTest.java→All the test passed.

package com.manishaplastics.put;

import org.junit.Assert;
import org.junit.Test;
import java.util.Collection;
import java.util.Arrays;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
import com.manishaplastics.tlp.DecimalNumber;
import com.manishaplastics.tlp.BinaryNumber;
import org.junit.runner.JUnitCore;

@RunWith(Parameterized.class)
public class DecimalNumberTest {

    private static final BinaryNumber BIN_ZERO = BinaryNumber.newBinaryNumber("00000000000000000000000000000000");
    private static final BinaryNumber BIN_ONE = BinaryNumber.newBinaryNumber("00000000000000000000000000000001");
    private static final BinaryNumber BIN_MINUS_ONE = BinaryNumber.newBinaryNumber("11111111111111111111111111111111");
    private static final BinaryNumber BIN_MAX = BinaryNumber.newBinaryNumber("01111111111111111111111111111111");
    private static final BinaryNumber BIN_MIN = BinaryNumber.newBinaryNumber("10000000000000000000000000000000");
    private static final BinaryNumber BIN_RANDOM1 = BinaryNumber.newBinaryNumber("10111000110010110001101100110011");
    private static final BinaryNumber BIN_RANDOM2 = BinaryNumber.newBinaryNumber("00001101101001110101001011100100");

    private static final DecimalNumber DEC_ZERO = new DecimalNumber(0);
    private static final DecimalNumber DEC_ONE = new DecimalNumber(1);
    private static final DecimalNumber DEC_MINUS_ONE = new DecimalNumber(-1);
    private static final DecimalNumber DEC_MAX = new DecimalNumber(Integer.MAX_VALUE);
    private static final DecimalNumber DEC_MIN = new DecimalNumber(Integer.MIN_VALUE);
    private static final DecimalNumber DEC_RANDOM1 = new DecimalNumber(-1194648781);
    private static final DecimalNumber DEC_RANDOM2 = new DecimalNumber(229069540);

    private DecimalNumber decNumber;
    private BinaryNumber binNumber;

	@Parameters
	public static Collection<Object[]> Decimal_And_Binary_Numbers_For_Test() {
		return Arrays.asList(new Object[][] {
						{BIN_ZERO, DEC_ZERO},
						{BIN_ONE, DEC_ONE},
						{BIN_MINUS_ONE, DEC_MINUS_ONE},
						{BIN_MAX, DEC_MAX},
						{BIN_MIN, DEC_MIN},
						{BIN_RANDOM1, DEC_RANDOM1},
						{BIN_RANDOM2, DEC_RANDOM2}
					});
	}

	public DecimalNumberTest(BinaryNumber binNumber, DecimalNumber decNumber) {
		this.binNumber = binNumber;
		this.decNumber = decNumber;
	}

    @Test
    public void test_toBinaryNumber() {
        Assert.assertEquals(binNumber, decNumber.toBinaryNumber());
    }

    public static void main(String... args) {
        JUnitCore.main("com.manishaplastics.put.DecimalNumberTest");
    }

}

ConversionType.java

package com.manishaplastics.tlp;

/**
 * Enum for conversion from one base to another like from decimal to binary,
 * binary to decimal etc.Every constant represent a specific conversion type
 * like for Example: the {@link BinaryNumber#DECIMAL_TO_BINARY DECIMAL_TO_BINARY}
 * represent a conversion from base 10 to base 2.
 *
 * @author Praveen Kumar
 */
public enum ConversionType {
    
    /**
     * Represents a conversion type from base 10 to base 2.
     */
    DECIMAL_TO_BINARY {
		@Override
		public String convert(String arg) throws IllegalArgumentException {
			try {
				int integer = Integer.parseInt(arg);
				DecimalNumber decimalNum = new DecimalNumber(integer);
				return decimalNum.toBinaryNumber().toString();
			}
			catch (NumberFormatException cause) {
				throw new IllegalArgumentException(cause);
			}
		}
	},
	
	/**
	 * Represents a conversion type from base 2 to base 10.
     */
    BINARY_TO_DECIMAL {
		@Override
		public String convert(String arg) throws IllegalArgumentException {
			try {
				BinaryNumber binaryNum = BinaryNumber.newBinaryNumber(arg);
				int value = binaryNum.toDecimalInt();
				return "" + value;
			}
			catch (NullPointerException cause) {
				throw new IllegalArgumentException(cause);
			}
			catch (IllegalArgumentException cause) {
				throw new IllegalArgumentException(cause);
			}
			catch (IndexOutOfBoundsException cause) {
				throw new IllegalArgumentException(cause);
			}

		}
	};

    /**
     * Converts the argument to a string representing the another base and is equivalent
     * to the base represented by the argument.the conversion will take place accordingly
     * with the Enum constant {@code ConversionType}.
     *
     * @param arg the string representation of the base to be converted to another base.
	 * @return the string representation of a converted base.
	 * @throws IllegalArgumentException if the argument string is not parsable to the
	                                    base to be converted.
     */
    public abstract String convert(String arg) throws IllegalArgumentException;

}

ConversionTypeTest.java→All the test passed

package com.manishaplastics.put;

import org.junit.Before;
import org.junit.Test;
import org.junit.Assert;
import org.junit.runner.JUnitCore;
import com.manishaplastics.tlp.BinaryNumber;
import com.manishaplastics.tlp.DecimalNumber;
import com.manishaplastics.tlp.ConversionType;

public class ConversionTypeTest {

    private static final BinaryNumber BIN_ZERO = BinaryNumber.newBinaryNumber("00000000000000000000000000000000");
    private static final BinaryNumber BIN_ONE = BinaryNumber.newBinaryNumber("00000000000000000000000000000001");
    private static final BinaryNumber BIN_MINUS_ONE = BinaryNumber.newBinaryNumber("11111111111111111111111111111111");
    private static final BinaryNumber BIN_MAX = BinaryNumber.newBinaryNumber("01111111111111111111111111111111");
    private static final BinaryNumber BIN_MIN = BinaryNumber.newBinaryNumber("10000000000000000000000000000000");
    private static final BinaryNumber BIN_RANDOM1 = BinaryNumber.newBinaryNumber("10111000110010110001101100110011");
    private static final BinaryNumber BIN_RANDOM2 = BinaryNumber.newBinaryNumber("00001101101001110101001011100100");

    private static final DecimalNumber DEC_ZERO = new DecimalNumber(0);
    private static final DecimalNumber DEC_ONE = new DecimalNumber(1);
    private static final DecimalNumber DEC_MINUS_ONE = new DecimalNumber(-1);
    private static final DecimalNumber DEC_MAX = new DecimalNumber(Integer.MAX_VALUE);
    private static final DecimalNumber DEC_MIN = new DecimalNumber(Integer.MIN_VALUE);
    private static final DecimalNumber DEC_RANDOM1 = new DecimalNumber(-1194648781);
    private static final DecimalNumber DEC_RANDOM2 = new DecimalNumber(229069540);

    private BinaryNumber[] binArr;
    private DecimalNumber[] decArr;

    @Before
    public void setUp() {
		setBinAndDecNumberArrays();
	}

	private void setBinAndDecNumberArrays() {
		binArr = new BinaryNumber[] {
		                         BIN_ZERO, BIN_ONE, BIN_MINUS_ONE, BIN_MAX,
		                         BIN_MIN, BIN_RANDOM1, BIN_RANDOM2
		                     };


		decArr = new DecimalNumber[] {
		                         DEC_ZERO, DEC_ONE, DEC_MINUS_ONE, DEC_MAX,
		                         DEC_MIN, DEC_RANDOM1, DEC_RANDOM2
		                     };
	}


    @Test(expected = IllegalArgumentException.class)
    public void test_Decimal_TO_Binary_Conversion_For_Letters_As_Arg() {
        ConversionType.DECIMAL_TO_BINARY.convert("abc");
    }

    @Test(expected = IllegalArgumentException.class)
    public void test_Decimal_TO_Binary_Conversion_For_null_Arg() {
        ConversionType.DECIMAL_TO_BINARY.convert(null);
    }

    @Test
    public void test_Decimal_TO_Binary_Conversion() {
        for (int i = 0; i < binArr.length; i++) {
	    Assert.assertEquals(ConversionType.DECIMAL_TO_BINARY.convert(decArr[i].toString()), binArr[i].toString());
        }
    }

    @Test(expected = IllegalArgumentException.class)
    public void test_Binary_To_Decimal_Conversion_For_Digits_As_Arg() {
		ConversionType.BINARY_TO_DECIMAL.convert("11253");
	}

	@Test(expected = IllegalArgumentException.class)
	public void test_Binary_To_Decimal_Conversion_For_Letters_As_Arg() {
		ConversionType.BINARY_TO_DECIMAL.convert("abcde");
	}

	@Test(expected = IllegalArgumentException.class)
	public void test_Binary_To_Decimal_Conversion_For_null_As_Arg() {
		ConversionType.BINARY_TO_DECIMAL.convert(null);
	}

	@Test
	public void test_Binary_To_Decimal_Conversion() {
		for (int i = 0; i < binArr.length; i++) {
			Assert.assertEquals(ConversionType.BINARY_TO_DECIMAL.convert(binArr[i].toString()), decArr[i].toString());
        }
	}

    public static void main(String... args) {
        JUnitCore.main("com.manishaplastics.put.ConversionTypeTest");
    }

}

Converter.java

package com.manishaplastics.tlp;

public class Convertor {
    
    private final ConversionType conversionType;

    public Convertor(ConversionType conversionType) {
    	this.conversionType = conversionType;
    }

    public String convert(String arg) {
    	return conversionType.convert(arg);
    }

}

Junilu and knute i will request you to give some suggestions regarding the unit test i have done.as this is my first test code.

reply will be appreciated.

Kind regards,
Praveen.