1. Overview of Eclipse Lectures
Installing and Running
Building and Running Java Classes
Debugging
Testing with JUnit
Refactoring
Version Control with CVS
“Lecture 0”
Lecture 2
Let’s begin with an overview of Eclipse.
Lecture 3
CSC/ECE 517 Fall Lec. 2

2. Module Road Map Debugging Debug Perspective Debug Session Breakpoint
Overview
Installing and Running
Building and Running Java Classes
Debugging
Debug Perspective
Debug Session
Breakpoint
Debug Views
Breakpoint Types
Evaluating and Displaying Expressions
Testing with JUnit
Refactoring
Version Control with CVS
In this module, you will learn about Eclipse’s debugging facility
CSC/ECE 517 Fall Lec. 2

3. Debugging » Debugging in Eclipse
The Java Debugger
Part of Eclipse Java Development Tools (JDT)
More than System.out.printn(̎̎̎̎error̎̎̎̎)
Detects errors as code executes
Correct errors as code executes
Actions you can perform debugging include:
Control Execution
Set simple breakpoints
Set conditional breakpoints
Review and change variable values
Hot code replace (feature new to JRE 1.4)
CSC/ECE 517 Fall Lec. 2

4. Debugging » Debug Perspective
Threads and Monitor View
Variable View
Editor View
The debug perspective is a screen layout to help in debugging the code. It contains views that are specific for debugging. Perspective opens automatically when a breakpoint is hit during the execution of the Java application. However you need to run Java application in a debug mode, otherwise the execution will not stop at the breakpoint, and the breakpoint will be ignored.
Console View
Outline View
Tasks View
CSC/ECE 517 Fall Lec. 2

5. Debugging » Simple Breakpoint
Stops the execution of a program at the point
Thread suspends at the location where the breakpoint is set
Setting a breakpoint
CTRL+Shift+B at current point in editor line
Double click in editor’s marker bar at current line
Breakpoints can be set by:
Double-clicking on the left bar beside the line in the editor where you want to add the breakpoint
Choosing Add Breakpoint from the context menu on the bar in the editor
CSC/ECE 517 Fall Lec. 2

6. Debugging » Starting a Debugging Session
Select Java class containing the following:
main() method
Resulting execution will pass breakpoint
Select Run » Debug As » Java Application
Or Select Debug As » Java Application from the drop-down menu on the Debug tool bar.
Debugging session usually starts on a Java application, i.e. class containing the main() method. The debugging session can also start if you execute Java code from the Scrapbook and a breakpoint is encountered during the execution.
CSC/ECE 517 Fall Lec. 2

7. Debugging » Debug Session
Execution suspends prior to the line with a breakpoint
You can set multiple breakpoints
CSC/ECE 517 Fall Lec. 2

8. Debugging » Deleting Breakpoints
Double-click on the breakpoint in the editor
Another way to remove the breakpoint is by choosing Remove Breakpoint from the context menu on the breakpoint.
CSC/ECE 517 Fall Lec. 2

9. Debugging » Control Execution From Breakpoint…
Step Into or F5:
For methods, execute method and suspend on first statement in the method
For assignments, similar to Step Over
For conditionals, similar to Step Over
Step Over or F6
Execute next statement
Step Return or F7
Resume execution to the end of the method on the next line after it was invoked
Control Execution toolbar buttons are used for controlling the debugging session.
CSC/ECE 517 Fall Lec. 2

10. Debugging » Control Execution From Breakpoint
Resume or F8
Continue execution until program ends or another breakpoint is reached
Terminate
Stops the current execution thread
CSC/ECE 517 Fall Lec. 2

11. Debugging » Variables and Fields
To see the values bound to fields:
Use Variables View
Select variable in editor and select Inspect
CSC/ECE 517 Fall Lec. 2

12. Debugging » Code Debugging in this Module
public class Debug {
private int something = 0;
private Vector list = new Vector();
public void firstMethod(){
thirdMethod(something);
something = something + 1; }
public void secondMethod(){
something = something + 2;
public void thirdMethod(int value){
something = something + value;
public static void main(String[] args) {
Debug debug = new Debug();
debug.firstMethod();
debug.secondMethod();}
CSC/ECE 517 Fall Lec. 2

13. Debugging » Variables View
Shows all fields of instance where breakpoint occurred
Select this to see all fields
Select any field to see value
If field is bound to an object, you can select Inspect from the menu to view its fields and values
CSC/ECE 517 Fall Lec. 2

14. Debugging » Changing Field Values
To change field value:
Select field in Variables view
Select Change Variable Value from the menu
Enter new value into Set Variable Value window
Click OK
CSC/ECE 517 Fall Lec. 2

15. Debugging » Expressions View
Remembers all objects you have inspected
Displays the fields of the object
You can see the values of the fields
You can Inspect the fields
Opens when:
You Inspect an object
You click on the Expressions tab
Expression view is used with the Inspector. You can also invoke the view from a Scrapbook by selecting the Java code and choosing Inspect from the context menu.
CSC/ECE 517 Fall Lec. 2

16. Debugging » Breakpoint View
Lists all available breakpoints
Can be used for manipulating breakpoints (through the views menu):
Enabling
Disabling
Removing
Also displays breakpoints properties
Accessed like other debugging views
Breakpoint View can be opened by clicking on the Breakpoints tab in the Debugging Perspective.
Breakpoints can be manipulated in the Breakpoint View, meaning that you can remove, enable, or disable breakpoints. Double-clicking on the breakpoint in the view opens up an editor on the code where the breakpoint is set, and selects the line with the breakpoint.
Breakpoints properties are viewed by choosing Breakpoint Properties from the context menu on a breakpoint.
It is possible to set conditional breakpoints from the properties view. These breakpoints stop the execution only if the condition evaluates to true. To specify condition select the Enable Condition in the properties window and specify the condition.
CSC/ECE 517 Fall Lec. 2

17. Method and variables are shown in the editor for the selected frame
Debugging » Debug View
Shows:
Active threads
Current stack frame when execution has stopped
Previous stack frames
Method and variables are shown in the editor for the selected frame
Update in the editor updates the source
When you debug, an editor on code that you debug is available in the perspective. When the execution stops at the break point editor shows (highlights) the line where the breakpoint is. Using debugging controls results in editor showing different methods, variables, etc. You can change the code in the editor directly, save the change, and continue with the debugging.
CSC/ECE 517 Fall Lec. 2

18. Debugging » Breakpoint Types
Breakpoints can be set for the following Java entities:
Line (simple breakpoint)
Method
Field (watchpoint)
Java Exception
Each breakpoint is set a different way and has different properties
Watchpoint suspends execution when a particular field is about to be accessed.
CSC/ECE 517 Fall Lec. 2

19. Debugging » Method Breakpoints
To set method breakpoint:
Select method in the Outline View
From context menu select Toggle Method Breakpoint
To set breakpoint’s properties:
Select breakpoint in editor. From the context menu, select Breakpoint Properties.. from the context menu
In the Properties dialog, Check Enabled to enable the breakpoint
Check Hit Count to enable hit count. Breakpoint suspends execution of a thread the nth time it is hit, but never again, until it is re-enabled or the hit count is changed or disabled.
Choose Enable condition to have breakpoint enabled only if the specified condition occurs.
condition is 'true' option: Breakpoint stops if the condition evaluates to true. The expres-sion provided must be a boolean expression.
value of condition changes option: Breakpoint stops if result of the condition changes.
You cannot specify a condition for method breakpoints, i.e. methods breakpoints cannot be conditional.
CSC/ECE 517 Fall Lec. 2

20. Debugging » Field Breakpoints
Also known as watchpoint
To set the watchpoint:
Select field in the Outline View
From context menu select Toggle Watchpoint
To set watchpoint’s properties:
Select breakpoint in editor
Select Breakpoint Properties.. from context menu
Set properties as desired
Access/modification, enable
Execution suspended on access/modification of field
You cannot specify condition for field breakpoints, i.e. field breakpoints cannot be conditional.
CSC/ECE 517 Fall Lec. 2

21. Debugging » Java Exception Breakpoint
To Add Java Exception Point:
Select Run » Add Java Exception Breakpoint from main menu
Enter exception type
Specify what triggers a breakpoint:
Caught exception
Uncaught exception
Both
CSC/ECE 517 Fall Lec. 2

22. Debugging » How To Debug
Here are simple steps for debugging in Eclipse:
Set your breakpoints
Hit a breakpoint during execution
Walk/step through code to other breakpoints
Follow along in editor
Inspect/Display interesting fields
Watch the Console for things to happen
Debugging is an important facility of any development environment. Eclipse debugger contains facilities that help you in debugging the code. You will find that inspecting objects is probably most commonly used activity during the debugging. Watch what happens during the debugging, i.e. watch for field, variables values.
CSC/ECE 517 Fall Lec. 2

23. You have learned: The views in the Debug Perspective
Debugging » Summary
You have learned:
The views in the Debug Perspective
Typical debug session
How to use the Inspector
About the different types of breakpoints
How to set breakpoints
How step around your code doing debugging
CSC/ECE 517 Fall Lec. 2

24. What happens to the program execution?
Debugging » Exercise 2
Set a breakpoint in the printField method of the class NewClass that was created in Exercise 1.
Start a debug session.
What happens to the program execution?
What do you see in the debug windows?
CSC/ECE 517 Fall Lec. 2

25. Module Road Map Overview Installing and Running
Building and Running Java Classes
Debugging
Testing with JUnit
What is JUnit?
Where Does it Come From?
Working with Test Cases
Working with Test Suites
JUnit Window
Refactoring
Version Control with CVS
In this module, you will learn about Eclipse’s built-in JUnit facility.
CSC/ECE 517 Fall Lec. 2

26. What is JUnit? Regression testing framework
Written by Erich Gamma and Kent Beck
Used for unit testing in Java
Open Source
Released under IBM's CPL
Deugo’s presentation on JUnit:
CSC/ECE 517 Fall Lec. 2

27. Testing » Where Does JUnit Come From?
JUnit’s web site:
Eclipse includes JUnit
Eclipse provides new GUI to run JUnit test cases and suites
JDT tools include a plug-in that integrates JUnit into the Java IDE
Allows you to define regression tests for your code and run them from the Java IDE.
You can run your unit tests outside of Eclipse
If you wish using TestRunner
Using JUnit’s Window
TestRunner is explained at This sites introduces JUnit testing outside of Eclipse.
CSC/ECE 517 Fall Lec. 2

28. Testing » Including JUnit in a Project
In the Package window, right-click on the name of the project
Choose “Properties”; then select “Java Build Path”
Click on the “Libraries” tab, and then choose the “Add Library” button on the right.
Select “Junit” and click “Finish”.
CSC/ECE 517 Fall Lec. 2

29. Testing » Eclipse JUnit Setup
Eclipse preferences can be set in the JUnit Preferences window (Window » Preferences from the main menu. Expand Java in the Preferences window)
For the most part you can leave the preferences alone
Filters needed to identify packages, classes, or patterns that should not be shown in the stack trace of a test failure
CSC/ECE 517 Fall Lec. 2

30. Testing » JUnit Test Cases
Runs multiple tests
Implemented as subclass of TestCase
Define instance variables that store the state of the tests in the class
Initialize TestCase by overriding setUp method
Clean-up after test case is done by overriding tearDown method
The Test framework will invoke the setUp and tearDown methods.
CSC/ECE 517 Fall Lec. 2

31. Testing » Creating JUnit Test Cases in Eclipse
Create a new package to contain your test case classes
Add the JUnit JAR file to the project’s buildpath
CSC/ECE 517 Fall Lec. 2

32. Testing » Creating JUnit Test Cases in Eclipse
Select your testing package
From the context menu select New » JUnit Test Case. This opens the New JUnit Test Case Wizard.
Fill in the name of your test case in the Name field.
Select the method stubs that you want Eclipse to generate
This will create the corresponding class in your testing package
CSC/ECE 517 Fall Lec. 2

33. Testing » JUnit TestCase Template
public class NewTestCase extends TestCase {
public static void main(String[] args) { }
public NewTestCase(String arg0) {
super(arg0);
protected void setUp() throws Exception {
super.setUp();
protected void tearDown() throws Exception {
super.tearDown();
CSC/ECE 517 Fall Lec. 2

34. Testing » Adding Tests to Test Cases
Any method in a TestCase class is considered a test if it begins with the word “test”.
You can write many tests (have many test methods)
Each test method should use a variety of assert… methods to perform tests on the state of its class.
Assert methods are inherited
CSC/ECE 517 Fall Lec. 2

35. Testing » JUnit Assert Methods
Assert methods include:
assertEqual(x,y)
assertFalse(boolean)
assertTrue(boolean)
assertNull(object)
assertNotNull(object)
assetSame(firstObject, secondObject)
assertNotSame(firstObject, secondObject)
CSC/ECE 517 Fall Lec. 2

36. Testing » Adding Two Tests to JUnit Test Case
public class NewTestCase extends TestCase {
public static void main(String[] args) { }
public NewTestCase(String arg0) {
super(arg0);
protected void setUp() throws Exception {
super.setUp();
protected void tearDown() throws Exception {
super.tearDown();
public void testCompareSucceed() {
assertEquals(0, 0); //this assertion will succeed
public void testCompareFail() {
assertEquals(0, 1); //this assertion will fail
CSC/ECE 517 Fall Lec. 2

37. Testing » Running JUnit Test Case
Select TestCase class
From the Run menu select Run » Run As » JUnit Test
This will run the tests in your TestCase class along with the setUp and tearDown methods
You will then get a report in the JUnit window
CSC/ECE 517 Fall Lec. 2

38. Red indicates a test has failed You can see which test failed
Testing » JUnit Window
Red indicates a test has failed
You can see which test failed
You can see the call trace leading to the failure
If you wish to see the tests in TestCase click on the Hierarchy tab
CSC/ECE 517 Fall Lec. 2

39. You can see how many tests ran How many failures occurred
Testing » JUnit Window
You can see how many tests ran
How many failures occurred
You can see the details of the failure
Errors occur when exceptions are thrown
CSC/ECE 517 Fall Lec. 2

40. Testing » Creating JUnit Test Suite
Runs multiple test cases or suites
To create a TestSuite
Select your testing package
From the context menu select New » Other…
Then from the Wizard select Java » JUnit » JUnit Test Suite
Motivation for creating a JUnit Test Suite: Multiple classes can be tested at once.
CSC/ECE 517 Fall Lec. 2

41. Testing » Creating JUnit Test Suite
Fill in the name of your TestSuite class
Select the TestCases to include in your TestSuite
CSC/ECE 517 Fall Lec. 2

42. Testing » Unit Test Suite Template
import com.test;
import junit.framework.Test;
public class AllInclusiveTestSuite {
public static Test suite() {
TestSuite suite =
new TestSuite("Test for com.test");
//$JUnit-BEGIN$
suite.addTestSuite(NewTestCase.class));
suite.addTestSuite(SecondTestCase.class));
//$JUnit-END$
return suite; }
CSC/ECE 517 Fall Lec. 2

43. Testing » Running JUnit Test Suite
Select TestSuite class
From the Run menu select Run » Run As » JUnit Test
This will run the test cases in your TestSuite class
You will then get a report in the JUnit Window
CSC/ECE 517 Fall Lec. 2

44. Testing » JUnit Test Interface
The JUnit classes TestCase and TestSuite both implement the JUnit Test interface
Therefore, you can add JUnit TestSuites to other TestSuites
public static Test suite() {
TestSuite suite = new TestSuite("Test for testing");
//$JUnit-BEGIN$
suite.addTestSuite(FirstTestCase.class);
suite.addTestSuite(SecondTestCase.class);
suite.addTest(AllTests.suite());
//$JUnit-END$
return suite; }
Motivation for adding TestSuite to another TestSuite: Test suites written in another package (written by others) can be tested within a test suite in one shot.
CSC/ECE 517 Fall Lec. 2

45. Exercise 3
Create a JUnit test case class TestClass for the package csc517 of the project EgApp.
Add a test method testBoolean to the class TestClass.
In the method testBoolean, invoke the assert routine assertTrue with the argument “0” (FALSE).
Run the test case. What do you see in the JUnit window?
Now invoke the assertTrue routine with the argument “1” (TRUE).
Run the test case. What is the output in the JUnit window?
assertTrue is inherited
CSC/ECE 517 Fall Lec. 2