315 lines
10 KiB
Java
315 lines
10 KiB
Java
/*
|
|
* Copyright (c) 2007, 2021, 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 = Boolean.valueOf(Boolean.TRUE);
|
|
|
|
public static Byte expectedByteWrapperValue = Byte.valueOf(Byte.MAX_VALUE);
|
|
|
|
public static Character expectedCharWrapperValue = Character.valueOf(Character.MAX_VALUE);
|
|
|
|
public static Short expectedShortWrapperValue = Short.valueOf(Short.MAX_VALUE);
|
|
|
|
public static Integer expectedIntWrapperValue = Integer.valueOf(Integer.MAX_VALUE);
|
|
|
|
public static Long expectedLongWrapperValue = Long.valueOf(Long.MAX_VALUE);
|
|
|
|
public static Float expectedFloatWrapperValue = Float.valueOf(Float.MAX_VALUE);
|
|
|
|
public static Double expectedDoubleWrapperValue = Double.valueOf(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;
|
|
}
|
|
}
|