Subscribe

RSS Feed (xml)

Powered By

Skin Design:
Free Blogger Skins

Powered by Blogger

Friday, August 7, 2009

Assertions in Java

Hi friends,

The advent of J2SE 1.4 saw the introduction of few important changes to augment the power of java. Predominant among them are the java logging API, Chained exceptions, Assertions and so on. In this article we shall explore the concept of assertions and how they can add to the flexibility of the java language.
Assertions though a new concept introduced in the J2SE 1.4 specifications have been a well established practice in the programming community from the ages of the Eiffel programming language. Assertions, as stated above are not a new concept introduced by java; they have been around for a number of years in many object oriented programming languages. Assertions and exceptions derive themselves from the concept of "Design by Contract," which is followed in most of the object oriented languages. The design by contract theory states that an application is created or designed according to a contract or specification agreed upon by the creator and the consumer about the functioning of the application. Vendors and implementers have been asking for assertions to be included as a part of the specification. A good number of them have their private implementations of assertions.

* What are assertions?

To quote the text from the JSR 41 (Java Specification Request)
"An assertion is a statement containing a boolean expression that the programmer believes to be true at the time the statement is executed". In other words this means a facility provided within the java programming language to test the correctness or assumptions made by your program. The assumptions could be simple facts like a number cannot be negative or the range of a number is between 3.3 and 5.67. Assertions are checks provided within the system to ensure the smooth running of the program.

* Why Assertions:

The next obvious question that comes up is why we need another level of checking when exceptions can do the job. Java exceptions are primarily used to handle unusual conditions arising during program execution. Assertions are used to specify conditions that a programmer assumes are true. When programming, if a programmer can swear that the value being passed into a particular method is positive no matter what a calling client passes, it can be documented using an assertion to state it. Exceptions handle abnormal conditions arising in the course of the program; however they do not guarantee smooth or correct execution of the program. Assertions help state scenarios that ensure the program is running smoothly. Assertions can be efficient tools to ensure correct execution of a program. They improve the confidence about the program.
How to use Assertions:
The assertion statement has two forms.

assertExpression1;
assert Expression1:Expression2;


The first one is a simpler form that takes a boolean expression as an argument. The expression is the one the programmer wishes to assert as true. If the assumption fails, the expression evaluates to be false which means the assertion failed. In case the expression succeeds the program continues normally.
The second form is the more descriptive one. The first argument takes a Boolean expression, while the second expression would be the resulting action to be taken if the assertion fails. The Expression2 should be a value and can also be a result of executing a function. The compiler would throw an error if the second expression returns a void value.
As discussed before an assertion is not a replacement for an exception and cannot be used to show user level errors. User level errors need to be passed to an appropriate error handler and they need be presented to the user more gracefully. Assertions, like exceptions, throw an exception which would show them as part of the stack trace.
When an assertion fails the program would throw an AssertionError on to the stack trace. If the simpler form of assertion is used the program would create an object of AssertionError with the default constructor, while in the second form an object of AssertionError with the return type of Expression2. The overloaded AssertionError constructor would then convert the returned data type into String and dump it on the stack trace with a meaningful message. A few examples are shown below.

assert i<0;
assert (!myString.equals(""));
assert age>0 : "The value of age cannot be negative +"age;
assert ((i/2*23-12)>0):checkArgumentValue();
assert isParameterValid():throwIllegalParameterError();


In the last example the method checkArgumentValue() must return a value.

* Where to use Assertions:

As we stated earlier, assertions are not to replace exceptions but to augment them. Assertions should not be used at any place to ensure the smooth running of a program. The fact that assertions can be turned off could make your programs behave erratically.

So friends, Hope this information was usefull to you. PLease give your valuable feedback.

No comments: