Unit Testing
with JUnit
Iterative Software development
Write and execute unit tests
Write acceptance tests
Execute acceptance tests
increment
+ system
Written before Prioritized functionalities Executed after the development
2
Testing tools
Jemmy/Abbot/JFCUnit/
FIT/Fitnesse (High level)
GUI
Perfomance and Load Testing JMeter/JUnitPerf
Cactus
Business Logic
HttpUnit/Canoo/Selenium Junit (Low level)
Web UI
Persistence Layer
Junit/SQLUnit/XMLUnit
3
Testing with JUnit
Junit is a unit test environment for Java programs developed by Erich Gamma and Kent Beck. Writing test cases Executing test cases Pass/fail? (expected result = obtained result?) Consists in a framework providing all the tools for testing. framework: set of classes and conventions to use them. It is integrated into eclipse through a graphical plugin.
4
Junit (3.x and 4.x)
Test framework
test
cases are Java code test case = sequence of operations +inputs + expected
values
Production code int doubleOf2(){ // }
Test code testDoubleOf2(){
//..
doubleOf2();
//..
}
5
JUnit 3.x for testing programs
JUnit tests substitute the use of main() to check the program behaviour All we need to do is: [Link].* write a sub-class of TestCase add to it one or more test methods run the test using JUnit
Framework elements
TestCase Base class for classes that contain tests assert*() Method family to check conditions TestSuite Enables grouping several test cases
Testcase 1 Testsuite Testcase 2 Testcase 3
An example
class Stack { public boolean isEmpty(){ ... } public void push(int i){ ... } public int pop(){ ... } }
import [Link]; public class StackTester extends TestCase { public StackTester(String name) { super(name); } public void testStack() { Stack aStack = new Stack(); if(![Link]()) { [Link](Stack should be empty!); [Link](10); [Link](-4); [Link](Last element: + [Link]()); [Link](First element: +[Link]()); } }
Must begin with test
Method family to check conditions
Assert*()
They are public methods defined in the base class TestCase Their names begin with assert and are used in test methods
Ex: assertTrue(stack should be empty, [Link]());
If the condition is false: test fails execution skips the rest of the test method the message (if any) is printed If the condition is true: execution continues normally
9
Assert*()
for a boolean condition assertTrue(message for fail, condition); assertFalse(message, condition); obtained for object, int, long, and byte values assertEquals(expected_value, expression); for float and double values assertEquals(expected, expression, error); for objects references assertNull(reference) assertNotNull(reference)
[Link]
10
Assert: example
public void testStack() { Stack aStack = new Stack(); assertTrue(Stack should be empty!, [Link]()); [Link](10); assertTrue(Stack should not be empty!,![Link]()); [Link](4); assertEquals(4, [Link]()); assertEquals(10, [Link]()); } class Stack { public boolean isEmpty(){ ... } public void push(int i){ ... } public int pop(){ ... } }
11
Code Modularization
One concept at a time
public class StackTester extends TestCase { public void testStackEmpty() { Stack aStack = new Stack(); assertTrue(Stack should be empty!, [Link]()); [Link](10); assertTrue(Stack should not be empty!, ![Link]()); } public void testStackOperations() { Stack aStack = new Stack(); [Link](10); [Link](-4); assertEquals(-4, [Link]()); assertEquals(10, [Link]()); } }
12
Working rule
For each test case class, JUnit execute all of its public test methods i.e. those whose name starts with test ignores everything else Test classes can contain helper methods provided that are: non public, or whose name does not begin with test
13
TestSuite
Groups several test cases:
[Link].*
public class AllTests extends TestSuite {
public static TestSuite suite() { TestSuite suite = new TestSuite(); [Link]([Link]); [Link]([Link]); return suite; }
}
14
Test of Exceptions
There are two cases: 1. We expect a normal behavior and then no exceptions. 2. We expect an anomalous behavior and then an exception.
15
We expect a normal behavior
try { // We call the method with correct parameters [Link]("Parameter"); assertTrue(true); // OK } catch(PossibleException e){ fail(method should not fail !!!"); }
class TheClass { public void method(String p) throws PossibleException { /*... */ } }
16
We expect an exception
try { // we call the method with wrong parameters
[Link](null); fail(method should fail!!"); } catch(PossibleException e){ assertTrue(true); // OK } class TheClass {
public void method(String p) throws PossibleException { /*... */ } }
17
SetUp() and tearDown()
setUp() method initialize object(s) under test. called before every test method tearDown() method release object(s) under test called after every test case method.
ShoppingCart cart; Book book;
protected void setUp() { cart = new ShoppingCart(); book = new Book(JUnit", 29.95); [Link](book); }
18
Junit in eclipse - Setup
In Eclipse
Create
a new project Open projects property window (File -> Properties) Select: Java build path Select: libraries Add Library Select Junit
Select the type 3.x or 4.x
19
Create a new JUnit test case
Eclipse Menu
File Edit Source Refactor Navigate Search Project Run Window Help
File New Junit Test Case
Set the parameters: Junit 3.x or 4.x name of the class etc. Finish
20
Run as JUnit Test
Eclipse Menu
File Edit Source Refactor Navigate Search Project Run Window Help
Run Run As Junit Test
21
Red / Green Bar
Fail
Pass
expected <-3> but was <-4>
22
JUnit 3.x and JUnit 4.x
Most things are about equally easy JUnit 4 can still run JUnit 3 tests All the old assertXXX methods are the same JUnit 4 has some additional features JUnit 4 provides protection against infinite loops Junit 4 uses annotations (@)
23
From JUnit 3.x to 4.x
JUnit 4 requires Java 5 or newer Dont extend [Link]; just use an ordinary class Import [Link].* and [Link].*
Use a static import for [Link].* Static imports replace inheritance from [Link] Instead of a setUp method, put @Before before some method Instead of a tearDown method, put @After before some method Instead of beginning test method names with test, put @Test before each test method
Use annotations instead of special method names:
24
Annotations in J2SE
J2SE 5 introduces the Metadata feature (data about data) Annotations allow you to add decorations to your code (remember javadoc tags: @author ) Annotations are used for code documentation, compiler processing (@Deprecated ), code generation, runtime processing New annotations can be created by developers
[Link]
25
Annotations in J2SE an example
. @Override it is a predefined annotation used by the Java compiler
It informs the compiler that the element (a method) is meant to override an element declared in a superclass
// mark method as a superclass method // that has been overridden @Override public int overriddenMethod() { }
While it's not required to use this annotation when overriding a method, it helps to prevent errors. If a method marked with @Override fails in correctly overriding the original method in its superclass, the compiler generates an error.
26
Junit 4.x for testing programs
Import the JUnit 4 classes you need
import [Link].*; import static [Link].*;
Declare your (conventional) Java class
public class MyProgramTest {
Declare any variables you are going to use, e.g., an instance of the class being tested
MyProgram program; int [ ] array; int solution;
27
Junit 4.x for testing programs (2)
If needed, define one method to be executed just once, when the class is first loaded. For instance, when we need to connecting to a database
@BeforeClass public static void setUpClass() throws Exception { // one-time initialization code }
If needed, define one method to be executed just once, to do cleanup after all the tests have been completed
@AfterClass public static void tearDownClass() throws Exception { // one-time cleanup code }
28
Junit 4.x for testing programs (3)
If needed, define one or more methods to be executed before each test, e.g., typically for initializing values
@Before public void setUp() { program = new MyProgram(); array = new int[] { 1, 2, 3, 4, 5 }; }
If needed, define one or more methods to be executed after each test, e.g., typically for releasing resources (files, etc.)
@After public void tearDown() { }
29
@Before and @After methods
More than one @Before and/or @After methods can be defined in a test case
Attention: we dont know in what order they will execute
We can inherit @Before and @After methods from a superclass; execution is as follows:
Execute the @Before methods in the superclass Execute the @Before methods in this class Execute a @Test method in this class Execute the @After methods in this class Execute the @After methods in the superclass
30
Junit 4.x for testing programs (4)
- A test method is annotated with @Test - It takes no parameters, and returns no result. - All the usual assertXXX methods can be used
@Test public void sum() { assertEquals(15, [Link](array)); assertTrue([Link](array) > 0); }
31
Additional Features of @Test
To avoid infinite loops, an execution time limit can be used. The time limit is specified in milliseconds. The test fails if the method takes too long.
@Test (timeout=10) public void greatBig() { assertTrue([Link](5, 5) > 10e12); }
Some method calls should throw an exception. We can specify that an exception is expected. The test will pass if the expected exception is thrown, and fail otherwise
@Test (expected=[Link]) public void factorial() { [Link](-5); }
32
Parameterized tests
import [Link]; import [Link]; import [Link];
Using @RunWith(value=[Link]) and a method @Parameters, a test class is executed with several inputs
@RunWith(value=[Link]) public class FactorialTest { private long expected; private int value;
Parameters used to exercise different instances of the class
@Parameters public static Collection data() { return [Link]( new Object[ ][ ] { { 1, 0 }, { 1, 1 }, { 2, 2 }, { 120, 5 } }); } public FactorialTest(long expected, int value) { // constructor [Link] = expected; [Link] = value; } @Test public void factorial() { assertEquals(expected, new Calculator().factorial(value)); } }
33
Test suites
import [Link]; import [Link];
As before, you can define a suite of tests
@RunWith(value=[Link]) @SuiteClasses(value={ value=[Link], value=[Link] }) public class AllTests { }
It could be empty
34
Additional features of Junit 4
Instead of JUnit 3s AssertionFailedError, now failed tests throw an AssertionError There is now an additional version of assertEquals for arrays of objects: assertEquals(Object[] expected, Object[] actual) JUnit 3 had an assertEquals(p, p) method for each kind of primitive p, but JUnit 4 only has an assertEquals(object, object) and depends on autoboxing
@Override public boolean equals(Object o){ return ; }
35
Autoboxing example
Consider the following method:
long sum(long x, long y) { return x + y; } @Test public void sum() { assertEquals(4, [Link](2, 2)); }
and the following test:
assertEquals((long)4, [Link](2, 2));
it fails and gives:
expected: <4> but was: <4>
This is for the autoboxing
assertEquals no longer exists for primitives, only for objects! Hence, the 4 is autoboxed to an Integer, while sum returns a long The error message means: expected int 4, but got long 4 To make this work, change the 4 to a 4L or (long)4
Note that this problem has been fixed starting form JUnit 4.4
36
Summarizing an example (Junit 3.x)
public class Add { public static int sum (int a, int b) { return a+b; } }
import [Link]; import [Link]; public class TestCase1_add_Junit3 extends TestCase { public void testAdd() { Add add=new Add(); int sum=[Link](3, 2); assertEquals(5, sum); } }
Test case 1
37
Summarizing an example (Junit 3.x)
Test case 2
import [Link]; import [Link]; public class TestCase1_add_Junit3 extends TestCase { public void testAdd() { } public void testAdd_2() { Add add=new Add(); int sum=[Link](3, -2); assertEquals(5, sum); } }
38
Summarizing an example (Junit 3.x)
Test case 2
import [Link]; import [Link]; public class TestCase1_add_Junit3 extends TestCase { public void testAdd() { } public void testAdd_2() { Add add=new Add(); int sum=[Link](3, -2); assertEquals(5, sum); } }
39
Summarizing an example (Junit 4.x)
public class Add { public static int sum (int a, int b) { return a+b; } }
import [Link]; import [Link].*; import static [Link].*; public class Testcase1_add_Junit4 { @Test public void testAdd() { Add add=new Add(); int sum=[Link](3, 2); assertEquals(5, sum); } }
40
When testing programs?
Test last The conventional way for testing in which testing follows the implementation
Test first The Extreme-Programming view in which testing is used as a developement tool
41
Test last
New functionality
Understand
Implement functionality
Write tests Run all tests
fail
Rework
Result?
pass
Next functionality
42
Extreme programming (XP) champions the use of tests as a development tool
Test first
New functionality
Understand Add a single test Add code for the test Run all test
fail
Rework
Result?
pass
No
Next functionality
Yes
Functionality complete?
43
Test First Advantages
Each method has associated a testcase the confidence of our code increases It simplifies: refactoring/restructuring maintenance the introduction of new functionalities Test first help to build the documentation testcases are good use samples Programming is more fun
44
Test-first with Junit
Add the skeleton of the class and methods (without body)
Add a testcase
Run test
Rework
Refactoring improving the structure Run test
Junit in practice
Existing system: a class current account to
manage a bank account
deposit withdraw Add a new functionality settlement
Example: CurrentAccount cc = new CurrentAccount(); [Link](12); [Link](-8); [Link](10); [Link]() expected value
14 euro!
46
Add a testcase
47
Add Testcases for the settlement method
class Test_CurrentAccount extends TestCase{ public void test_settlementVoid() { CurrentAccount c = new CurrentAccount(); assertEquals(0, [Link]()); }
test first
public void test_settlement() { CurrentAccount c = new CurrentAccount(); [Link](12); [Link](-8); [Link](10); assertEquals(14, [Link]()); } }
Add the skeleton of the class and methods (without body)
49
class CurrentAccount { int account[]; int lastMove; CurrentAccount(){ lastMove=0; account=new int[10]; }
Add the skeletone code of the method
class Test_CurrentAccount extends TestCase{ public void test_settlementVoid() { currentAccount c = new currentAccount(); assertEquals(0, [Link]()); } public void test_settlement() { currentAccount c = new currentAccount(); [Link](12); [Link](-8); [Link](10); assertEquals(14, [Link]()); } }
public void deposit(int value){ account[lastMove]=value; lastMove++; }
public void draw(int value) { account[lastMove]=value; lastMove++; } public int settlement() {return 0;}
public static void main(String args[]) {} }
Run test
51
Run Junit (first time)
Rework
53
class CurrentAccount { int account[]; int lastMove; CurrentAccount(){ lastMove=0; account=new int[10]; } public void deposit(int value){ } public void draw(int value) { } public int settlement() { int result = 0 for (int i=0; i<[Link]; i++) { result = result + account[i]; } return result; } public static void main(String args[]) {} }
Rework
class Test_CurrentAccount extends TestCase{ public void test_settlementVoid() { currentAccount c = new currentAccount(); assertEquals(0, [Link]()); } public void test_settlement() { currentAccount c = new currentAccount(); [Link](12); [Link](-8); [Link](10); assertEquals(14, [Link]()); } }
Run test
55
Run Junit (second time)
Add a testcase
57
class CurrentAccount { int account[]; int lastMove; CurrentAccount(){ lastMove=0; account=new int[10]; }
Add a new testcase
class Test_currentAccount extends TestCase{
public void test_realCaseSettlement() { currentAccount c = new currentAccount(); for (int i=0; i <10 ; i++) [Link](1); [Link](-10); assertEquals(0, [Link]()); }
public void deposit(int value){ }
public void draw(int value) { } public int settlement() { int result = 0 for (int i=0; i<[Link]; i++) { result = result + account[i]; } return result; }
public static void main(String args[]) {} }
Run test
59
Run JUnit (third time)
Run time error
Rework
61
class CurrentAccount { int account[]; int lastMove; CurrentAccount(){ lastMove=0; account=new int[100]; }
Rework
class Test_currentAccount extends TestCase {
public void test_realCaseSettlement() { currentAccount c = new currentAccount(); for (int i=0; i <10 ; i++) [Link](1); [Link](-10); assertTrue(0, [Link]()); } }
public void deposit(int value){ }
public void draw(int value) { } public int settlement() { int result = 0 for (int i=0; i<[Link]; i++) { result = result + account[i]; } return result; }
public static void main(String args[]) {} }
Run test
63
Run JUnit (fourth time)
Refactoring improving the structure
65
public class CurrentAccount { List account = new LinkedList();
Refactoring
public void deposit(int value) { [Link](new Integer(value)); }
public void draw(int value) { [Link](new Integer(value)); } public int settlement() { int result = 0; Iterator it=[Link](); while ([Link]()) { Integer value_integer = (Integer)[Link](); int val = value_integer.intValue(); result = result + val; } return result; } }
changing the data structure: Array --> List
Run test
67
Run JUnit (fifth time)
The End
69
xUnit
Junit: it is one of many in the xUnit family. NUnit It is an open source unit testing framework for Microsoft .NET. It serves the same purpose as JUnit does in the Java world.
2.1 ActionScript 2.2 Ada 2.3 BPEL 2.4 C 2.5 C++ 2.6 ColdFusion (CFML) 2.7 Delphi 2.8 Emacs Lisp 2.9 Fortran 2.10 Haskell 2.11 Internet 2.12 Java 2.13 JavaScript 2.14 Lasso 2.15 MATLAB 2.16 MySQL 2.17 .NET programming languages 2.18 Objective-C 2.19 Ocaml 2.20 PegaRULES Process Commander
2.21 Perl 2.22 PHP 2.23 PL/SQL 2.24 PowerBuilder 2.25 Prolog 2.26 Python 2.27 REALbasic 2.28 Ruby 2.29 SAS 2.30 Scala 2.31 Shell 2.32 Simulink 2.33 Smalltalk 2.34 SQL 2.35 Tcl 2.36 Transact-SQL 2.37 Visual FoxPro 2.38 Visual Basic 2.39 XML 2.40 XSLT 2.41 Other
70
The tip of the iceberg
Coverage testing (JCoverage, Clover, ) Integration testing System/GUI testing (Jemmy, Abbot, ) Testing legacy applications Testing J2EE applications Testing database applications. Testing EJBs Testing Web applications (HttpUnit, JWebUnit, ) Testing Web services Testing in isolation with Mock Objects
71
