JUnit test and Project 3
simulation
Midterm Exam
Wednesday, March 18, 2009
 Content: Week 1 to Week 9
 Guideline: posted on D2L.
 Format:
Multiple choices
 Simple problem solving questions
 Writing code

2
JUnit
The testing problems
 The framework of JUnit
 A case study

Acknowledgement: using some materials from JUNIT
tutorial by Hong Qing Yu
(www.cs.le.ac.uk/people/hqy1)
3
The Testing Problems
Should write
Do
programmers
few
Why?
I am so busy
It is difficult
4
The Testing Problems
Programmers need such kind of tool:
“Writing a few lines of code, then a test that should run, or even
better, to write a test that won't run, then write the code that will
make it run.”
JUnit is that kind of tool!
5
JUnit
The testing problems
 The framework of JUnit
 A case study

6
The Framework of JUnit
7
JUnit
The testing problems
 The framework of JUnit
 A case study

8
A Case Study

Lab3Queue:
enQueue method
 deQueue method

9
Include junit library in eclipse
10
How to Write A TestCase using Junit
(available in Eclipse 3.1 or later)

Step 1:Create a JUNIT test case (File ->
New -> Junit Test Case
11
Create a test case
12
Create a test case
import junit.framework.*;
public class Lab3QueueTest {
public void setUp() throws Exception {
}
public void tearDown() throws Exception {
}
}
13
Create a test case
import junit.framework.*;
public class Lab3QueueTest extends TestCase {
Lab3Queue testQueue;
int queueSize;
public void setUp() throws Exception {
testQueue = new Lab3Queue();
queueSize = testQueue.getSize();
}
public void tearDown() throws Exception {
}
}
14
Create a test case

For each method that you are going to
test:

Write a corresponding test method named:
test<method name> in the test case
15
Create a test case
public void testenQueue() {
int newItem = 1;
queueSize = testQueue.getSize();
testQueue.enQueue(newItem);
Assert.assertEquals(queueSize+1, testQueue.getSize());
int actualItem = ((Integer) testQueue.getLastNode()).intValue();
Assert.assertEquals(newItem, actualItem);
}
16
Assert

assertEquals(expected, actual)
 assertEquals(message, expected, actual)
 assertEquals(expected, actual, delta)
 assertEquals(message, expected, actual, delta)
 assertFalse(condition)
 assertFalse(message, condition)
 Assert(Not)Null(object)
 Assert(Not)Null(message, object)
 Assert(Not)Same(expected, actual)
 Assert(Not)Same(message, expected, actual)
 assertTrue(condition)
 assertTrue(message, condition)
17
Structure

setUp()
Storing the fixture's objects in instance variables of your
TestCase subclass and initialize them by overriding the setUp
method

tearDown()
Releasing the fixture’s
18
Writing a test suite
Step 2: Create a test suite by choosing
19
Writing a test suite
20
Writing a test suite
import junit.framework.Test;
import junit.framework.TestSuite;
public class AllTests {
public static Test suite() {
TestSuite suite = new TestSuite("Test for AiportSimulation");
//$JUnit-BEGIN$
suite.addTestSuite(Lab3QueueTest.class);
//$JUnit-END$
return suite;
}
}
21
Running a test
AllTests -> choose Run -> Run As -> Junit Test
22
Running a test
23
Design Test Cases


The real world scenarios
The number boundaries
24
Tips
Testcases must extend TestCase
All ‘test’ methods must include at least one call to
an assert method or to fail:
assertEquals (String message, ...)
assertNotNull (String message, Object obj)
assertNull (String message, Object obj)
assertSame (String message, Obj exp, Obj
actual)
assertTrue (String message, boolean condition)
fail (String message)
Remove System.out.println after test cases are working
and rely on Junit assert methods to determine
success/failure.
25
Dynamic Run
Since JUnit 2.0 there is an even simpler
dynamic way. You only pass the class with
the tests to a TestSuite and it extracts the
test methods automatically.
suite.addTestSuite(Lab3QueueTest.class);
26
Project 3 - Algorithm
27
Recursion
Recursive Thinking
Recursion is a problem-solving approach
that can be used to generate simple
solutions to certain kinds of problems
that would be difficult to solve in other
ways
 Recursion splits a problem into one or
more simpler versions of itself

29
Recursive Thinking
Recursion is a problem-solving approach
that can be used to generate simple
solutions to certain kinds of problems
that would be difficult to solve in other
ways
 Recursion splits a problem into one or
more simpler versions of itself

30
Steps to Design a Recursive
Algorithm

Step 1:


Step 2:


Recognize the base case and provide a solution to it
Step 4:


A problem of a given size n can be split into one or more
smaller versions of the same problem (recursive case)
Step 3:


There must be at least one case (the base case), for a small
value of n, that can be solved directly
Devise a strategy to split the problem into smaller versions of
itself while making progress toward the base case
Step 5:

Combine the solutions of the smaller problems in such a way
as to solve the larger problem
Chapter 7: Recursion
31
Steps to Design a Recursive
Algorithm

Step 1:


Step 2:


Recognize the base case and provide a solution to it
Step 4:


A problem of a given size n can be split into one or more
smaller versions of the same problem (recursive case)
Step 3:


There must be at least one case (the base case), for a small
value of n, that can be solved directly
Devise a strategy to split the problem into smaller versions of
itself while making progress toward the base case
Step 5:

Combine the solutions of the smaller problems in such a way
as to solve the larger problem
Chapter 7: Recursion
32
Steps to Design a Recursive
Algorithm

Step 1:


Step 2:


Recognize the base case and provide a solution to it
Step 4:


A problem of a given size n can be split into one or more
smaller versions of the same problem (recursive case)
Step 3:


There must be at least one case (the base case), for a small
value of n, that can be solved directly
Devise a strategy to split the problem into smaller versions of
itself while making progress toward the base case
Step 5:

Combine the solutions of the smaller problems in such a way
as to solve the larger problem
Chapter 7: Recursion
33
Steps to Design a Recursive
Algorithm

Step 1:


Step 2:


Recognize the base case and provide a solution to it
Step 4:


A problem of a given size n can be split into one or more
smaller versions of the same problem (recursive case)
Step 3:


There must be at least one case (the base case), for a small
value of n, that can be solved directly
Devise a strategy to split the problem into smaller versions of
itself while making progress toward the base case
Step 5:

Combine the solutions of the smaller problems in such a way
as to solve the larger problem
Chapter 7: Recursion
34
Steps to Design a Recursive
Algorithm

Step 1:


Step 2:


Recognize the base case and provide a solution to it
Step 4:


A problem of a given size n can be split into one or more
smaller versions of the same problem (recursive case)
Step 3:


There must be at least one case (the base case), for a small
value of n, that can be solved directly
Devise a strategy to split the problem into smaller versions of
itself while making progress toward the base case
Step 5:

Combine the solutions of the smaller problems in such a way
as to solve the larger problem
Chapter 7: Recursion
35
Proving that a Recursive Method is
Correct

Proof by induction



Prove the theorem is true for the base case
Show that if the theorem is assumed true for n, then
it must be true for n+1
Recursive proof is similar to induction



Verify the base case is recognized and solved
correctly
Verify that each recursive case makes progress
towards the base case
Verify that if all smaller problems are solved
correctly, then the original problem is also solved
correctly
Chapter 7: Recursion
36
Recursive Definitions of
Mathematical Formulas

Mathematicians often use recursive definitions
of formulas that lead very naturally to recursive
algorithms
 Examples include:




Factorial
Powers
Greatest common divisor
If a recursive function never reaches its base
case, a stack overflow error occurs
Chapter 7: Recursion
37
Recursion Versus Iteration





There are similarities between recursion and
iteration
In iteration, a loop repetition condition
determines whether to repeat the loop body or
exit from the loop
In recursion, the condition usually tests for a
base case
You can always write an iterative solution to a
problem that is solvable by recursion
Recursive code may be simpler than an
iterative algorithm and thus easier to write,
read, and debug
Chapter 7: Recursion
38
Efficiency of Recursion

Recursive methods often have slower
execution times when compared to their
iterative counterparts
 The overhead for loop repetition is smaller than
the overhead for a method call and return
 If it is easier to conceptualize an algorithm using
recursion, then you should code it as a recursive
method

The reduction in efficiency does not outweigh the
advantage of readable code that is easy to debug
Chapter 7: Recursion
39
Efficiency of Recursion (continued)
Inefficient
Efficient
40
Recursive Array Search

Searching an array can be accomplished using
recursion
 Simplest way to search is a linear search


Examine one element at a time starting with the first
element and ending with the last
Base case for recursive search is an empty
array

Result is negative one

Another base case would be when the array
element being examined matches the target
 Recursive step is to search the rest of the array,
excluding the element just examined
Chapter 7: Recursion
41
Algorithm for Recursive Linear Array
Search
Chapter 7: Recursion
42
Design of a Binary Search Algorithm
Binary search can be performed only on
an array that has been sorted
 Stop cases

The array is empty
 Element being examined matches the target

Checks the middle element for a match
with the target
 Throw away the half of the array that the
target cannot lie within

Chapter 7: Recursion
43
Design of a Binary Search Algorithm
(continued)
Chapter 7: Recursion
44
Efficiency of Binary Search and the
Comparable Interface

At each recursive call we eliminate half
the array elements from consideration


O(log2 n)
Classes that implement the Comparable
interface must define a compareTo
method that enables its objects to be
compared in a standard way

CompareTo allows one to define the
ordering of elements for their own classes
Chapter 7: Recursion
45
Method Arrays.binarySearch

Java API class Arrays contains a
binarySearch method
Can be called with sorted arrays of primitive
types or with sorted arrays of objects
 If the objects in the array are not mutually
comparable or if the array is not sorted, the
results are undefined
 If there are multiple copies of the target
value in the array, there is no guarantee
which one will be found
Chapter 7: Recursion
 Throws ClassCastException
if the target is 46

Method Arrays.binarySearch
(continued)
Chapter 7: Recursion
47
Recursive Data Structures

Computer scientists often encounter data
structures that are defined recursively

Trees (Chapter 8) are defined recursively

Linked list can be described as a recursive
data structure
 Recursive methods provide a very natural
mechanism for processing recursive data
structures
 The first language developed for artificial
intelligence research was a recursive
language called LISP
Chapter 7: Recursion
48
Recursive Definition of a Linked List
A non-empty linked list is a collection of
nodes such that each node references
another linked list consisting of the
nodes that follow it in the list
 The last node references an empty list
 A linked list is empty, or it contains a
node, called the list head, that stores
data and a reference to a linked list

Chapter 7: Recursion
49
Problem Solving with Recursion

Will look at two problems
Towers of Hanoi
 Counting cells in a blob

Chapter 7: Recursion
50
Towers of Hanoi
Chapter 7: Recursion
51
Towers of Hanoi (continued)
Chapter 7: Recursion
52
Counting Cells in a Blob


Consider how we might process an image
that is presented as a two-dimensional
array of color values
Information in the image may come from





X-Ray
MRI
Satellite imagery
Etc.
Goal is to determine the size of any area in
the image that is considered abnormal
because of its color values
Chapter 7: Recursion
53
Counting Cells in a Blob (continued)
Chapter 7: Recursion
54
Counting Cells in a Blob (continued)
Chapter 7: Recursion
55
Counting Cells in a Blob (continued)
Chapter 7: Recursion
56
Backtracking

Backtracking is an approach to implementing
systematic trial and error in a search for a solution


An example is finding a path through a maze
If you are attempting to walk through a maze, you
will probably walk down a path as far as you can go



Eventually, you will reach your destination or you won’t be
able to go any farther
If you can’t go any farther, you will need to retrace your steps
Backtracking is a systematic approach to trying
alternative paths and eliminating them if they don’t
work
Chapter 7: Recursion
57
Backtracking (continued)

Never try the exact same path more than once, and
you will eventually find a solution path if one exists
 Problems that are solved by backtracking can be
described as a set of choices made by some
method
 Recursion allows us to implement backtracking in a
relatively straightforward manner


Each activation frame is used to remember the choice
that was made at that particular decision point
A program that plays chess may involve some kind
of backtracking algorithm
Chapter 7: Recursion
58
Backtracking (continued)
Chapter 7: Recursion
59