| /******************************************************************************* |
| * Copyright (c) 2000, 2015 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.debug.jdi.tests.program; |
| |
| |
| import java.io.OutputStream; |
| import java.io.PrintWriter; |
| import java.util.Date; |
| |
| import org.eclipse.debug.jdi.tests.ClassTypeTest; |
| |
| /** |
| * Main class for target VM tests. |
| * This class is intended to be run by the target VM. |
| * It will use other classes in this package, and it will create and terminate |
| * threads as a regular program would do. |
| * |
| * WARNING, WARNING: |
| * Tests in org.eclipse.debug.jdi.tests assume the content of this class, |
| * as well as its behavior. So if this class or one of the types in this |
| * package is changed, the corresponding tests must also be changed. |
| */ |
| public class MainClass extends Date implements Runnable, Printable { |
| |
| private static byte[] byteArray = new byte[0]; |
| private static byte[][] byteDoubleArray = new byte[0][0]; |
| private static short[] shortArray = new short[0]; |
| private static short[][] shortDoubleArray = new short[0][0]; |
| private static int[] intArray = new int[0]; |
| private static int[][] intDoubleArray = new int[0][0]; |
| private static long[] longArray = new long[0]; |
| private static long[][] longDoubleArray = new long[0][0]; |
| private static double[] doubleArray = new double[0]; |
| private static double[][] doubleDoubleArray = new double[0][0]; |
| private static float[] floatArray = new float[0]; |
| private static float[][] floatDoubleArray = new float[0][0]; |
| private static char[] charArray = new char[0]; |
| private static char[][] charDoubleArray = new char[0][0]; |
| private static boolean[] booleanArray = new boolean[0]; |
| private static boolean[][] booleanDoubleArray = new boolean[0][0]; |
| |
| private String string = ""; |
| private String[] stringArray = new String[0]; |
| private String[][] stringDoubleArray = new String[0][0]; |
| |
| /** |
| * An integer value |
| */ |
| public static int fInt = 0; |
| |
| /** |
| * The instance of the <code>MainClass</code> |
| */ |
| public static MainClass fObject = new MainClass(); |
| |
| /** |
| * A string initialized to 'hello world' |
| */ |
| public static String fString = "Hello World"; |
| |
| /** |
| * A <code>Thread</code> object |
| */ |
| public static Thread fThread; |
| |
| /** |
| * A <code>Thread</code> object representing the main thread |
| */ |
| public static Thread fMainThread; |
| |
| /** |
| */ |
| public static String[] fArray = new String[] { "foo", "bar", "hop" }; |
| |
| /** |
| * A pre-initialized array of doubles |
| */ |
| public static double[] fDoubleArray = new double[] { 1, 2.2, 3.33 }; |
| |
| /** |
| * The name of an event type |
| */ |
| public static String fEventType = ""; |
| |
| /** |
| * A boolean value initialized to <code>false</code> |
| */ |
| public boolean fBool = false; |
| |
| private char fChar = 'a'; |
| |
| private String fString2 = "Hello"; |
| |
| protected final String fString3 = "HEY"; |
| |
| /** |
| * Constructor |
| */ |
| public MainClass() {} |
| |
| /** |
| * Constructor |
| * Used to test ClassType.newInstance |
| * @see ClassTypeTest |
| * @param i |
| * @param o1 |
| * @param o2 |
| */ |
| public MainClass(int i, Object o1, Object o2) { |
| } |
| |
| /** |
| * For invocation tests |
| * @param x the integer |
| * @param o |
| * @return a string object representing the specified interger value |
| */ |
| private static String invoke1(int x, Object o) { |
| if (o == null) { |
| return (new Integer(x)).toString(); |
| } else { |
| return ""; |
| } |
| } |
| /** |
| * For invocation tests |
| */ |
| private static void invoke2() { |
| throw new IndexOutOfBoundsException(); |
| } |
| |
| /** |
| * For invocation tests |
| * @param str |
| * @param o |
| * @return an the integer value of the specified string |
| */ |
| private int invoke3(String str, Object o) { |
| return Integer.parseInt(str); |
| } |
| /** |
| * For invocation tests |
| * @return nothing, only throws an exception |
| * @throws java.io.EOFException |
| */ |
| private long invoke4() throws java.io.EOFException { |
| throw new java.io.EOFException(); |
| } |
| /** |
| * For variables test |
| * @param l |
| */ |
| private void variablesTest(long l) {} |
| |
| /** |
| * Runs the test program |
| * @param args |
| */ |
| public static void main(java.lang.String[] args) { |
| // Start the test program |
| ThreadGroup group = new ThreadGroup("Test ThreadGroup"); |
| fThread = new Thread(group, fObject, "Test Thread"); |
| fThread.start(); |
| |
| fMainThread = Thread.currentThread(); |
| |
| // Prevent this thread from dying |
| while (true) { |
| try { |
| Thread.sleep(1000); |
| } catch (InterruptedException e) { |
| } |
| } |
| } |
| /** |
| * @see org.eclipse.debug.jdi.tests.program.Printable#print(java.io.OutputStream) |
| */ |
| @Override |
| public void print(OutputStream out) { |
| String string = fInt++ +". " + fString; |
| PrintWriter writer = new PrintWriter(out); |
| writer.println(string); |
| writer.flush(); |
| } |
| |
| /** |
| * Prints out a specified integer. This method is used in the force early return tests to ensure we |
| * can specify a different, type compatible return value |
| * @param out a stream to print out to |
| * @param num the number we want to print and return |
| * @return the specified number parameter, just pass it through |
| * @since 3.3 |
| */ |
| public int printNumber(OutputStream out, int num) { |
| String blah = "foo"+foo(); |
| PrintWriter writer = new PrintWriter(out); |
| writer.println("The specified number is: "+num); |
| writer.flush(); |
| return num; |
| } |
| |
| /** |
| * Returns 20 |
| * |
| * @return 20 |
| */ |
| public int getInt() { |
| int x = Math.max(20, 10); |
| return x; |
| } |
| |
| /** |
| * Returns true. |
| * |
| * @return true |
| */ |
| public boolean getBoolean() { |
| boolean bool = Boolean.valueOf("true").booleanValue(); |
| return bool; |
| } |
| |
| /** |
| * Returns 123L. |
| * |
| * @return 123 |
| */ |
| public long getLong() { |
| long l = Long.valueOf("123").longValue(); |
| return l; |
| } |
| |
| /** |
| * dump out a string |
| * @return a String |
| * @since 3.3 |
| */ |
| public String foo() { |
| System.out.println("foobar"); |
| return "man"; |
| } |
| |
| /** |
| * make a sync'd method so we can stop in it to gather monitor information |
| * @since 3.3 |
| */ |
| synchronized public void sync() { |
| System.out.println("sync'd to the moon"); |
| } |
| |
| /** |
| * suspend on the first line of the method to get the argument values from the stackframe. |
| * used in testing the new 1.6VM capability to get argument values when no debugging info is available. |
| * @param str a string |
| * @param num a number |
| * @param obj an object |
| * @since 3.3 |
| */ |
| public void argValues(String str, int num, Object obj) { |
| System.out.println("get the arg values"); |
| } |
| |
| /** |
| * Prints to System.out and throws an exception to indicate readiness |
| */ |
| synchronized public void printAndSignal() { |
| print(System.out); |
| // Signal readiness by throwing an exception |
| try { |
| throw new NegativeArraySizeException(); |
| } catch (NegativeArraySizeException exc) { |
| } |
| } |
| |
| /** |
| * @see java.lang.Runnable#run() |
| */ |
| @Override |
| public void run() { |
| try { |
| Thread t = Thread.currentThread(); |
| MainClass o = new OtherClass(); |
| // The front-end tests use the class load event to determine that the program has started |
| |
| if (CONSTANT == 2) { |
| System.out.println("CONSTANT=2"); |
| } |
| |
| while (true) { |
| printAndSignal(); |
| triggerEvent(); |
| useLocalVars(t, o); |
| try { |
| Thread.sleep(1000); |
| } catch (InterruptedException e) { |
| } |
| } |
| } finally { |
| System.out.println("Running finally block in MainClass.run()"); |
| } |
| } |
| /** |
| * Trigger an access watchpoint event for the front-end. |
| */ |
| private void triggerAccessWatchpointEvent() { |
| if (fBool) { |
| System.out.println("fBool is true"); |
| } |
| } |
| /** |
| * Trigger a breakpoint event for the front-end. |
| */ |
| private void triggerBreakpointEvent() { |
| System.out.println("Breakpoint"); |
| } |
| /** |
| * Trigger a class prepare event for the front-end. |
| */ |
| private void triggerClassPrepareEvent() { |
| new TestClass(); |
| } |
| /** |
| * Trigger a class prepare event for the front-end. |
| */ |
| private void triggerClassPrepareEvent1() { |
| new TestClass1(); |
| } |
| /** |
| * Trigger a class prepare event for the front-end. |
| */ |
| private void triggerClassPrepareEvent2() { |
| new TestClass2(); |
| } |
| /** |
| * Trigger a class prepare event for the front-end. |
| */ |
| private void triggerClassPrepareEvent3() { |
| new TestClass3(); |
| } |
| /** |
| * Trigger a class prepare event for the front-end. |
| */ |
| private void triggerClassPrepareEvent4() { |
| new TestClass4(); |
| } |
| /** |
| * Trigger a class prepare event for the front-end. |
| */ |
| private void triggerClassPrepareEvent5() { |
| new TestClass5(); |
| } |
| /** |
| * Trigger a class prepare event for the front-end. |
| */ |
| private void triggerClassPrepareEvent6() { |
| new TestClass6(); |
| } |
| /** |
| * Trigger a class prepare event for the front-end. |
| */ |
| private void triggerClassPrepareEvent7() { |
| new TestClass7(); |
| new TestClazz8(); |
| } |
| /** |
| * Trigger a class prepare event for the front-end. |
| */ |
| private void triggerClassPrepareEvent8() { |
| new TestClazz9(); |
| new TestClazz10(); |
| } |
| /** |
| * Trigger an event for the front-end. |
| */ |
| private void triggerEvent() { |
| /* Ensure we do it only once */ |
| String eventType = fEventType; |
| fEventType = ""; |
| |
| /* Trigger event according to the field fEventType */ |
| if (eventType.equals("")) { |
| return; |
| } else if(eventType.equals("refclassload")) { |
| new RefClass(); |
| } |
| else if(eventType.equals("fooreturn")) { |
| foo(); |
| } |
| else if(eventType.equals("argvalues")) { |
| argValues("teststr", 5, new Double(1.33)); |
| } |
| else if(eventType.equals("forcereturn2")) { |
| printNumber(System.out, 1); |
| } |
| else if(eventType.equals("forcereturn")) { |
| print(System.out); |
| } |
| else if(eventType.equals("monitorinfo")) { |
| sync(); |
| } |
| else if(eventType.equals("refclass1load")) { |
| new RefClass1(); |
| } |
| else if(eventType.equals("refclass2load")) { |
| new RefClass2(); |
| } |
| else if(eventType.equals("refclass3load")) { |
| new RefClass3(); |
| } |
| else if(eventType.equals("refclass4load")) { |
| new RefClass4(); |
| } else if (eventType.equals("getInt")) { |
| getInt(); |
| } else if (eventType.equals("getBoolean")) { |
| getBoolean(); |
| } else if (eventType.equals("getLong")) { |
| getLong(); |
| } else if (eventType.equals("AccessWatchpointEvent")) { |
| triggerAccessWatchpointEvent(); |
| } else if (eventType.equals("StaticAccessWatchpointEvent")) { |
| triggerStaticAccessWatchpointEvent(); |
| } else if (eventType.equals("BreakpointEvent")) { |
| triggerBreakpointEvent(); |
| } else if (eventType.equals("ClassPrepareEvent")) { |
| triggerClassPrepareEvent(); |
| } else if (eventType.equals("ClassPrepareEvent1")) { |
| triggerClassPrepareEvent1(); |
| } else if (eventType.equals("ClassPrepareEvent2")) { |
| triggerClassPrepareEvent2(); |
| } else if (eventType.equals("ClassPrepareEvent3")) { |
| triggerClassPrepareEvent3(); |
| } else if (eventType.equals("ClassPrepareEvent4")) { |
| triggerClassPrepareEvent4(); |
| } else if (eventType.equals("ClassPrepareEvent5")) { |
| triggerClassPrepareEvent5(); |
| } else if (eventType.equals("ClassPrepareEvent6")) { |
| triggerClassPrepareEvent6(); |
| } else if (eventType.equals("ClassPrepareEvent7")) { |
| triggerClassPrepareEvent7(); |
| } else if (eventType.equals("ClassPrepareEvent8")) { |
| triggerClassPrepareEvent8(); |
| } else if (eventType.equals("ExceptionEvent")) { |
| triggerExceptionEvent(); |
| } else if (eventType.equals("ModificationWatchpointEvent")) { |
| triggerModificationWatchpointEvent(); |
| } else if (eventType.equals("StaticModificationWatchpointEvent")) { |
| triggerStaticModificationWatchpointEvent(); |
| } else if (eventType.equals("ThreadStartEvent")) { |
| triggerThreadStartEvent(); |
| } else if (eventType.equals("ThreadDeathEvent")) { |
| triggerThreadDeathEvent(); |
| } else { |
| System.out.println("Unknown event type: " + eventType); |
| } |
| } |
| |
| /** |
| * Trigger an exception event for the front-end. |
| */ |
| private void triggerExceptionEvent() { |
| Thread t = new Thread(new Runnable() { |
| @Override |
| public void run() { |
| throw new Error(); |
| } |
| }, "Test Exception Event"); |
| t.start(); |
| } |
| /** |
| * Trigger a modification watchpoint event for the front-end. |
| */ |
| private void triggerModificationWatchpointEvent() { |
| fBool = true; |
| } |
| /** |
| * Trigger an access watchpoint event to a static field |
| * for the front-end. |
| */ |
| private void triggerStaticAccessWatchpointEvent() { |
| if (fObject == null) { |
| System.out.println("fObject is null"); |
| } |
| } |
| /** |
| * Trigger a modification watchpoint event of a static field |
| * for the front-end. |
| */ |
| private void triggerStaticModificationWatchpointEvent() { |
| fString = "Hello Universe"; |
| } |
| /** |
| * Trigger a thread end event for the front-end. |
| */ |
| private void triggerThreadDeathEvent() { |
| new Thread("Test Thread Death Event").start(); |
| } |
| /** |
| * Trigger a thread start event for the front-end. |
| */ |
| private void triggerThreadStartEvent() { |
| new Thread("Test Thread Start Event").start(); |
| } |
| private void useLocalVars(Thread t, MainClass o) { |
| if (t == null) { |
| System.out.println("t is null"); |
| } |
| if (o == null) { |
| System.out.println("o is null"); |
| } |
| |
| } |
| } |