JDebugTool 3.8.2 review

by rbytes.net on

JDebugTool is a standalone graphical Java debugger built on top of the standard JPDA (Java Platform Debugger Architecture). Here a

License: Shareware
File size: 0K
Developer: debugtools
0 stars award from rbytes.net

JDebugTool is a standalone graphical Java debugger built on top of the standard JPDA (Java Platform Debugger Architecture).

Here are some key features of "JDebugTool":
Built on top of the standard JPDA (Java Debugger Platform Architecture). JDebugTool should work with any JPDA compliant JVM. JDK 1.5, J2SDK 1.4, and JDK 1.3 are supported.
Debug Java Applications, Applets, Servlets and EJBs.
JDebugTool is totally written in Java itself.
The Java Swing GUI is logically divided into resizable panels and popup dialogs. Data is color coded, and displayed in trees and tables (tables can be sorted and table columns can be hidden or shown). There are tool tips, right-click popup context menus and keyboard accelerators throughout the GUI.
JDebugTool has an integrated Help Viewer. Context sensitive help is available throughout the GUI.
Change the Look and Feel of the GUI and also change globally the font size of the GUI.
Debugger settings are saved according to projects. There is always a default project, if you do not want to create any projects.
Each source file is displayed (syntax color coded) in its own tabbed pane. The left margin annotates the line numbers, breakpoints and the current Execution Point.
Launch a User definable External Text Editor in which to edit the currently displayed Java source file.
Find a particular string or go to a particular line number in a Source File.
List (and quickly navigate to) the methods of the main class in the currently displayed Source File.
Traverse your source code tree(s) and display selected source files.
Displays the hierarchy of classes (and inner classes) that have been loaded into the target JVM. The total number of classes currently loaded is displayed. For each package, the number of loaded classes is also displayed. For each class the attributes, methods and fields are displayed. The corresponding source code can be displayed for each class and its methods.
Set breakpoint(s) at a particular line number or method of a class. Breakpoints can be enabled, disabled and cleared.
Breakpoints can belong to breakpoint groups. Breakpoints can be cleared, enabled and disabled based on breakpoint group.
Stop execution when a particular exception or any uncaught exception is thrown. Debugger exceptions can be enabled and disabled.
The debugger supports the new J2SDK 1.4 chained exceptions feature -- each exception in the chain is displayed.
Stop on class field access (read), or modification (write) combined with comparison (==, !=, =) to a particular value. The watchpoint can be constrained to a particular object instance (J2SDK 1.4).
Stop execution on thread start and stop events -- filter by thread name or thread group.
Stop on class prepare and unload events -- filter by class name or package name with class name wild card.
Stop on method entry and exit events, selectable on a per thread basis.
Single step (step in, over and out of methods) and run to cursor, resume, suspend and restart execution.
The user can specify classes not to step into (like 3rd party packages).
View local variables (and types) in the current scope.
View class fields (and types) [including the inheritance hierarchy] in the current scope.
Watch key local variables and class (this) fields (and types) in the current scope. Also watch array and field accesses in the current scope, and also static fields.
View the fields (and types) of an object [including the inheritance hierarchy]. Object IDs are displayed throughout the GUI.
Invoke the toString() method on an object and view the resulting string.
View selected array ranges.
Modify the values of primitive variables directly in the GUI.
Interactively evaluate simple expressions including method calls.
View variables in the current scope (including array and field accesses, and static fields from other classes) in the source code as tool tips. View objects and selected array ranges in the current scope in popup dialogs.
View the current threads (including thread object ID, name, status and group). Change the current context of the debugger to a particular thread. Interrupt execution of a particular thread causing an InterruptedException to be thrown.
View the current stack backtrace and traverse individual stack frames to change the current context of the debugger.
The debugger can invoke the target JVM to be debugged. The main class and arguments, classpath, and JVM arguments can be specified.
If the debugger invoked the target JVM, then the (color-coded) standard input, output and error streams are displayed. The user can type the standard input to be sent to the target.
Debug the target JVM executing locally or remotely separated by a network.
The debugger can attach to a target JVM that has been invoked outside the debugger.
The debugger can listen for a target JVM (that has been invoked outside the debugger) to connect to the debugger.
Displays information about the target JVM such as the bootclasspath, the classpath, version and debugging capabilities.
Displays the debugging connectors supported by your host JVM.
Display the memory usage of both JDebugTool and also the target JVM.
Display the Java System properties of both JDebugTool and also the target JVM.
The debugger supports the new J2SDK 1.4 Hot Swap feature. This supports fix and continue debugging, and also updating a long running server program without restarting the server program.
The debugger supports the new J2SDK 1.4 Pop stack frame(s) feature. This supports re-executing method(s) particularly those that are Hot Swapped.


The debugger requires that the Java Software Developers Kit JDK 1.5.x (Java 5) or SDK 1.4.x or JDK 1.3.x be installed. JDebugTool is built on top of the standard JPDA (Java Platform Debugger Architecture), which must be supported by your JVM (Java Virtual Machine) in order to use JDebugTool.

The first time JDebugTool is invoked, JDebugTool will automatically copy the tools.jar file (containing the JPDA Debugger library), after prompting the user. The user will then need to restart JDebugTool.

Select Desktop Icon... from the JDebugTool Help menu for desktop icons that you can use to create a desktop shortcut to launch JDebugTool.

JDebugTool 3.8.2 keywords