| /* |
| * Copyright (C) 2017 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except |
| * in compliance with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software distributed under the License |
| * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express |
| * or implied. See the License for the specific language governing permissions and limitations under |
| * the License. |
| */ |
| |
| package art; |
| |
| import static art.SuspendEvents.setupFieldSuspendFor; |
| import static art.SuspendEvents.setupSuspendBreakpointFor; |
| import static art.SuspendEvents.setupSuspendExceptionEvent; |
| import static art.SuspendEvents.setupSuspendMethodEvent; |
| import static art.SuspendEvents.setupSuspendPopFrameEvent; |
| import static art.SuspendEvents.setupSuspendSingleStepAt; |
| import static art.SuspendEvents.setupTest; |
| import static art.SuspendEvents.waitForSuspendHit; |
| |
| import java.io.*; |
| import java.lang.reflect.Field; |
| import java.lang.reflect.Method; |
| import java.util.concurrent.CountDownLatch; |
| import java.util.function.Consumer; |
| import java.util.function.Supplier; |
| |
| public class Test1968 { |
| public static final boolean PRINT_STACK_TRACE = false; |
| public static long OVERRIDE_ID = 0; |
| |
| public static final class OveriddenReturnValue { |
| public final Thread target; |
| public final Thread.State state; |
| public final StackTraceElement stack[]; |
| public final long id; |
| |
| public OveriddenReturnValue(Thread thr) { |
| target = thr; |
| state = thr.getState(); |
| stack = thr.getStackTrace(); |
| id = OVERRIDE_ID++; |
| } |
| |
| public String toString() { |
| String stackTrace = |
| PRINT_STACK_TRACE |
| ? ",\n\tthread: " |
| + target.toString() |
| + ",\n\tstate: " |
| + state |
| + ",\n\tstack:\n" |
| + safeDumpStackTrace(stack, "\t\t") |
| + ",\n\t" |
| : ""; |
| return "OveriddenReturnValue { id: " + id + stackTrace + " }"; |
| } |
| } |
| |
| // Returns a value to be used for the return value of the given thread. |
| public static Object getOveriddenReturnValue(Thread thr) { |
| return new OveriddenReturnValue(thr); |
| } |
| |
| public static void doNothing() {} |
| |
| public interface TestRunnable extends Runnable { |
| public Object getReturnValue(); |
| } |
| |
| public static interface TestSuspender { |
| public void setupForceReturnRun(Thread thr); |
| |
| public void waitForSuspend(Thread thr); |
| |
| public void cleanup(Thread thr); |
| |
| public default void performForceReturn(Thread thr) { |
| Object ret = getOveriddenReturnValue(thr); |
| System.out.println("Will force return of " + ret); |
| NonStandardExit.forceEarlyReturn(thr, ret); |
| } |
| |
| public default void setupNormalRun(Thread thr) {} |
| } |
| |
| public static interface ThreadRunnable { |
| public void run(Thread thr); |
| } |
| |
| public static TestSuspender makeSuspend(final ThreadRunnable setup, final ThreadRunnable clean) { |
| return new TestSuspender() { |
| public void setupForceReturnRun(Thread thr) { |
| setup.run(thr); |
| } |
| |
| public void waitForSuspend(Thread thr) { |
| waitForSuspendHit(thr); |
| } |
| |
| public void cleanup(Thread thr) { |
| clean.run(thr); |
| } |
| }; |
| } |
| |
| public void runTestOn(Supplier<TestRunnable> testObj, ThreadRunnable su, ThreadRunnable cl) |
| throws Exception { |
| runTestOn(testObj, makeSuspend(su, cl)); |
| } |
| |
| private static void SafePrintStackTrace(StackTraceElement st[]) { |
| System.out.println(safeDumpStackTrace(st, "\t")); |
| } |
| |
| private static String safeDumpStackTrace(StackTraceElement st[], String prefix) { |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| PrintStream os = new PrintStream(baos); |
| for (StackTraceElement e : st) { |
| os.println( |
| prefix |
| + e.getClassName() |
| + "." |
| + e.getMethodName() |
| + "(" |
| + (e.isNativeMethod() ? "Native Method" : e.getFileName()) |
| + ")"); |
| if (e.getClassName().equals("art.Test1968") && e.getMethodName().equals("runTests")) { |
| os.println(prefix + "<Additional frames hidden>"); |
| break; |
| } |
| } |
| os.flush(); |
| return baos.toString(); |
| } |
| |
| static long ID_COUNTER = 0; |
| |
| public TestRunnable Id(final TestRunnable tr) { |
| final long my_id = ID_COUNTER++; |
| return new TestRunnable() { |
| public void run() { |
| tr.run(); |
| } |
| |
| public Object getReturnValue() { |
| return tr.getReturnValue(); |
| } |
| |
| public String toString() { |
| return "(ID: " + my_id + ") " + tr.toString(); |
| } |
| }; |
| } |
| |
| public static long THREAD_COUNT = 0; |
| |
| public Thread mkThread(Runnable r) { |
| Thread t = new Thread(r, "Test1968 target thread - " + THREAD_COUNT++); |
| t.setUncaughtExceptionHandler( |
| (thr, e) -> { |
| System.out.println( |
| "Uncaught exception in thread " |
| + thr |
| + " - " |
| + e.getClass().getName() |
| + ": " |
| + e.getLocalizedMessage()); |
| SafePrintStackTrace(e.getStackTrace()); |
| }); |
| return t; |
| } |
| |
| final class TestConfig { |
| public final TestRunnable testObj; |
| public final TestSuspender suspender; |
| |
| public TestConfig(TestRunnable obj, TestSuspender su) { |
| this.testObj = obj; |
| this.suspender = su; |
| } |
| } |
| |
| public void runTestOn(Supplier<TestRunnable> testObjGen, TestSuspender su) throws Exception { |
| runTestOn(() -> new TestConfig(testObjGen.get(), su)); |
| } |
| |
| public void runTestOn(Supplier<TestConfig> config) throws Exception { |
| TestConfig normal_config = config.get(); |
| TestRunnable normal_run = Id(normal_config.testObj); |
| try { |
| System.out.println("NORMAL RUN: Single call with no interference on " + normal_run); |
| Thread normal_thread = mkThread(normal_run); |
| normal_config.suspender.setupNormalRun(normal_thread); |
| normal_thread.start(); |
| normal_thread.join(); |
| System.out.println( |
| "NORMAL RUN: result for " + normal_run + " is " + normal_run.getReturnValue()); |
| } catch (Exception e) { |
| System.out.println("NORMAL RUN: Ended with exception for " + normal_run + "!"); |
| e.printStackTrace(System.out); |
| } |
| |
| TestConfig force_return_config = config.get(); |
| TestRunnable testObj = Id(force_return_config.testObj); |
| TestSuspender su = force_return_config.suspender; |
| System.out.println("Single call with force-early-return on " + testObj); |
| final CountDownLatch continue_latch = new CountDownLatch(1); |
| final CountDownLatch startup_latch = new CountDownLatch(1); |
| Runnable await = |
| () -> { |
| try { |
| startup_latch.countDown(); |
| continue_latch.await(); |
| } catch (Exception e) { |
| throw new Error("Failed to await latch", e); |
| } |
| }; |
| Thread thr = |
| mkThread( |
| () -> { |
| await.run(); |
| testObj.run(); |
| }); |
| thr.start(); |
| |
| // Wait until the other thread is started. |
| startup_latch.await(); |
| |
| // Do any final setup. |
| preTest.accept(testObj); |
| |
| // Setup suspension method on the thread. |
| su.setupForceReturnRun(thr); |
| |
| // Let the other thread go. |
| continue_latch.countDown(); |
| |
| // Wait for the other thread to hit the breakpoint/watchpoint/whatever and |
| // suspend itself |
| // (without re-entering java) |
| su.waitForSuspend(thr); |
| |
| // Cleanup the breakpoint/watchpoint/etc. |
| su.cleanup(thr); |
| |
| try { |
| // Pop the frame. |
| su.performForceReturn(thr); |
| } catch (Exception e) { |
| System.out.println("Failed to force-return due to " + e); |
| SafePrintStackTrace(e.getStackTrace()); |
| } |
| |
| // Start the other thread going again. |
| Suspension.resume(thr); |
| |
| // Wait for the other thread to finish. |
| thr.join(); |
| |
| // See how many times calledFunction was called. |
| System.out.println("result for " + testObj + " is " + testObj.getReturnValue()); |
| } |
| |
| public abstract static class AbstractTestObject implements TestRunnable { |
| private Object resultObject; |
| |
| public AbstractTestObject() { |
| resultObject = null; |
| } |
| |
| public Object getReturnValue() { |
| return resultObject; |
| } |
| |
| public void run() { |
| // This function should have it's return-value replaced by force-early-return. |
| resultObject = calledFunction(); |
| } |
| |
| public abstract Object calledFunction(); |
| } |
| |
| public static class IntContainer { |
| private final int value; |
| |
| public IntContainer(int i) { |
| value = i; |
| } |
| |
| public String toString() { |
| return "IntContainer { value: " + value + " }"; |
| } |
| } |
| |
| public static class FieldBasedTestObject extends AbstractTestObject implements Runnable { |
| public int TARGET_FIELD; |
| |
| public FieldBasedTestObject() { |
| super(); |
| TARGET_FIELD = 0; |
| } |
| |
| public Object calledFunction() { |
| // We put a watchpoint here and force-early-return when we are at it. |
| TARGET_FIELD += 10; |
| return new IntContainer(TARGET_FIELD); |
| } |
| |
| public String toString() { |
| return "FieldBasedTestObject { TARGET_FIELD: " + TARGET_FIELD + " }"; |
| } |
| } |
| |
| public static class StandardTestObject extends AbstractTestObject implements Runnable { |
| public int cnt; |
| |
| public StandardTestObject() { |
| super(); |
| cnt = 0; |
| } |
| |
| public Object calledFunction() { |
| cnt++; // line +0 |
| // We put a breakpoint here and PopFrame when we are at it. |
| Object result = new IntContainer(cnt); // line +2 |
| cnt++; // line +3 |
| return result; // line +4 |
| } |
| |
| public String toString() { |
| return "StandardTestObject { cnt: " + cnt + " }"; |
| } |
| } |
| |
| public static class SynchronizedFunctionTestObject extends AbstractTestObject |
| implements Runnable { |
| public int cnt; |
| |
| public SynchronizedFunctionTestObject() { |
| super(); |
| cnt = 0; |
| } |
| |
| public synchronized Object calledFunction() { |
| cnt++; // line +0 |
| // We put a breakpoint here and PopFrame when we are at it. |
| Object result = new IntContainer(cnt); // line +2 |
| cnt++; // line +3 |
| return result; |
| } |
| |
| public String toString() { |
| return "SynchronizedFunctionTestObject { cnt: " + cnt + " }"; |
| } |
| } |
| |
| public static class SynchronizedTestObject extends AbstractTestObject implements Runnable { |
| public final Object lock; |
| public int cnt; |
| |
| public SynchronizedTestObject() { |
| this(new Object()); |
| } |
| |
| public SynchronizedTestObject(Object lock) { |
| super(); |
| this.lock = lock; |
| cnt = 0; |
| } |
| |
| public Object calledFunction() { |
| synchronized (lock) { // line +0 |
| cnt++; // line +1 |
| // We put a breakpoint here and PopFrame when we are at it. |
| Object result = new IntContainer(cnt); // line +3 |
| cnt++; // line +4 |
| return result; // line +5 |
| } |
| } |
| |
| public String toString() { |
| return "SynchronizedTestObject { cnt: " + cnt + " }"; |
| } |
| } |
| |
| public static class ExceptionCatchTestObject extends AbstractTestObject implements Runnable { |
| public static class TestError extends Error {} |
| |
| public int cnt; |
| |
| public ExceptionCatchTestObject() { |
| super(); |
| cnt = 0; |
| } |
| |
| public Object calledFunction() { |
| cnt++; |
| Object result = new IntContainer(cnt); |
| try { |
| doThrow(); |
| cnt += 100; |
| } catch (TestError e) { |
| System.out.println(e.getClass().getName() + " caught in called function."); |
| cnt++; |
| } |
| return result; |
| } |
| |
| public Object doThrow() { |
| throw new TestError(); |
| } |
| |
| public String toString() { |
| return "ExceptionCatchTestObject { cnt: " + cnt + " }"; |
| } |
| } |
| |
| public static class ExceptionThrowFarTestObject implements TestRunnable { |
| public static class TestError extends Error {} |
| |
| public int cnt; |
| public int baseCallCnt; |
| public final boolean catchInCalled; |
| public Object result; |
| |
| public ExceptionThrowFarTestObject(boolean catchInCalled) { |
| super(); |
| cnt = 0; |
| baseCallCnt = 0; |
| this.catchInCalled = catchInCalled; |
| } |
| |
| public void run() { |
| baseCallCnt++; |
| try { |
| result = callingFunction(); |
| } catch (TestError e) { |
| System.out.println(e.getClass().getName() + " thrown and caught!"); |
| } |
| baseCallCnt++; |
| } |
| |
| public Object callingFunction() { |
| return calledFunction(); |
| } |
| |
| public Object calledFunction() { |
| cnt++; |
| if (catchInCalled) { |
| try { |
| cnt += 100; |
| throw new TestError(); // We put a watch here. |
| } catch (TestError e) { |
| System.out.println(e.getClass().getName() + " caught in same function."); |
| Object result = new IntContainer(cnt); |
| cnt += 10; |
| return result; |
| } |
| } else { |
| cnt++; |
| throw new TestError(); // We put a watch here. |
| } |
| } |
| |
| public String toString() { |
| return "ExceptionThrowFarTestObject { cnt: " + cnt + ", baseCnt: " + baseCallCnt + " }"; |
| } |
| |
| @Override |
| public Object getReturnValue() { |
| return result; |
| } |
| } |
| |
| public static class ExceptionOnceObject extends AbstractTestObject { |
| public static final class TestError extends Error {} |
| |
| public int cnt; |
| public final boolean throwInSub; |
| |
| public ExceptionOnceObject(boolean throwInSub) { |
| super(); |
| cnt = 0; |
| this.throwInSub = throwInSub; |
| } |
| |
| public Object calledFunction() { |
| cnt++; |
| if (cnt == 1) { |
| if (throwInSub) { |
| return doThrow(); |
| } else { |
| throw new TestError(); |
| } |
| } |
| return new IntContainer(cnt++); |
| } |
| |
| public Object doThrow() { |
| throw new TestError(); |
| } |
| |
| public String toString() { |
| return "ExceptionOnceObject { cnt: " + cnt + ", throwInSub: " + throwInSub + " }"; |
| } |
| } |
| |
| public static class ExceptionThrowTestObject implements TestRunnable { |
| public static class TestError extends Error {} |
| |
| public Object getReturnValue() { |
| return result; |
| } |
| |
| public int cnt; |
| public int baseCallCnt; |
| public final boolean catchInCalled; |
| public Object result; |
| |
| public ExceptionThrowTestObject(boolean catchInCalled) { |
| super(); |
| cnt = 0; |
| baseCallCnt = 0; |
| this.catchInCalled = catchInCalled; |
| } |
| |
| public void run() { |
| baseCallCnt++; |
| try { |
| result = calledFunction(); |
| } catch (TestError e) { |
| System.out.println(e.getClass().getName() + " thrown and caught!"); |
| } |
| baseCallCnt++; |
| } |
| |
| public Object calledFunction() { |
| cnt++; |
| if (catchInCalled) { |
| try { |
| cnt += 10; |
| throw new TestError(); // We put a watch here. |
| } catch (TestError e) { |
| System.out.println(e.getClass().getName() + " caught in same function."); |
| Object result = new IntContainer(cnt); |
| cnt += 100; |
| return result; |
| } |
| } else { |
| cnt += 1; |
| throw new TestError(); // We put a watch here. |
| } |
| } |
| |
| public String toString() { |
| return "ExceptionThrowTestObject { cnt: " + cnt + ", baseCnt: " + baseCallCnt + " }"; |
| } |
| } |
| |
| public static class NativeCalledObject extends AbstractTestObject { |
| public int cnt = 0; |
| |
| public native Object calledFunction(); |
| |
| public String toString() { |
| return "NativeCalledObject { cnt: " + cnt + " }"; |
| } |
| } |
| |
| public static class NativeCallerObject implements TestRunnable { |
| public Object returnValue = null; |
| public int cnt = 0; |
| |
| public Object getReturnValue() { |
| return returnValue; |
| } |
| |
| public native void run(); |
| |
| public Object calledFunction() { |
| cnt++; |
| // We will stop using a MethodExit event. |
| Object res = new IntContainer(cnt); |
| cnt++; |
| return res; |
| } |
| |
| public String toString() { |
| return "NativeCallerObject { cnt: " + cnt + " }"; |
| } |
| } |
| |
| public static class StaticMethodObject implements TestRunnable { |
| public int cnt = 0; |
| public Object result = null; |
| public Object getReturnValue() { |
| return result; |
| } |
| |
| public static Object calledFunction(Supplier<Object> incr) { |
| Object res = incr.get(); // line +0 |
| // We put a breakpoint here to force the return. |
| doNothing(); // line +2 |
| incr.get(); // line +3 |
| return res; // line +4 |
| } |
| |
| public void run() { |
| result = calledFunction(() -> new IntContainer(++cnt)); |
| } |
| |
| public String toString() { |
| return "StaticMethodObject { cnt: " + cnt + " }"; |
| } |
| } |
| |
| public static class SuspendSuddenlyObject extends AbstractTestObject { |
| public volatile boolean should_spin = true; |
| public volatile boolean is_spinning = false; |
| public int cnt = 0; |
| |
| public Object calledFunction() { |
| cnt++; |
| do { |
| is_spinning = true; |
| } while (should_spin); |
| return new IntContainer(cnt++); |
| } |
| |
| public String toString() { |
| return "SuspendSuddenlyObject { cnt: " + cnt + ", spun: " + is_spinning + " }"; |
| } |
| } |
| |
| public static class BadForceVoidObject implements TestRunnable { |
| public int cnt = 0; |
| public Object getReturnValue() { |
| return null; |
| } |
| public void run() { |
| incrCnt(); |
| } |
| public void incrCnt() { |
| ++cnt; // line +0 |
| // We set a breakpoint here and try to force-early-return. |
| doNothing(); // line +2 |
| ++cnt; // line +3 |
| } |
| public String toString() { |
| return "BadForceVoidObject { cnt: " + cnt + " }"; |
| } |
| } |
| |
| public static class BadForceIntObject implements TestRunnable { |
| public int cnt = 0; |
| public int result = 0; |
| public Object getReturnValue() { |
| return Integer.valueOf(result); |
| } |
| public void run() { |
| result = incrCnt(); |
| } |
| public int incrCnt() { |
| ++cnt; // line +0 |
| // We set a breakpoint here and try to force-early-return. |
| int res = cnt; // line +2 |
| ++cnt; // line +3 |
| return res; |
| } |
| public String toString() { |
| return "BadForceIntObject { cnt: " + cnt + " }"; |
| } |
| } |
| |
| public static void run() throws Exception { |
| new Test1968((x) -> {}).runTests(); |
| } |
| |
| public Test1968(Consumer<TestRunnable> preTest) { |
| this.preTest = preTest; |
| } |
| |
| private Consumer<TestRunnable> preTest; |
| |
| public static void no_runTestOn(Supplier<Object> a, ThreadRunnable b, ThreadRunnable c) {} |
| |
| public void runTests() throws Exception { |
| setupTest(); |
| |
| final Method calledFunction = StandardTestObject.class.getDeclaredMethod("calledFunction"); |
| // Add a breakpoint on the second line after the start of the function |
| final int line = Breakpoint.locationToLine(calledFunction, 0) + 2; |
| final long loc = Breakpoint.lineToLocation(calledFunction, line); |
| System.out.println("Test stopped using breakpoint"); |
| runTestOn( |
| StandardTestObject::new, |
| (thr) -> setupSuspendBreakpointFor(calledFunction, loc, thr), |
| SuspendEvents::clearSuspendBreakpointFor); |
| |
| final Method syncFunctionCalledFunction = |
| SynchronizedFunctionTestObject.class.getDeclaredMethod("calledFunction"); |
| // Add a breakpoint on the second line after the start of the function Annoyingly r8 generally |
| // has the first instruction (a monitor enter) not be marked as being on any line but javac has |
| // it marked as being on the first line of the function. Just use the second entry on the |
| // line-number table to get the breakpoint. This should be good for both. |
| final long syncFunctionLoc = |
| Breakpoint.getLineNumberTable(syncFunctionCalledFunction)[1].location; |
| System.out.println("Test stopped using breakpoint with declared synchronized function"); |
| runTestOn( |
| SynchronizedFunctionTestObject::new, |
| (thr) -> setupSuspendBreakpointFor(syncFunctionCalledFunction, syncFunctionLoc, thr), |
| SuspendEvents::clearSuspendBreakpointFor); |
| |
| final Method syncCalledFunction = |
| SynchronizedTestObject.class.getDeclaredMethod("calledFunction"); |
| // Add a breakpoint on the second line after the start of the function |
| final int syncLine = Breakpoint.locationToLine(syncCalledFunction, 0) + 3; |
| final long syncLoc = Breakpoint.lineToLocation(syncCalledFunction, syncLine); |
| System.out.println("Test stopped using breakpoint with synchronized block"); |
| final Object lockObj = new Object(); |
| runTestOn( |
| () -> new SynchronizedTestObject(lockObj), |
| (thr) -> setupSuspendBreakpointFor(syncCalledFunction, syncLoc, thr), |
| SuspendEvents::clearSuspendBreakpointFor); |
| // Make sure we can still lock the object. |
| synchronized (lockObj) { } |
| |
| System.out.println("Test stopped on single step"); |
| runTestOn( |
| StandardTestObject::new, |
| (thr) -> setupSuspendSingleStepAt(calledFunction, loc, thr), |
| SuspendEvents::clearSuspendSingleStepFor); |
| |
| final Field target_field = FieldBasedTestObject.class.getDeclaredField("TARGET_FIELD"); |
| System.out.println("Test stopped on field access"); |
| runTestOn( |
| FieldBasedTestObject::new, |
| (thr) -> setupFieldSuspendFor(FieldBasedTestObject.class, target_field, true, thr), |
| SuspendEvents::clearFieldSuspendFor); |
| |
| System.out.println("Test stopped on field modification"); |
| runTestOn( |
| FieldBasedTestObject::new, |
| (thr) -> setupFieldSuspendFor(FieldBasedTestObject.class, target_field, false, thr), |
| SuspendEvents::clearFieldSuspendFor); |
| |
| System.out.println("Test stopped during Method Exit of calledFunction"); |
| runTestOn( |
| StandardTestObject::new, |
| (thr) -> setupSuspendMethodEvent(calledFunction, /* enter */ false, thr), |
| SuspendEvents::clearSuspendMethodEvent); |
| |
| System.out.println("Test stopped during Method Enter of calledFunction"); |
| runTestOn( |
| StandardTestObject::new, |
| (thr) -> setupSuspendMethodEvent(calledFunction, /* enter */ true, thr), |
| SuspendEvents::clearSuspendMethodEvent); |
| |
| final Method exceptionOnceCalledMethod = |
| ExceptionOnceObject.class.getDeclaredMethod("calledFunction"); |
| System.out.println("Test stopped during Method Exit due to exception thrown in same function"); |
| runTestOn( |
| () -> new ExceptionOnceObject(/* throwInSub */ false), |
| (thr) -> setupSuspendMethodEvent(exceptionOnceCalledMethod, /* enter */ false, thr), |
| SuspendEvents::clearSuspendMethodEvent); |
| |
| System.out.println("Test stopped during Method Exit due to exception thrown in subroutine"); |
| runTestOn( |
| () -> new ExceptionOnceObject(/* throwInSub */ true), |
| (thr) -> setupSuspendMethodEvent(exceptionOnceCalledMethod, /* enter */ false, thr), |
| SuspendEvents::clearSuspendMethodEvent); |
| |
| final Method exceptionThrowCalledMethod = |
| ExceptionThrowTestObject.class.getDeclaredMethod("calledFunction"); |
| System.out.println( |
| "Test stopped during notifyFramePop with exception on pop of calledFunction"); |
| runTestOn( |
| () -> new ExceptionThrowTestObject(false), |
| (thr) -> setupSuspendPopFrameEvent(0, exceptionThrowCalledMethod, thr), |
| SuspendEvents::clearSuspendPopFrameEvent); |
| |
| final Method exceptionCatchThrowMethod = |
| ExceptionCatchTestObject.class.getDeclaredMethod("doThrow"); |
| System.out.println("Test stopped during notifyFramePop with exception on pop of doThrow"); |
| runTestOn( |
| ExceptionCatchTestObject::new, |
| (thr) -> setupSuspendPopFrameEvent(0, exceptionCatchThrowMethod, thr), |
| SuspendEvents::clearSuspendPopFrameEvent); |
| |
| System.out.println( |
| "Test stopped during ExceptionCatch event of calledFunction " |
| + "(catch in called function, throw in called function)"); |
| runTestOn( |
| () -> new ExceptionThrowTestObject(true), |
| (thr) -> setupSuspendExceptionEvent(exceptionThrowCalledMethod, /* catch */ true, thr), |
| SuspendEvents::clearSuspendExceptionEvent); |
| |
| final Method exceptionCatchCalledMethod = |
| ExceptionCatchTestObject.class.getDeclaredMethod("calledFunction"); |
| System.out.println( |
| "Test stopped during ExceptionCatch event of calledFunction " |
| + "(catch in called function, throw in subroutine)"); |
| runTestOn( |
| ExceptionCatchTestObject::new, |
| (thr) -> setupSuspendExceptionEvent(exceptionCatchCalledMethod, /* catch */ true, thr), |
| SuspendEvents::clearSuspendExceptionEvent); |
| |
| System.out.println( |
| "Test stopped during Exception event of calledFunction " + "(catch in calling function)"); |
| runTestOn( |
| () -> new ExceptionThrowTestObject(false), |
| (thr) -> setupSuspendExceptionEvent(exceptionThrowCalledMethod, /* catch */ false, thr), |
| SuspendEvents::clearSuspendExceptionEvent); |
| |
| System.out.println( |
| "Test stopped during Exception event of calledFunction (catch in called function)"); |
| runTestOn( |
| () -> new ExceptionThrowTestObject(true), |
| (thr) -> setupSuspendExceptionEvent(exceptionThrowCalledMethod, /* catch */ false, thr), |
| SuspendEvents::clearSuspendExceptionEvent); |
| |
| final Method exceptionThrowFarCalledMethod = |
| ExceptionThrowFarTestObject.class.getDeclaredMethod("calledFunction"); |
| System.out.println( |
| "Test stopped during Exception event of calledFunction " |
| + "(catch in parent of calling function)"); |
| runTestOn( |
| () -> new ExceptionThrowFarTestObject(false), |
| (thr) -> setupSuspendExceptionEvent(exceptionThrowFarCalledMethod, /* catch */ false, thr), |
| SuspendEvents::clearSuspendExceptionEvent); |
| |
| System.out.println( |
| "Test stopped during Exception event of calledFunction " + "(catch in called function)"); |
| runTestOn( |
| () -> new ExceptionThrowFarTestObject(true), |
| (thr) -> setupSuspendExceptionEvent(exceptionThrowFarCalledMethod, /* catch */ false, thr), |
| SuspendEvents::clearSuspendExceptionEvent); |
| |
| System.out.println("Test stopped during random Suspend."); |
| runTestOn(() -> { |
| final SuspendSuddenlyObject sso = new SuspendSuddenlyObject(); |
| return new TestConfig(sso, new TestSuspender() { |
| public void setupForceReturnRun(Thread thr) { } |
| public void setupNormalRun(Thread thr) { |
| sso.should_spin = false; |
| } |
| |
| public void waitForSuspend(Thread thr) { |
| while (!sso.is_spinning) { } |
| Suspension.suspend(thr); |
| } |
| |
| public void cleanup(Thread thr) { } |
| }); |
| }); |
| |
| System.out.println("Test stopped during a native method fails"); |
| runTestOn( |
| NativeCalledObject::new, |
| SuspendEvents::setupWaitForNativeCall, |
| SuspendEvents::clearWaitForNativeCall); |
| |
| System.out.println("Test stopped in a method called by native succeeds"); |
| final Method nativeCallerMethod = NativeCallerObject.class.getDeclaredMethod("calledFunction"); |
| runTestOn( |
| NativeCallerObject::new, |
| (thr) -> setupSuspendMethodEvent(nativeCallerMethod, /* enter */ false, thr), |
| SuspendEvents::clearSuspendMethodEvent); |
| |
| System.out.println("Test stopped in a static method"); |
| final Method staticCalledMethod = StaticMethodObject.class.getDeclaredMethod("calledFunction", Supplier.class); |
| final int staticFunctionLine= Breakpoint.locationToLine(staticCalledMethod, 0) + 2; |
| final long staticFunctionLoc = Breakpoint.lineToLocation(staticCalledMethod, staticFunctionLine); |
| runTestOn( |
| StaticMethodObject::new, |
| (thr) -> setupSuspendBreakpointFor(staticCalledMethod, staticFunctionLoc, thr), |
| SuspendEvents::clearSuspendMethodEvent); |
| |
| System.out.println("Test force-return of void function fails!"); |
| final Method voidFunction = BadForceVoidObject.class.getDeclaredMethod("incrCnt"); |
| final int voidLine = Breakpoint.locationToLine(voidFunction, 0) + 2; |
| final long voidLoc = Breakpoint.lineToLocation(voidFunction, voidLine); |
| runTestOn( |
| BadForceVoidObject::new, |
| (thr) -> setupSuspendBreakpointFor(voidFunction, voidLoc, thr), |
| SuspendEvents::clearSuspendMethodEvent); |
| |
| System.out.println("Test force-return of int function fails!"); |
| final Method intFunction = BadForceIntObject.class.getDeclaredMethod("incrCnt"); |
| final int intLine = Breakpoint.locationToLine(intFunction, 0) + 2; |
| final long intLoc = Breakpoint.lineToLocation(intFunction, intLine); |
| runTestOn( |
| BadForceIntObject::new, |
| (thr) -> setupSuspendBreakpointFor(intFunction, intLoc, thr), |
| SuspendEvents::clearSuspendMethodEvent); |
| } |
| } |
