jdk/test/com/sun/jdi/PopSynchronousTest.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2001, 2015, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 /**
  * @test
  * @bug 4467564
  * @summary Test the popping of frames in synchronous context
  *          (that is, when stopped at an event)
  * @author Robert Field
  *
  * @run build TestScaffold VMConnection TargetListener TargetAdapter
  * @run compile -g PopSynchronousTest.java
  * @run driver PopSynchronousTest
  */
 import com.sun.jdi.*;
 import com.sun.jdi.event.*;
 import com.sun.jdi.request.*;

 import java.util.*;

     /********** target program **********/

 class PopSynchronousTarg {
     static String s;
     static PopSynchronousTarg sole;

     synchronized void a(int y, boolean w) {
         if (y == 6 && w) {
             s += "@";
         } else {
             s += " aArgFail ";
         }
     }
     String b(String h) {
         if (h.equals("yo")) {
             s += "[";
         } else {
             s += " bArgFail ";
         }
         a(6, true);
         s += "]";
         return s;
     }
     long c() {
         s += "<";
         synchronized (s) {
             b("yo");
         }
         s += ">";
         return 17;
     }
     static void p() {
         s += "(";
         if (sole.c() != 17) {
             s += " cReturnFail ";
         }
         s += ")";
     }
     static void report() {
     }
     public static void main(String[] args){
         s = new String();
         sole = new PopSynchronousTarg();
         for (int i = 0; i < 100; ++i) {
             p();
             // System.out.println(s);
             report();
         }
     }
 }

     /********** test program **********/

 public class PopSynchronousTest extends TestScaffold {
     ReferenceType targetClass;
     ThreadReference mainThread;
     int stateIndex = 0;
     String expected = "";
     static final String[] calls =  {"a", "b", "c", "p", "main"};
     static final int popMax = calls.length - 1;
     static final String[] states =
     {"main-i", "p-e", "p-i", "c-e", "c-i", "b-e", "b-i", "a-e", "a-l", "b-l", "c-l", "p-l", "main-r", "report-e"};
     static final String[] output =
     {"",       "",    "(",   "",    "<",   "",    "[",   "",    "@",   "]",   ">",   ")",   "",       ""};


     PopSynchronousTest (String args[]) {
         super(args);
     }

     public static void main(String[] args)      throws Exception {
         new PopSynchronousTest(args).startTests();
     }


     /********** test assist **********/

     StackFrame frameFor(String methodName) throws Exception {
         Iterator it = mainThread.frames().iterator();

         while (it.hasNext()) {
             StackFrame frame = (StackFrame)it.next();
             if (frame.location().method().name().equals(methodName)) {
                 return frame;
             }
         }
         failure("FAIL: " + methodName + " not on stack");
         return null;
     }

     String actual() throws Exception {
         Field field = targetClass.fieldByName("s");
         StringReference sr = (StringReference)(targetClass.getValue(field));
         return sr.value();
     }

     void checkExpected() throws Exception {
         if (!actual().equals(expected)) {
             failure("FAIL: expected value: " + expected +
                     " got: " + actual());
         }
     }

     int methodIndex(String methodName) {
         for (int i = 0; i < popMax; ++i) {
             if (methodName.equals(calls[i])) {
                 return i;
             }
         }
         return -1;
     }

     boolean isTop(String methodName) throws Exception {
         return mainThread.frame(0).location().method().name().equals(methodName);
     }

     void checkTop(String methodName, boolean atStart) throws Exception {
         Location loc = mainThread.frame(0).location();
         Method meth = loc.method();
         String name = meth.name();
         if (!isTop(methodName)) {
             failure("FAIL: expected " + methodName +
                     " at top of stack, instead: " + name);
         } else if ((meth.location().codeIndex() == loc.codeIndex()) != atStart) {
             failure("FAIL: not at expect position: " + loc.codeIndex());
         }
     }

     void checkState() throws Exception {
         String name = states[stateIndex];
         int dash = name.indexOf('-');
         String methodName = name.substring(0,dash);
         String posName = name.substring(dash+1);
         checkTop(methodName, posName.equals("e"));
         checkExpected();
     }

     void incrementState() {
         stateIndex = (stateIndex + 1) % (states.length);
     }

     void resetState(String stateName) {
         for (int i=0; i < states.length; ++i) {
             if (states[i].equals(stateName)) {
                 stateIndex = i;
                 return;
             }
         }
         failure("TEST FAILURE: cannot find state: " + stateName);
     }

     void resetExpected() throws Exception {
         println("Current value: " + actual());
         Field field = targetClass.fieldByName("s");
         expected = "";
         ((ClassType)targetClass).setValue(field, vm().mirrorOf(expected));
     }

     void stateTo(String stateName) {
         do {
             incrementState();
             expected += output[stateIndex];
         } while(!states[stateIndex].equals(stateName));
     }

     void resumeTo(String methodName) throws Exception {
         List meths = targetClass.methodsByName(methodName);
         Method meth = (Method)(meths.get(0));
         resumeTo(meth.location());
         stateTo(methodName + "-e");
         checkState();
     }

     void pop(String methodName) throws Exception {
         mainThread.popFrames(frameFor(methodName));
         resetState(methodName + "-e");
         --stateIndex;
         checkState();
     }

     void reenter(String methodName) throws Exception {
         pop(methodName);
         stepIntoInstruction(mainThread);
         incrementState();
         checkState();
     }

     /********** test core **********/

     protected void runTests() throws Exception {
         /*
          * Get to the top of main()
          * to determine targetClass and mainThread
          */
         BreakpointEvent bpe = startToMain("PopSynchronousTarg");
         targetClass = bpe.location().declaringType();
         mainThread = bpe.thread();

         /*
          * Testing
          */

         /* individual tests */
         for (int i = 0; i < popMax; ++i) {
             String from = calls[i];
             for (int j = i; j < popMax; ++j) {
                 String to = calls[j];
                 String prev = calls[j+1];
                 println("TEST pop from '" + from + "' to '" + to + "'");
                 resumeTo(from);
                 reenter(to);
                 resumeTo("report");
                 resetExpected();
             }
         }

         /* sequential tests */

         println("TEST pop a b c p");
         resumeTo("a");
         pop("a");
         pop("b");
         pop("c");
         pop("p");
         resumeTo("report");
         resetExpected();

         println("TEST pop a c p");
         resumeTo("a");
         pop("a");
         pop("c");
         pop("p");
         resumeTo("report");
         resetExpected();

         println("TEST stress a");
         resumeTo("a");
         for (int i = 0; i < 100; ++i) {
             reenter("a");
         }
         resumeTo("report");
         resetExpected();

         println("TEST stress c");
         resumeTo("c");
         for (int i = 0; i < 100; ++i) {
             reenter("c");
         }
         resumeTo("report");
         resetExpected();

         /*
          * we are done, get rid of target
          */
         vm().dispose();

         /*
          * deal with results of test
          * if anything has called failure("foo") testFailed will be true
          */
         if (!testFailed) {
             println("PopSynchronousTest: passed");
         } else {
             throw new Exception("PopSynchronousTest: failed");
         }
     }
 }
	/*
	* Copyright (c) 2001, 2015, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	/**
	* @test
	* @bug 4467564
	* @summary Test the popping of frames in synchronous context
	* (that is, when stopped at an event)
	* @author Robert Field
	*
	* @run build TestScaffold VMConnection TargetListener TargetAdapter
	* @run compile -g PopSynchronousTest.java
	* @run driver PopSynchronousTest
	*/
	import com.sun.jdi.*;
	import com.sun.jdi.event.*;
	import com.sun.jdi.request.*;

	import java.util.*;

	/******** target program ********/

	class PopSynchronousTarg {
	static String s;
	static PopSynchronousTarg sole;

	synchronized void a(int y, boolean w) {
	if (y == 6 && w) {
	s += "@";
	} else {
	s += " aArgFail ";
	}
	}
	String b(String h) {
	if (h.equals("yo")) {
	s += "[";
	} else {
	s += " bArgFail ";
	}
	a(6, true);
	s += "]";
	return s;
	}
	long c() {
	s += "<";
	synchronized (s) {
	b("yo");
	}
	s += ">";
	return 17;
	}
	static void p() {
	s += "(";
	if (sole.c() != 17) {
	s += " cReturnFail ";
	}
	s += ")";
	}
	static void report() {
	}
	public static void main(String[] args){
	s = new String();
	sole = new PopSynchronousTarg();
	for (int i = 0; i < 100; ++i) {
	p();
	// System.out.println(s);
	report();
	}
	}
	}

	/******** test program ********/

	public class PopSynchronousTest extends TestScaffold {
	ReferenceType targetClass;
	ThreadReference mainThread;
	int stateIndex = 0;
	String expected = "";
	static final String[] calls = {"a", "b", "c", "p", "main"};
	static final int popMax = calls.length - 1;
	static final String[] states =
	{"main-i", "p-e", "p-i", "c-e", "c-i", "b-e", "b-i", "a-e", "a-l", "b-l", "c-l", "p-l", "main-r", "report-e"};
	static final String[] output =
	{"", "", "(", "", "<", "", "[", "", "@", "]", ">", ")", "", ""};


	PopSynchronousTest (String args[]) {
	super(args);
	}

	public static void main(String[] args) throws Exception {
	new PopSynchronousTest(args).startTests();
	}


	/******** test assist ********/

	StackFrame frameFor(String methodName) throws Exception {
	Iterator it = mainThread.frames().iterator();

	while (it.hasNext()) {
	StackFrame frame = (StackFrame)it.next();
	if (frame.location().method().name().equals(methodName)) {
	return frame;
	}
	}
	failure("FAIL: " + methodName + " not on stack");
	return null;
	}

	String actual() throws Exception {
	Field field = targetClass.fieldByName("s");
	StringReference sr = (StringReference)(targetClass.getValue(field));
	return sr.value();
	}

	void checkExpected() throws Exception {
	if (!actual().equals(expected)) {
	failure("FAIL: expected value: " + expected +
	" got: " + actual());
	}
	}

	int methodIndex(String methodName) {
	for (int i = 0; i < popMax; ++i) {
	if (methodName.equals(calls[i])) {
	return i;
	}
	}
	return -1;
	}

	boolean isTop(String methodName) throws Exception {
	return mainThread.frame(0).location().method().name().equals(methodName);
	}

	void checkTop(String methodName, boolean atStart) throws Exception {
	Location loc = mainThread.frame(0).location();
	Method meth = loc.method();
	String name = meth.name();
	if (!isTop(methodName)) {
	failure("FAIL: expected " + methodName +
	" at top of stack, instead: " + name);
	} else if ((meth.location().codeIndex() == loc.codeIndex()) != atStart) {
	failure("FAIL: not at expect position: " + loc.codeIndex());
	}
	}

	void checkState() throws Exception {
	String name = states[stateIndex];
	int dash = name.indexOf('-');
	String methodName = name.substring(0,dash);
	String posName = name.substring(dash+1);
	checkTop(methodName, posName.equals("e"));
	checkExpected();
	}

	void incrementState() {
	stateIndex = (stateIndex + 1) % (states.length);
	}

	void resetState(String stateName) {
	for (int i=0; i < states.length; ++i) {
	if (states[i].equals(stateName)) {
	stateIndex = i;
	return;
	}
	}
	failure("TEST FAILURE: cannot find state: " + stateName);
	}

	void resetExpected() throws Exception {
	println("Current value: " + actual());
	Field field = targetClass.fieldByName("s");
	expected = "";
	((ClassType)targetClass).setValue(field, vm().mirrorOf(expected));
	}

	void stateTo(String stateName) {
	do {
	incrementState();
	expected += output[stateIndex];
	} while(!states[stateIndex].equals(stateName));
	}

	void resumeTo(String methodName) throws Exception {
	List meths = targetClass.methodsByName(methodName);
	Method meth = (Method)(meths.get(0));
	resumeTo(meth.location());
	stateTo(methodName + "-e");
	checkState();
	}

	void pop(String methodName) throws Exception {
	mainThread.popFrames(frameFor(methodName));
	resetState(methodName + "-e");
	--stateIndex;
	checkState();
	}

	void reenter(String methodName) throws Exception {
	pop(methodName);
	stepIntoInstruction(mainThread);
	incrementState();
	checkState();
	}

	/******** test core ********/

	protected void runTests() throws Exception {
	/*
	* Get to the top of main()
	* to determine targetClass and mainThread
	*/
	BreakpointEvent bpe = startToMain("PopSynchronousTarg");
	targetClass = bpe.location().declaringType();
	mainThread = bpe.thread();

	/*
	* Testing
	*/

	/* individual tests */
	for (int i = 0; i < popMax; ++i) {
	String from = calls[i];
	for (int j = i; j < popMax; ++j) {
	String to = calls[j];
	String prev = calls[j+1];
	println("TEST pop from '" + from + "' to '" + to + "'");
	resumeTo(from);
	reenter(to);
	resumeTo("report");
	resetExpected();
	}
	}

	/* sequential tests */

	println("TEST pop a b c p");
	resumeTo("a");
	pop("a");
	pop("b");
	pop("c");
	pop("p");
	resumeTo("report");
	resetExpected();

	println("TEST pop a c p");
	resumeTo("a");
	pop("a");
	pop("c");
	pop("p");
	resumeTo("report");
	resetExpected();

	println("TEST stress a");
	resumeTo("a");
	for (int i = 0; i < 100; ++i) {
	reenter("a");
	}
	resumeTo("report");
	resetExpected();

	println("TEST stress c");
	resumeTo("c");
	for (int i = 0; i < 100; ++i) {
	reenter("c");
	}
	resumeTo("report");
	resetExpected();

	/*
	* we are done, get rid of target
	*/
	vm().dispose();

	/*
	* deal with results of test
	* if anything has called failure("foo") testFailed will be true
	*/
	if (!testFailed) {
	println("PopSynchronousTest: passed");
	} else {
	throw new Exception("PopSynchronousTest: failed");
	}
	}
	}