| /* |
| * Copyright (c) 2007, 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.share.jpda; |
| |
| import java.net.*; |
| import nsk.share.*; |
| |
| /* |
| * This thread class executes in loop native methods with different return types |
| */ |
| public class NativeMethodsTestThread extends Thread { |
| |
| static { |
| System.loadLibrary("NativeMethodsTestThread"); |
| } |
| |
| native void VoidMethod(String message); |
| |
| native boolean BooleanMethod(String message); |
| |
| native byte ByteMethod(String message); |
| |
| native short ShortMethod(String message); |
| |
| native char CharMethod(String message); |
| |
| native int IntMethod(String message); |
| |
| native long LongMethod(String message); |
| |
| native float FloatMethod(String message); |
| |
| native double DoubleMethod(String message); |
| |
| native Object[] ObjectArrayMethod(String message); |
| |
| native String StringMethod(String message); |
| |
| native Thread ThreadMethod(String message); |
| |
| native ThreadGroup ThreadGroupMethod(String message); |
| |
| native Class ClassObjectMethod(String message); |
| |
| native ClassLoader ClassLoaderMethod(String message); |
| |
| native Object ObjectMethod(String message); |
| |
| native Boolean BooleanWrapperMethod(String message); |
| |
| native Byte ByteWrapperMethod(String message); |
| |
| native Short ShortWrapperMethod(String message); |
| |
| native Character CharWrapperMethod(String message); |
| |
| native Integer IntWrapperMethod(String message); |
| |
| native Long LongWrapperMethod(String message); |
| |
| native Float FloatWrapperMethod(String message); |
| |
| native Double DoubleWrapperMethod(String message); |
| |
| private void log(String message) { |
| log.display(message); |
| } |
| |
| public static boolean expectedBooleanValue = Boolean.TRUE; |
| |
| public static byte expectedByteValue = Byte.MAX_VALUE; |
| |
| public static char expectedCharValue = Character.MAX_VALUE; |
| |
| public static short expectedShortValue = Short.MAX_VALUE; |
| |
| public static int expectedIntValue = Integer.MAX_VALUE; |
| |
| public static long expectedLongValue = Long.MAX_VALUE; |
| |
| public static float expectedFloatValue = Float.MAX_VALUE; |
| |
| public static double expectedDoubleValue = Double.MAX_VALUE; |
| |
| public static Object[] expectedObjectArrayValue = new Object[1000]; |
| |
| public static Thread expectedThreadValue = new Thread(); |
| |
| public static ThreadGroup expectedThreadGroupValue = new ThreadGroup("Expected thread group"); |
| |
| public static Class expectedClassObjectValue = NativeMethodsTestThread.class; |
| |
| public static ClassLoader expectedClassLoaderValue = new URLClassLoader(new URL[] {}); |
| |
| public static String expectedStringValue = "EXPECTED STRING"; |
| |
| public static Object expectedObjectValue = new Object(); |
| |
| public static Boolean expectedBooleanWrapperValue = new Boolean(Boolean.TRUE); |
| |
| public static Byte expectedByteWrapperValue = new Byte(Byte.MAX_VALUE); |
| |
| public static Character expectedCharWrapperValue = new Character(Character.MAX_VALUE); |
| |
| public static Short expectedShortWrapperValue = new Short(Short.MAX_VALUE); |
| |
| public static Integer expectedIntWrapperValue = new Integer(Integer.MAX_VALUE); |
| |
| public static Long expectedLongWrapperValue = new Long(Long.MAX_VALUE); |
| |
| public static Float expectedFloatWrapperValue = new Float(Float.MAX_VALUE); |
| |
| public static Double expectedDoubleWrapperValue = new Double(Double.MAX_VALUE); |
| |
| // names of tested types, this names can be used to derive names of tested methods(typeName + 'Method'), |
| public static String testedTypesNames[] = {"Void", "Boolean", "Byte", "Short", "Char", "Int", "Long", "Float", "Double", "ObjectArray", |
| "String", "Thread", "ThreadGroup", "ClassObject", "ClassLoader", "Object", "BooleanWrapper", "ByteWrapper", "ShortWrapper", |
| "CharWrapper", "IntWrapper", "LongWrapper", "FloatWrapper", "DoubleWrapper" }; |
| |
| private Log log; |
| |
| // is forceEarlyReturn would called for this thread |
| private boolean isTestThread; |
| |
| // how many times call all test methods |
| private int iterationsNumber = 1; |
| |
| // test thread wait on 'startExecutionWicket' in beginning of run() |
| private Wicket startExecutionWicket = new Wicket(); |
| |
| private boolean success = true; |
| |
| public NativeMethodsTestThread(Log log, boolean isTestThread, int iterationNumber) { |
| this.log = log; |
| this.isTestThread = isTestThread; |
| |
| this.iterationsNumber = iterationNumber; |
| } |
| |
| private volatile boolean stopExecution; |
| |
| public void stopExecution() { |
| stopExecution = true; |
| } |
| |
| public void startExecuion() { |
| startExecutionWicket.unlockAll(); |
| } |
| |
| public void run() { |
| // first, debuggee VM starts and suspends test threads to let debugger initialize breakpoints |
| startExecutionWicket.waitFor(); |
| |
| int iterationCount = 0; |
| |
| // test thread executes test methods 'iterationNumber' times |
| // non-test thread execute until not interrupted |
| while ((iterationCount++ < iterationsNumber) || (!isTestThread && !stopExecution)) { |
| // execute test methods in order given in 'testMethodsNames' array |
| for (int i = 0; i < testedTypesNames.length; i++) { |
| executeMethod(testedTypesNames[i] + "Method"); |
| } |
| } |
| |
| log("Test thread exit"); |
| } |
| |
| // execute test method and check that correct value is returned |
| private void executeMethod(String methodName) { |
| String message = Thread.currentThread() + " in " + methodName; |
| if (methodName.equals("VoidMethod")) { |
| VoidMethod(message); |
| } |
| if (methodName.equals("BooleanMethod")) { |
| boolean result = BooleanMethod(message); |
| |
| log("Result: " + result); |
| } |
| if (methodName.equals("ByteMethod")) { |
| byte result = ByteMethod(message); |
| |
| log("Result: " + result); |
| } |
| if (methodName.equals("CharMethod")) { |
| char result = CharMethod(message); |
| |
| log("Result: " + result); |
| } |
| if (methodName.equals("ShortMethod")) { |
| short result = ShortMethod(message); |
| |
| log("Result: " + result); |
| } |
| if (methodName.equals("IntMethod")) { |
| int result = IntMethod(message); |
| |
| log("Result: " + result); |
| } |
| if (methodName.equals("LongMethod")) { |
| long result = LongMethod(message); |
| |
| log("Result: " + result); |
| } |
| if (methodName.equals("FloatMethod")) { |
| float result = FloatMethod(message); |
| |
| log("Result: " + result); |
| } |
| if (methodName.equals("DoubleMethod")) { |
| double result = DoubleMethod(message); |
| |
| log("Result: " + result); |
| } |
| if (methodName.equals("StringMethod")) { |
| String result = StringMethod(message); |
| |
| log("Result: " + result); |
| } |
| if (methodName.equals("ObjectMethod")) { |
| Object result = ObjectMethod(message); |
| |
| log("Result: " + result); |
| } |
| if (methodName.equals("ObjectArrayMethod")) { |
| Object[] result = ObjectArrayMethod(message); |
| |
| log("Result: " + result); |
| } |
| if (methodName.equals("ThreadMethod")) { |
| Thread result = ThreadMethod(message); |
| |
| log("Result: " + result); |
| } |
| if (methodName.equals("ThreadGroupMethod")) { |
| ThreadGroup result = ThreadGroupMethod(message); |
| |
| log("Result: " + result); |
| } |
| if (methodName.equals("ClassObjectMethod")) { |
| Class result = ClassObjectMethod(message); |
| |
| log("Result: " + result); |
| } |
| if (methodName.equals("ClassLoaderMethod")) { |
| ClassLoader result = ClassLoaderMethod(message); |
| |
| log("Result: " + result); |
| } |
| if (methodName.equals("BooleanWrapperMethod")) { |
| Boolean result = BooleanWrapperMethod(message); |
| |
| log("Result: " + result); |
| } |
| if (methodName.equals("ByteWrapperMethod")) { |
| Byte result = ByteWrapperMethod(message); |
| |
| log("Result: " + result); |
| } |
| if (methodName.equals("ShortWrapperMethod")) { |
| Short result = ShortWrapperMethod(message); |
| |
| log("Result: " + result); |
| } |
| if (methodName.equals("CharWrapperMethod")) { |
| Character result = CharWrapperMethod(message); |
| |
| log("Result: " + result); |
| } |
| if (methodName.equals("IntWrapperMethod")) { |
| Integer result = IntWrapperMethod(message); |
| |
| log("Result: " + result); |
| } |
| if (methodName.equals("LongWrapperMethod")) { |
| Long result = LongWrapperMethod(message); |
| |
| log("Result: " + result); |
| } |
| if (methodName.equals("FloatWrapperMethod")) { |
| Float result = FloatWrapperMethod(message); |
| |
| log("Result: " + result); |
| } |
| if (methodName.equals("DoubleWrapperMethod")) { |
| Double result = DoubleWrapperMethod(message); |
| |
| log("Result: " + result); |
| } |
| } |
| |
| public boolean getSuccess() { |
| return success; |
| } |
| } |