Def#1:In computer
programming, a unit test is a method of testing the correctness
of a particular module of source code. The idea is to write test
cases for every non-trivial function or method in the module so
that each test case is separate from the others if possible.
Def#2:In computer
programming, a unit test is a procedure used to validate that a
particular module of source code is working properly. The
procedure is to write test cases for all functions and methods
so that whenever a change causes a regression, it can be quickly
identified and fixed. Ideally, each test case is separate from
the others; constructs such as mock objects can assist in
separating unit tests. This type of testing is mostly done by
the developers and not by end-users.
Why
unit test is
necessary -
The goal of unit testing is to
isolate each part of the program and show that the individual
parts are correct. Unit testing provides a strict, written
contract that the piece of code must satisfy. With effective
unit test, we can: Facilitates change
Unit testing allows the programmer to refactor code at a later
date, and make sure the module still works correctly (i.e.
regression testing). This provides the benefit of encouraging
programmers to make changes to the code since it is easy for the
programmer to check if the piece is still working properly. A
good set of unit test cases makes sure that every line of code
in the module executes. Simplifies integration
Unit testing helps eliminate uncertainty in the units themselves
and can be used in a bottom-up testing style approach. By
testing the parts of a program first and then testing the sum of
its parts, integration testing becomes much easier. Documentation
Unit testing provides a sort of "living document". Clients and
other developers looking to learn how to use the module can look
at the unit tests to determine how to use the module to fit
their needs and gain a basic understanding of the API. Separation of interface from implementation
Because some classes may have references to other classes,
testing a class can frequently spill over into testing another
class. A common example of this is classes that depend on a
database: in order to test the class, the tester often writes
code that interacts with the database. This is a mistake,
because a unit test should never go outside of its own class
boundary. As a result, the software developer abstracts an
interface around the database connection, and then implements
that interface with their own mock object. This results in
loosely coupled code, minimizing dependencies in the system.
Unit Testing is often associated with Extreme Programming.
Resources for unit test -
Parasoft Jtest ® An automated Java unit testing and coding standard analysis
product. It automatically generates and executes JUnit tests for
instant verification, and allows users to extend these tests. In
addition, it checks whether code follows over 500 coding
standard rules and automatically corrects violations of over 200
rules.
CppUnit CppUnit is a C++ unit testing framework. It started its life
as a port of JUnit to C++ by Michael Feathers.
dotunit dotunit is a port of JUnit (www.junit.org) to the
Microsoft .net platform. This testing framework allows for
automated unit and functional tests which are vital for
refactoring and regression testing.
JsUnit JsUnit is a simple framework to write repeatable tests in
JavaScript. It is an instance of the xUnit architecture for unit
testing frameworks. JsUnit is a port of JUnit 3.8.1 originally
written by Erich Gamma and Kent Beck. It covers the core system
and the examples.
HtmlUnit HtmlUnit is a java unit testing framework for testing web
based applications. It is similar in concept to httpunit but is
very different in implementation. Which one is better for you
depends on how you like to write your tests. HttpUnit models the
http protocol so you deal with request and response objects.
HtmlUnit on the other hand, models the returned document so that
you deal with pages and forms and tables.
HttpUnit Written in Java, HttpUnit emulates the relevant portions of
browser behavior, including form submission, JavaScript, basic
http authentication, cookies and automatic page redirection, and
allows Java test code to examine returned pages either as text,
an XML DOM, or containers of forms, tables, and links.
PerlUnit PerlUnit is a clone of JUnit for perl code unit test.
JUnit
JUnit is a simple framework to write repeatable tests. It is an
instance of the xUnit architecture for unit testing frameworks.
Search for more resources from the Internet...
How
unit test is done -
Owner Typically, programmers (developers) should be the owner of
Unit Test.
Test Techniques Both conventionally and as a well accepted industry
practice, unit testing is conducted in an automated environment
through the use of a third party supplied component or
framework. However, one reputable organization, the IEEE,
prescribes neither an automated nor a manual approach. A manual
approach to unit testing may employ a step-by-step instructional
document. Nevertheless, the objective in unit testing is to
isolate a unit and validate its correctness. Automation is much
more efficient for achieving this, and enables the many benefits
listed in this article. In fact, manual unit testing is arguably
a form of integration testing and thus precludes the achievement
of most (if not all) of the goals established for unit testing.
To fully realize the effect of isolation, the unit or code body
subjected to the unit test is executed within a framework
outside of its natural environment, that is, outside of the
product or calling context for which it was originally created.
Testing in an isolated manner has the benefit of revealing
unnecessary dependencies between the code being tested and other
units or data spaces in the product. These dependencies can then
be eliminated through refactoring, or if necessary, re-design.
Using a unit testing framework, the developer codifies criteria
into the unit test to verify the correctness of the unit under
test. During execution of the unit test(s), the framework logs
test cases that fail any criterion. Many frameworks will also
automatically flag and report in a summary these failed test
cases. Depending upon the severity of a failure, the framework
may halt subsequent testing.
As a consequence, unit testing is traditionally a motivator for
programmers to create decoupled and cohesive code bodies. This
practice promotes healthy habits in software development. Design
patterns, unit testing, and refactoring often work together so
that the most ideal solution may emerge.
Tips for Unit Test
Unit-testing will not catch every error in the program. By
definition, it only tests the functionality of the units
themselves. Therefore, it will not catch integration errors,
performance problems or any other system-wide issues. In
addition, it may not be easy to anticipate all special cases of
input the program unit under study may receive in reality. Unit
testing is only effective if it is used in conjunction with
other software testing activities.
It is unrealistic to test all possible input combinations for
any non-trivial piece of software. A unit test can only show the
presence of errors; it cannot show the absence of errors.
