class EarlyReturnTarg {
static boolean debuggerWatching = false;
static int failureCount = 0;
/*
* These are the values that will be used by methods
* returning normally.
*/
static URL[] urls = new URL[1];
public static byte byteValue = 89;
public static char charValue = 'x';
public static double doubleValue = 2.2;
public static float floatValue = 3.3f;
public static int intValue = 1;
public static long longValue = Long.MAX_VALUE;
public static short shortValue = 8;
public static boolean booleanValue = false;
public static Class classValue = Object.class;
public static ClassLoader classLoaderValue;
{
try {
urls[0] = new URL("hi there");
} catch (java.net.MalformedURLException ee) {
}
classLoaderValue = new URLClassLoader(urls);
}
public static Thread threadValue = Thread.currentThread();
public static ThreadGroup threadGroupValue = threadValue.getThreadGroup();
public static String stringValue = "abc";
public static int[] intArrayValue = new int[] {1, 2, 3};
public static EarlyReturnTarg objectValue = new EarlyReturnTarg();
public String ivar = stringValue;
/*
* These are the values that will be used by methods
* returning early. These are != the normal values
* defined above.
*/
static URL[] eurls = new URL[1];
public static byte ebyteValue = 42;
public static char echarValue = 'a';
public static double edoubleValue = 6.6;
public static float efloatValue = 9.9f;
public static int eintValue = 7;
public static long elongValue = Long.MIN_VALUE;
public static short eshortValue = 3;
public static boolean ebooleanValue = true;
public static Class eclassValue = String.class;
public static ClassLoader eclassLoaderValue;
{
try {
urls[0] = new URL("been there, done that");
} catch (java.net.MalformedURLException ee) {
}
classLoaderValue = new URLClassLoader(urls);
}
public static Thread ethreadValue;
public static ThreadGroup ethreadGroupValue;
public static String estringValue = "wxyz";
public static int[] eintArrayValue = new int[] {10, 11, 12};
public static java.util.Date eobjectValue = new java.util.Date();
// Used to check the return values seen on the debugee side
public static boolean chk(byte v) {
return v == (debuggerWatching ? ebyteValue : byteValue);
}
public static boolean chk(char v) {
return v == (debuggerWatching ? echarValue : charValue);
}
public static boolean chk(double v) {
return v == (debuggerWatching ? edoubleValue : doubleValue);
}
public static boolean chk(float v) {
return v == (debuggerWatching ? efloatValue : floatValue);
}
public static boolean chk(int v) {
return v == (debuggerWatching ? eintValue : intValue);
}
public static boolean chk(long v) {
return v == (debuggerWatching ? elongValue : longValue);
}
public static boolean chk(short v) {
return v == (debuggerWatching ? eshortValue : shortValue);
}
public static boolean chk(boolean v) {
return v == (debuggerWatching ? ebooleanValue : booleanValue);
}
public static boolean chk(String v) {
return v.equals(debuggerWatching ? estringValue : stringValue);
}
public static boolean chk(Object v) {
return v.equals(debuggerWatching ? eobjectValue : objectValue);
}
// Used to show which set of tests follows
public static String s_show(String p1) {
return p1;
}
// These are the static methods
public static byte s_bytef(int p1) {
return byteValue;
}
public static char s_charf() {
return charValue;
}
public static double s_doublef() {
return doubleValue;
}
public static float s_floatf() {
return floatValue;
}
public static int s_intf() {
return intValue;
}
public static long s_longf() {
return longValue;
}
public static short s_shortf() {
return shortValue;
}
public static boolean s_booleanf() {
return booleanValue;
}
public static String s_stringf() {
return stringValue;
}
public static Class s_classf() {
return classValue;
}
public static ClassLoader s_classLoaderf() {
return classLoaderValue;
}
public static Thread s_threadf() {
return threadValue;
}
public static ThreadGroup s_threadGroupf() {
return threadGroupValue;
}
public static int[] s_intArrayf() {
return intArrayValue;
}
public static Object s_nullObjectf() {
return null;
}
public static Object s_objectf() {
return objectValue;
}
public static void s_voidf() {
System.err.println("debugee in s_voidf");
}
// These are the instance methods
public byte i_bytef(int p1) {
return byteValue;
}
public char i_charf() {
return charValue;
}
public double i_doublef() {
return doubleValue;
}
public float i_floatf() {
return floatValue;
}
public int i_intf() {
return intValue;
}
public long i_longf() {
return longValue;
}
public short i_shortf() {
return shortValue;
}
public boolean i_booleanf() {
return booleanValue;
}
public String i_stringf() {
return stringValue;
}
public Class i_classf() {
return classValue;
}
public ClassLoader i_classLoaderf() {
return classLoaderValue;
}
public Thread i_threadf() {
return threadValue;
}
public ThreadGroup i_threadGroupf() {
return threadGroupValue;
}
public int[] i_intArrayf() {
return intArrayValue;
}
public Object i_nullObjectf() {
return null;
}
public Object i_objectf() {
return objectValue;
}
public void i_voidf() {}
static void doit(EarlyReturnTarg xx) throws Exception {
System.err.print("debugee in doit ");
if (debuggerWatching) {
System.err.println("with a debugger watching. Early returns expected.");
} else {
System.err.println("with no debugger watching. Normal returns.");
}
s_show("========== Testing static methods ================");
if (!chk(s_bytef(88))) failureCount++;
if (!chk(s_charf())) failureCount++;
if (!chk(s_doublef())) failureCount++;
if (!chk(s_floatf())) failureCount++;
if (!chk(s_intf())) failureCount++;
if (!chk(s_longf())) failureCount++;
if (!chk(s_shortf())) failureCount++;
if (!chk(s_booleanf())) failureCount++;
if (!chk(s_stringf())) failureCount++;
s_classf();
s_classLoaderf();
s_threadf();
s_threadGroupf();
s_intArrayf();
s_nullObjectf();
if (!chk(s_objectf())) failureCount++;
s_voidf();
s_show("========== Testing instance methods ================");
if (!chk(xx.i_bytef(89))) failureCount++;
if (!chk(xx.i_charf())) failureCount++;
if (!chk(xx.i_doublef())) failureCount++;
if (!chk(xx.i_floatf())) failureCount++;
if (!chk(xx.i_intf())) failureCount++;
if (!chk(xx.i_longf())) failureCount++;
if (!chk(xx.i_shortf())) failureCount++;
if (!chk(xx.i_booleanf())) failureCount++;
if (!chk(xx.i_stringf())) failureCount++;
xx.i_intArrayf();
xx.i_classf();
xx.i_classLoaderf();
xx.i_threadf();
xx.i_threadGroupf();
xx.i_nullObjectf();
if (!chk(xx.i_objectf())) failureCount++;
xx.i_voidf();
}
/** Hang so that test fails */
static void hang() {
try {
// ten minute nap
Thread.currentThread().sleep(10 * 60 * 1000);
} catch (InterruptedException exc) {
// shouldn't happen
}
}
public static void main(String[] args) throws Exception {
// The debugger will stop at the start of main,
// set breakpoints and then do a resume.
System.err.println("debugee in main");
EarlyReturnTarg xx = new EarlyReturnTarg();
doit(xx);
if (debuggerWatching && failureCount > 0) {
hang();
throw new Exception("EarlyReturnTarg: failed");
}
}
}
