1. JUnit test and Project 3 simulation

2. 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

3. 3 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)

4. 4 The Testing Problems programmers Should write few Do Why? I am so busy It is difficult

5. 5 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!

6. 6 JUnit The testing problems The framework of JUnit A case study

7. 7 The Framework of JUnit

8. 8 JUnit The testing problems The framework of JUnit A case study

9. 9 A Case Study Lab3Queue: enQueue method deQueue method

10. Include junit library in eclipse 10

11. 11 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

12. Create a test case 12

13. Create a test case import junit.framework.*; public class Lab3QueueTest { public void setUp() throws Exception { } public void tearDown() throws Exception { } 13

14. 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

15. Create a test case For each method that you are going to test: Write a corresponding test method named: test in the test case 15

16. 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

17. 17 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)

18. 18 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

19. Writing a test suite Step 2: Create a test suite by choosing 19

20. Writing a test suite 20

21. 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

22. Running a test 22 AllTests -> choose Run -> Run As -> Junit Test

23. Running a test 23

24. 24 Design Test Cases The real world scenarios The number boundaries

25. 25 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.

26. 26 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);

27. Project 3 - Algorithm 27

28. Recursion

29. 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. 30 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

31. Chapter 7: Recursion31 Steps to Design a Recursive Algorithm Step 1: There must be at least one case (the base case), for a small value of n, that can be solved directly Step 2: A problem of a given size n can be split into one or more smaller versions of the same problem (recursive case) Step 3: Recognize the base case and provide a solution to it Step 4: 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

32. Chapter 7: Recursion32 Steps to Design a Recursive Algorithm Step 1: There must be at least one case (the base case), for a small value of n, that can be solved directly Step 2: A problem of a given size n can be split into one or more smaller versions of the same problem (recursive case) Step 3: Recognize the base case and provide a solution to it Step 4: 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

33. Chapter 7: Recursion33 Steps to Design a Recursive Algorithm Step 1: There must be at least one case (the base case), for a small value of n, that can be solved directly Step 2: A problem of a given size n can be split into one or more smaller versions of the same problem (recursive case) Step 3: Recognize the base case and provide a solution to it Step 4: 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

34. Chapter 7: Recursion34 Steps to Design a Recursive Algorithm Step 1: There must be at least one case (the base case), for a small value of n, that can be solved directly Step 2: A problem of a given size n can be split into one or more smaller versions of the same problem (recursive case) Step 3: Recognize the base case and provide a solution to it Step 4: 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

35. Chapter 7: Recursion35 Steps to Design a Recursive Algorithm Step 1: There must be at least one case (the base case), for a small value of n, that can be solved directly Step 2: A problem of a given size n can be split into one or more smaller versions of the same problem (recursive case) Step 3: Recognize the base case and provide a solution to it Step 4: 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

36. Chapter 7: Recursion36 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

37. Chapter 7: Recursion37 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

38. Chapter 7: Recursion38 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

39. Chapter 7: Recursion39 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

40. 40 Efficiency of Recursion (continued) Efficient Inefficient

41. Chapter 7: Recursion41 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

42. Chapter 7: Recursion42 Algorithm for Recursive Linear Array Search

43. Chapter 7: Recursion43 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

44. Chapter 7: Recursion44 Design of a Binary Search Algorithm (continued)

45. Chapter 7: Recursion45 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

46. Chapter 7: Recursion46 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 Throws ClassCastException if the target is not comparable to the array elements

47. Chapter 7: Recursion47 Method Arrays.binarySearch (continued)

48. Chapter 7: Recursion48 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

49. Chapter 7: Recursion49 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

50. Chapter 7: Recursion50 Problem Solving with Recursion Will look at two problems Towers of Hanoi Counting cells in a blob

51. Chapter 7: Recursion51 Towers of Hanoi

52. Chapter 7: Recursion52 Towers of Hanoi (continued)

53. Chapter 7: Recursion53 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

54. Chapter 7: Recursion54 Counting Cells in a Blob (continued)

55. Chapter 7: Recursion55 Counting Cells in a Blob (continued)

56. Chapter 7: Recursion56 Counting Cells in a Blob (continued)

57. Chapter 7: Recursion57 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

58. Chapter 7: Recursion58 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

59. Chapter 7: Recursion59 Backtracking (continued)