Debugging

Breakpoint Types

• Line Breakpoint:  This is the most familiar of the breakpoint types, which halts execution when a specified line in the source code is encountered during program execution.  To set a line breakpoint in Eclipse, double-click in the margin to the left of the line where you want the breakpoint to be placed.
  
  
• Method Breakpoint:  This type of breakpoint is used to halt execution when a specified method is invoked.  To set a method breakpoint in Eclipse, double-click in the margin to the left of the line defining the method name.
  
  
• Class Load Breakpoint:  This type of breakpoint is used to halt execution when a specified class is loaded.  This is especially useful when classes are loaded dynamically at runtime.  To set a class load breakpoint in Eclipse, double-click in the margin to the left of the line defining the class name.
  
  
• Exception Breakpoint:  This type of breakpoint is used to halt execution when a specified exception type is thrown at any time during execution.  To set an exception breakpoint in Eclipse, use the "Run -> Add Java Exception Breakpoint..." menu item.
  
  
• Watchpoint:  This type of breakpoint is used to halt execution when a specified field is read or modified.  This is especially useful because it allows you to watch a field without needing to add a breakpoint everywhere that it is read or modified throughout the code.  To set a watchpoint in Eclipse, double-click in the margin to the left of the line defining the field's name.
  

Breakpoint Properties

• Hit Count:  If a hit count is specified, the debugger will keep track of the number of times a breakpoint is "hit" and will only halt execution when the specified number is reached.  This is often useful when a line of code is in a loop, and you want to examine the program state at a specific iteration.
• Enable Condition:  An enable condition allows you to specify any boolean expression that will be evaluated each time a breakpoint is encountered.  Program execution will only be halted if the boolean expression evaluates to true.  This is useful in cases where a breakpoint may be hit many times in a program, but you only want to examine the program state under certain conditions.
  
• Suspend Policy:  This specifies whether the breakpoint should halt the execution of only the thread in which the breakpoint was encountered, or all threads within the virtual machine.

import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;


/**
 * DebugHash provides an executable program to print arbitrary values to
 * the screen in an infinite loop.  It is written in such a way that code
 * changes are very likely to change the output, and thus demonstrates the
 * utility of debuggers to instrument code without modifying it.
 *
 */
public class DebugHash {

	/**
	 * Using a supplied seed value, compute arbitrary (but repeatable) values
	 * based upon an underlying hashing algorithm.
	 * 
	 * @param seed - the seed used to determine the sequence of arbitrary values.
	 */
	private static void printArbitraryHashes(byte seed) {
		MessageDigest md5 = null;
		try {
			md5 = MessageDigest.getInstance("MD5");
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
			System.exit(-1);
		}
		
		byte[] last_hash = {seed};

		while (true) {
			md5.update(last_hash);
			byte[] new_hash = md5.digest();
			
			String hashString = getHashString(new_hash);
			System.out.println(hashString);
			
			last_hash = new_hash;
		}
	}
	
	/**
	 * Translate a given byte array into a hexadecimal String represention of 
	 * the given array.
	 * 
	 * @param hash - the byte array to be translated.
	 * @return - the hexadecimal String representation.
	 */
	private static String getHashString(byte[] hash) {
		return String.format("%032x", new BigInteger(1, hash));
	}
	
	/**
	 * Entry-point for this executable class.
	 * 
	 * @param args - the command line parameters (unused by this program).
	 */
	public static void main(String[] args) {
		byte seed = 0;
		for (StackTraceElement element: Thread.currentThread().getStackTrace()) {
			seed += element.getLineNumber();
		}
		
		printArbitraryHashes(seed);
	}
}

• Java Debugging with Eclipse - Tutorial