test/hotspot/jtreg/vmTestbase/nsk/jvmti/scenarios/hotswap/HS201/hs201t003.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2004, 2018, 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.
  */

 package nsk.jvmti.scenarios.hotswap.HS201;

 import java.io.*;
 import java.util.*;
 import nsk.share.*;
 import nsk.share.jvmti.*;

 /**
  * The test implements the JVMTI <i>hotswap</i> scenario <code>HS201</code>:
  * <ol><li> Enable events Exception, MethodExit, FramePop.</li>
  *     <li> Call method a() which calls method b().</li>
  *     <li> Throw an uncaught exception in the method b().</li>
  *     <li> Redefine a class with the changed methods a() and b() within
  *         triggered callbacks Exception, MethodExit, FramePop caused by
  *         the uncaught exception. New version contains the changed methods
  *         a() and b(). Both methods should stay obsolete during their
  *         execution.</li>
  * </ol>
  * The classfile redefinition and all checks are performed during the
  * appropriate triggered callbacks. The methods are checked for obsolescence
  * by analyzing length of the byte code array that implement the redefined
  * method. The reason is that method ID from input parameters will be
  * reasigned to the new method during execution of the very first callback but
  * it will be already referred to the old method in the others subsequent
  * callbacks in accordance with the JVMTI spec:
  * <blockquote><i>An original method version which is not equivalent to
  * the new method version is called obsolete and is assigned a new method
  * ID; the original method ID now refers to the new method version</i></blockquote>
  */
 public class hs201t003 extends DebugeeClass {
     final static String REDEF_CLS_SIGNATURE =
         "Lnsk/jvmti/scenarios/hotswap/HS201/hs201t003r;";

     static int status = Consts.TEST_PASSED;

     static Log log = null;

     // path to the directory with redefining class files
     static String clfBasePath = null;

     // refer to a tested class to be redefined
     hs201t003r redefCls;

     native static void storeClassBytes(byte[] classBytes);

     public static void main(String args[]) {
         args = nsk.share.jvmti.JVMTITest.commonInit(args);

         // produce JCK-like exit status.
         System.exit(run(args, System.out) + Consts.JCK_STATUS_BASE);
     }

     public static int run(String args[], PrintStream out) {
         return new hs201t003().runIt(args, out);
     }

     private int runIt(String args[], PrintStream out) {
         int iter;

         ArgumentHandler argHandler = new ArgumentHandler(args);
         log = new Log(out, argHandler);

         try {
             // directory to search a redefining class
             clfBasePath = args[0];
         } catch(Exception e) {
             throw new Failure("TEST BUG: Wrong test parameters, caught: "
                 + e);
         }

         storeClassBytes(loadFromClassFile(REDEF_CLS_SIGNATURE));

         // testing sync
         log.display("waiting for the agent start ...\n");
         status = checkStatus(status);

         log.display("starting an auxiliary thread ...\n");
         RedefClassWrapper redefClsWrapper = new RedefClassWrapper();
         redefClsWrapper.setDaemon(true);
         synchronized(redefClsWrapper) {
             redefClsWrapper.start();
             log.display("waiting for auxiliary thread readiness...\n");
             try {
                 redefClsWrapper.wait(); // wait for the thread's readiness
             } catch (InterruptedException e) {
                 redefClsWrapper.interrupt();
                 throw new Failure("TEST FAILURE: waiting for auxiliary thread start, caught: "
                     + e);
             }
         }

         // testing sync
         log.display("auxiliary thread started\n"
             + "waiting for the agent finish ...\n");
         status = checkStatus(status);

         log.display("waiting for auxiliary thread ...\n");
         redefClsWrapper.stopMe = true;
         try {
             redefClsWrapper.join();
         } catch (InterruptedException e) {
             redefClsWrapper.interrupt();
             throw new Failure("TEST FAILURE: waiting for auxiliary thread death, caught: "
                 + e);
         }

         // verify classfile redefinition
         try {
             redefCls.entryMethod();
         } catch(Exception e) {
             ; // ignoring
         }
         if (redefCls.entryMethodFld == 0 || redefCls.entryMethod2Fld == 0) {
             status = Consts.TEST_FAILED;
             log.complain("TEST FAILED: tested class has not been redefined:\n"
                 + "\tthe class fields still have old values: "
                 + redefCls.entryMethodFld + " " + redefCls.entryMethodFld
                 + "\n\texpected values: 1 1");
         }
         else
             log.display("CHECK PASSED: tested class has been redefined");

         return status;
     }

     /**
      * Load bytes of a redefining class.
      */
     private static byte[] loadFromClassFile(String signature) {
         String testPath = clfBasePath + File.separator
             + "newclass" + File.separator
             + signature.substring(1, signature.length()-1).replace('/', File.separatorChar)
             + ".class";
         File classFile = null;

         log.display("looking for class file at\n\t"
             + testPath + " ...\n");

         try {
             classFile = new File(testPath);
         } catch (NullPointerException e) {
             throw new Failure("FAILURE: failed to open class file, caught: "
                 + e);
         }

         log.display("loading " + classFile.length()
             + " bytes from class file "+ testPath + " ...\n");
         byte[] buf = new byte[(int) classFile.length()];
         try {
             InputStream in = new FileInputStream(classFile);
             in.read(buf);
             in.close();
         } catch (Exception e) {
             throw new Failure("FAILURE: failed to load bytes from class file, caught: "
                 + e);
         }

         log.display(classFile.length()
             + " bytes of a redefining class loaded\n");

         return buf;
     }

     /**
      * Class executing a class to be redefined.
      */
     class RedefClassWrapper extends Thread {
         boolean stopMe = false;

         RedefClassWrapper() {
             super("RedefClassWrapper");
         }

         public void run() {
             log.display(this.getName() + ": started");

             redefCls = new hs201t003r();

             synchronized(this) {
                 this.notify(); // notify the main thread

                 while(!stopMe) {
                     try {
                         redefCls.entryMethod();
                     } catch(Exception e) {
                         break; // ignoring
                     }

                     // get the main thread chance to obtain CPU
                     try {
                         this.wait(100);
                     } catch(Exception e) {}
                 }

                 log.display(this.getName() + ": exiting");
             }
         }
     }
     /*************************************************************/

 }

 /**
  * A class to be redefined in an agent.
  */
 class hs201t003r {
     // dummy fields used only to verify class file redefinition
     public static int entryMethodFld = 0;
     public static int entryMethod2Fld = 0;

     void entryMethod() throws Exception {
         entryMethod2();
     }

     void entryMethod2() throws Exception {
         String str = "Tasya";
         int i = 10;
         i +=10;
         i--;
         String str2 = "Hi " + str;

         throw new Exception("Test exception");
     }
 }
	/*
	* Copyright (c) 2004, 2018, 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.
	*/

	package nsk.jvmti.scenarios.hotswap.HS201;

	import java.io.*;
	import java.util.*;
	import nsk.share.*;
	import nsk.share.jvmti.*;

	/**
	* The test implements the JVMTI <i>hotswap</i> scenario <code>HS201</code>:
	* <ol><li> Enable events Exception, MethodExit, FramePop.</li>
	* <li> Call method a() which calls method b().</li>
	* <li> Throw an uncaught exception in the method b().</li>
	* <li> Redefine a class with the changed methods a() and b() within
	* triggered callbacks Exception, MethodExit, FramePop caused by
	* the uncaught exception. New version contains the changed methods
	* a() and b(). Both methods should stay obsolete during their
	* execution.</li>
	* </ol>
	* The classfile redefinition and all checks are performed during the
	* appropriate triggered callbacks. The methods are checked for obsolescence
	* by analyzing length of the byte code array that implement the redefined
	* method. The reason is that method ID from input parameters will be
	* reasigned to the new method during execution of the very first callback but
	* it will be already referred to the old method in the others subsequent
	* callbacks in accordance with the JVMTI spec:
	* <blockquote><i>An original method version which is not equivalent to
	* the new method version is called obsolete and is assigned a new method
	* ID; the original method ID now refers to the new method version</i></blockquote>
	*/
	public class hs201t003 extends DebugeeClass {
	final static String REDEF_CLS_SIGNATURE =
	"Lnsk/jvmti/scenarios/hotswap/HS201/hs201t003r;";

	static int status = Consts.TEST_PASSED;

	static Log log = null;

	// path to the directory with redefining class files
	static String clfBasePath = null;

	// refer to a tested class to be redefined
	hs201t003r redefCls;

	native static void storeClassBytes(byte[] classBytes);

	public static void main(String args[]) {
	args = nsk.share.jvmti.JVMTITest.commonInit(args);

	// produce JCK-like exit status.
	System.exit(run(args, System.out) + Consts.JCK_STATUS_BASE);
	}

	public static int run(String args[], PrintStream out) {
	return new hs201t003().runIt(args, out);
	}

	private int runIt(String args[], PrintStream out) {
	int iter;

	ArgumentHandler argHandler = new ArgumentHandler(args);
	log = new Log(out, argHandler);

	try {
	// directory to search a redefining class
	clfBasePath = args[0];
	} catch(Exception e) {
	throw new Failure("TEST BUG: Wrong test parameters, caught: "
	+ e);
	}

	storeClassBytes(loadFromClassFile(REDEF_CLS_SIGNATURE));

	// testing sync
	log.display("waiting for the agent start ...\n");
	status = checkStatus(status);

	log.display("starting an auxiliary thread ...\n");
	RedefClassWrapper redefClsWrapper = new RedefClassWrapper();
	redefClsWrapper.setDaemon(true);
	synchronized(redefClsWrapper) {
	redefClsWrapper.start();
	log.display("waiting for auxiliary thread readiness...\n");
	try {
	redefClsWrapper.wait(); // wait for the thread's readiness
	} catch (InterruptedException e) {
	redefClsWrapper.interrupt();
	throw new Failure("TEST FAILURE: waiting for auxiliary thread start, caught: "
	+ e);
	}
	}

	// testing sync
	log.display("auxiliary thread started\n"
	+ "waiting for the agent finish ...\n");
	status = checkStatus(status);

	log.display("waiting for auxiliary thread ...\n");
	redefClsWrapper.stopMe = true;
	try {
	redefClsWrapper.join();
	} catch (InterruptedException e) {
	redefClsWrapper.interrupt();
	throw new Failure("TEST FAILURE: waiting for auxiliary thread death, caught: "
	+ e);
	}

	// verify classfile redefinition
	try {
	redefCls.entryMethod();
	} catch(Exception e) {
	; // ignoring
	}
	if (redefCls.entryMethodFld == 0 \|\| redefCls.entryMethod2Fld == 0) {
	status = Consts.TEST_FAILED;
	log.complain("TEST FAILED: tested class has not been redefined:\n"
	+ "\tthe class fields still have old values: "
	+ redefCls.entryMethodFld + " " + redefCls.entryMethodFld
	+ "\n\texpected values: 1 1");
	}
	else
	log.display("CHECK PASSED: tested class has been redefined");

	return status;
	}

	/**
	* Load bytes of a redefining class.
	*/
	private static byte[] loadFromClassFile(String signature) {
	String testPath = clfBasePath + File.separator
	+ "newclass" + File.separator
	+ signature.substring(1, signature.length()-1).replace('/', File.separatorChar)
	+ ".class";
	File classFile = null;

	log.display("looking for class file at\n\t"
	+ testPath + " ...\n");

	try {
	classFile = new File(testPath);
	} catch (NullPointerException e) {
	throw new Failure("FAILURE: failed to open class file, caught: "
	+ e);
	}

	log.display("loading " + classFile.length()
	+ " bytes from class file "+ testPath + " ...\n");
	byte[] buf = new byte[(int) classFile.length()];
	try {
	InputStream in = new FileInputStream(classFile);
	in.read(buf);
	in.close();
	} catch (Exception e) {
	throw new Failure("FAILURE: failed to load bytes from class file, caught: "
	+ e);
	}

	log.display(classFile.length()
	+ " bytes of a redefining class loaded\n");

	return buf;
	}

	/**
	* Class executing a class to be redefined.
	*/
	class RedefClassWrapper extends Thread {
	boolean stopMe = false;

	RedefClassWrapper() {
	super("RedefClassWrapper");
	}

	public void run() {
	log.display(this.getName() + ": started");

	redefCls = new hs201t003r();

	synchronized(this) {
	this.notify(); // notify the main thread

	while(!stopMe) {
	try {
	redefCls.entryMethod();
	} catch(Exception e) {
	break; // ignoring
	}

	// get the main thread chance to obtain CPU
	try {
	this.wait(100);
	} catch(Exception e) {}
	}

	log.display(this.getName() + ": exiting");
	}
	}
	}
	/*************************************************************/

	}

	/**
	* A class to be redefined in an agent.
	*/
	class hs201t003r {
	// dummy fields used only to verify class file redefinition
	public static int entryMethodFld = 0;
	public static int entryMethod2Fld = 0;

	void entryMethod() throws Exception {
	entryMethod2();
	}

	void entryMethod2() throws Exception {
	String str = "Tasya";
	int i = 10;
	i +=10;
	i--;
	String str2 = "Hi " + str;

	throw new Exception("Test exception");
	}
	}