EclipseGuard
EclipseGuard is an implementation of relative debugging
for the IBM Eclipse environment.
Using this approach, you can test
whether a new project performs the same tasks as a previous version,
and if it doesn't, you can debug
it using EclipseGuard's powerful assertion mechanism. EclipseGuard
builds on the already powerful techniques used in other test tools,
but allows you to trace errors down to an individual source line.
What's more, you don't need to capture large trace files, saving
both space and time.
Assertions between programs
Adding an assertion between projects is as simple as invoking
EclipseGuard. The control panel shown below appears. An assertion
describes locations in the two processes where the user assumes
that key data structures should be identical.
Once the dialogue box has appeared, you can add
assertions by:
- Right clicking on a variable in either
project source file.
- Select Guard -> Add Assertion on the
pop up context menu. This brings up a half filled Assertion
Dialog form, as shown below. The left hand side of the form
(Target 1) now describes the location at which you decided to
create an assertion.
- Without closing the ‘Assertion Dialog
’ window, perform the same ‘right click -> Guard
-> Add Assertion’ operation on same location within
the other project. The other half of the ‘Assertion Dialog’
window should fill with information (if it doesn’t, then
you may be performing the right click on the same project twice).
The 'Assertion Dialog’ window is now filled with information
describing the assertion (see figure below).
Reporting differences
EclipseGuard reports differences as they are detected, avoiding
the need for confusing post mortem reports and logs. The following
screen shows that the variable "count" in two different
projects was the same on the first 6 iterations of a loop, and
then differed. At that point, EclipseGuard halted the execution
and allowed the user to locate the fault using normal Eclipse
functionality. It couldn't be much easier!
How it works
Figure 1 shows a simplified schematic view of the architecture
of EclipseGuard under Eclipse. Eclipse is build around a core
‘shell’ with functionality being provided by commands
that are implemented by a set of ‘plugins’. These
plugins are conventional java classes that are activated as a
result of user interaction (such as menu selection) within Eclipse,
and also when various asynchronous events occur. This component
architecture makes it possible to integrate new functionality
into the environment by loading additional plugins.
Figure 1 - EclipseGuard Architecture
Figure 2 -Sample screen dump of EclipseGuard within IBM Eclipse
