infernap12/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2026-07-20 07:58:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

8014755: [TEST_BUG] frames didn't closed after execution some awt/dnd/ tests

Browse Source 
Reviewed-by: serb, pchelko
This commit is contained in:
Oleg Pekhovskiy 2014-05-15 20:09:38 +04:00
parent a89eab1dc7
commit 9aa0cef64a
10 changed files with 1545 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
jdk/test/java/awt/dnd/DragInterceptorAppletTest/DragInterceptorAppletTest.html Normal file
View File

@ -0,0 +1,48 @@
<!--
Copyright (c) 2014, 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.
-->
<html>
<!--
@test
@bug 6887703
@summary Unsigned applet can retrieve the dragged information before drop action occurs
@author : area=dnd
@library ../../regtesthelpers
@library ../../regtesthelpers/process
@build Util
@build ProcessResults ProcessCommunicator
@run applet/othervm DragInterceptorAppletTest.html
-->
<head>
<title> Unsigned applet can retrieve the dragged information before drop action occurs </title>
</head>
<body>
<h1>DragInterceptorAppletTest<br>Bug ID: 6887703</h1>
<p> This is an AUTOMATIC test, simply wait for completion </p>
<APPLET CODE="DragInterceptorAppletTest.class" WIDTH=200 HEIGHT=200></APPLET>
</body>
</html>

154
jdk/test/java/awt/dnd/DragInterceptorAppletTest/DragInterceptorAppletTest.java Normal file
View File

@ -0,0 +1,154 @@
/*
* Copyright (c) 2007, 2014, 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 6887703
@summary Unsigned applet can retrieve the dragged information before drop action occurs
@author : area=dnd
@run applet DragInterceptorAppletTest.html
*/
/**
* DragInterceptorAppletTest.java
*
* summary: Unsigned applet can retrieve the dragged information before drop action occurs
*/
import static java.lang.Thread.sleep;
import test.java.awt.regtesthelpers.process.ProcessCommunicator;
import test.java.awt.regtesthelpers.process.ProcessResults;
import test.java.awt.regtesthelpers.Util;
import java.applet.Applet;
import java.awt.*;
import java.awt.event.InputEvent;
public class DragInterceptorAppletTest extends Applet {
public void init() {
setLayout(new BorderLayout());
}//End init()
public void start() {
SourceFrame sourceFrame = new SourceFrame();
Util.waitForIdle(null);
String [] args = new String [] {
String.valueOf(sourceFrame.getNextLocationX()),
String.valueOf(sourceFrame.getNextLocationY()),
String.valueOf(sourceFrame.getDragSourcePointX()),
String.valueOf(sourceFrame.getDragSourcePointY()),
};
String classpath = System.getProperty("java.class.path");
ProcessResults processResults =
ProcessCommunicator.executeChildProcess(this.getClass(),classpath,args);
verifyTestResults(processResults);
}// start()
private static void verifyTestResults(ProcessResults processResults) {
switch (processResults.getExitValue()) {
case InterprocessMessages.DATA_WAS_INTERCEPTED_AND_EXCEPTION_HANDLER_WAS_NOT_TRIGGERED:
processResults.printProcessErrorOutput(System.err);
throw new RuntimeException("TEST IS FAILED: Target applet can intercept data " +
"without a clipboard permission and an exception handler was not triggered.");
//Unreachable...
case InterprocessMessages.DATA_WAS_INTERCEPTED:
processResults.printProcessErrorOutput(System.err);
throw new RuntimeException("TEST IS FAILED: Target applet can intercept data " +
"without a clipboard permission");
//Unreachable...
case InterprocessMessages.EXCEPTION_HANDLER_WAS_NOT_TRIGGERED:
processResults.printProcessErrorOutput(System.err);
throw new RuntimeException("TEST IS FAILED: An exception handler was not triggered.");
//Unreachable...
}
// The child process throws an exception. do not look at the stderr.
processResults.verifyStdErr(System.err);
processResults.verifyProcessExitValue(System.err);
processResults.printProcessStandartOutput(System.out);
}
//We cannot make an instance of the applet without the default constructor
public DragInterceptorAppletTest() {
super();
}
//We need in this constructor to pass frame position between JVMs
public DragInterceptorAppletTest(Point targetFrameLocation, Point dragSourcePoint)
throws InterruptedException
{
DragInterceptorFrame targetFrame = new DragInterceptorFrame(targetFrameLocation);
Util.waitForIdle(null);
final Robot robot = Util.createRobot();
robot.mouseMove((int)dragSourcePoint.getX(),(int)dragSourcePoint.getY());
sleep(100);
robot.mousePress(InputEvent.BUTTON1_MASK);
sleep(100);
robot.mouseRelease(InputEvent.BUTTON1_MASK);
sleep(100);
Util.drag(robot, dragSourcePoint, targetFrame.getDropTargetPoint(),
InputEvent.BUTTON1_MASK);
sleep(2000);
ProcessCommunicator.destroyProcess();
}
enum InterprocessArguments {
TARGET_FRAME_X_POSITION_ARGUMENT,
TARGET_FRAME_Y_POSITION_ARGUMENT,
DRAG_SOURCE_POINT_X_ARGUMENT,
DRAG_SOURCE_POINT_Y_ARGUMENT;
int extract (String [] args) {
return Integer.parseInt(args[this.ordinal()]);
}
}
public static void main (String [] args) {
Point dragSourcePoint = new Point(InterprocessArguments.DRAG_SOURCE_POINT_X_ARGUMENT.extract(args),
InterprocessArguments.DRAG_SOURCE_POINT_Y_ARGUMENT.extract(args));
Point targetFrameLocation = new Point(InterprocessArguments.TARGET_FRAME_X_POSITION_ARGUMENT.extract(args),
InterprocessArguments.TARGET_FRAME_Y_POSITION_ARGUMENT.extract(args));
try {
new DragInterceptorAppletTest(targetFrameLocation, dragSourcePoint);
} catch (InterruptedException e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
}// class DragInterceptorAppletTest

128
jdk/test/java/awt/dnd/DragInterceptorAppletTest/DragInterceptorFrame.java Normal file
View File

@ -0,0 +1,128 @@
/*
* Copyright (c) 2007, 2014, 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.
*/
import java.awt.*;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.dnd.*;
import java.io.IOException;
import java.security.Permission;
import java.security.AccessControlException;
class DragInterceptorFrame extends Frame implements DropTargetListener {
private static int exitMessage = InterprocessMessages.TEST_PASSED;
private static boolean dataIsAccessible = false;
private static boolean exceptionHasBeenThrown = false;
DragInterceptorFrame(Point location) {
System.setSecurityManager(new ClipboardDefender());
initGUI(location);
setDropTarget(new DropTarget(this, DnDConstants.ACTION_COPY,
this));
}
private void initGUI(Point location) {
this.setLocation(location);
this.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
DragInterceptorFrame.this.dispose();
}
});
setSize (200, 200);
this.setVisible(true);
}
public void dragEnter(DropTargetDragEvent dtde) {
// We want to set the exception handler on EDT
Thread.currentThread().setUncaughtExceptionHandler (
new Thread.UncaughtExceptionHandler() {
public void uncaughtException(Thread t, Throwable e) {
exceptionHasBeenThrown = true;
}
}
);
examineTransferable(dtde);
}
public void dragOver(DropTargetDragEvent dtde) {
examineTransferable(dtde);
}
public void dropActionChanged(DropTargetDragEvent dtde) {
examineTransferable(dtde);
}
public void dragExit(DropTargetEvent dte) {}
public void drop(DropTargetDropEvent dtde) {
if (dataIsAccessible && !exceptionHasBeenThrown) {
exitMessage = InterprocessMessages.DATA_WAS_INTERCEPTED_AND_EXCEPTION_HANDLER_WAS_NOT_TRIGGERED;
} else if (dataIsAccessible) {
exitMessage = InterprocessMessages.DATA_WAS_INTERCEPTED;
} else if (!exceptionHasBeenThrown) {
exitMessage = InterprocessMessages.EXCEPTION_HANDLER_WAS_NOT_TRIGGERED;
}
// This returns the diagnostic code from the child VM
System.exit(exitMessage);
}
Point getDropTargetPoint() {
return new Point((int)getLocationOnScreen().getX()+(getWidth()/2),
(int)getLocationOnScreen().getY()+(getHeight()/2));
}
private void examineTransferable(DropTargetDragEvent dtde) {
if (dtde.getCurrentDataFlavorsAsList().contains(DataFlavor.stringFlavor)) {
dtde.acceptDrag(DnDConstants.ACTION_COPY);
try{
if (null != dtde.getTransferable().getTransferData(DataFlavor.stringFlavor)) {
dataIsAccessible = true;
}
} catch (IOException e) {
e.printStackTrace();
exitMessage = InterprocessMessages.UNEXPECTED_IO_EXCEPTION;
} catch (UnsupportedFlavorException e) {
e.printStackTrace();
exitMessage = InterprocessMessages.UNEXPECTED_UNSUPPORTED_FLAVOR_EXCEPTION;
}
}
}
static class ClipboardDefender extends SecurityManager {
public void checkPermission(Permission p) {
if (p instanceof java.awt.AWTPermission &&
p.getName().equals("accessClipboard")) {
throw new AccessControlException("access denied ");
}
}
}
public static void main(String[] args) {
new DragInterceptorFrame(new Point(200,200));
}
}

32
jdk/test/java/awt/dnd/DragInterceptorAppletTest/InterprocessMessages.java Normal file
View File

@ -0,0 +1,32 @@
/*
* Copyright (c) 2007, 2014, 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.
*/
public interface InterprocessMessages {
final static int TEST_PASSED = 0;
final static int DATA_WAS_INTERCEPTED = 212;
final static int EXCEPTION_HANDLER_WAS_NOT_TRIGGERED = 213;
final static int DATA_WAS_INTERCEPTED_AND_EXCEPTION_HANDLER_WAS_NOT_TRIGGERED = 214;
final static int UNEXPECTED_IO_EXCEPTION = 400;
final static int UNEXPECTED_UNSUPPORTED_FLAVOR_EXCEPTION = 401;
}

68
jdk/test/java/awt/dnd/DragInterceptorAppletTest/SourceFrame.java Normal file
View File

@ -0,0 +1,68 @@
/*
* Copyright (c) 2007, 2014, 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.
*/
import test.java.awt.regtesthelpers.Util;
import java.awt.*;
import java.awt.datatransfer.StringSelection;
import java.awt.dnd.DragGestureListener;
import java.awt.dnd.DragSource;
import java.awt.dnd.DnDConstants;
import java.awt.dnd.DragGestureEvent;
class SourceFrame extends Frame implements DragGestureListener {
SourceFrame() {
super("Source File List Frame");
initGUI();
new DragSource().createDefaultDragGestureRecognizer(this,
DnDConstants.ACTION_COPY,this);
}
private void initGUI() {
this.addWindowListener(Util.getClosingWindowAdapter());
this.setLocation(300,250);
this.setSize(200,200);
this.setVisible(true);
}
int getNextLocationX() {
return getX()+getWidth();
}
int getNextLocationY() {
return getY();
}
int getDragSourcePointX() {
return (int)getLocationOnScreen().getX()+(getWidth()/2);
}
int getDragSourcePointY() {
return (int)getLocationOnScreen().getY()+ (getHeight()/2);
}
public void dragGestureRecognized(DragGestureEvent dge) {
dge.startDrag(null, new StringSelection("A TEXT"));
}
}

43
jdk/test/java/awt/dnd/InterJVMGetDropSuccessTest/InterJVMGetDropSuccessTest.html Normal file
View File

@ -0,0 +1,43 @@
<!--
Copyright (c) 2014, 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.
-->
<html>
<!--
@test
@bug 4658741
@summary verifies that getDropSuccess() returns correct value for inter-JVM DnD
@author das@sparc.spb.su area=dnd
@run applet InterJVMGetDropSuccessTest.html
-->
<head>
<title> </title>
</head>
<body>
<h1>InterJVMGetDropSuccessTest<br>Bug ID: 4658741</h1>
<p> This is an AUTOMATIC test, simply wait for completion </p>
<APPLET CODE="InterJVMGetDropSuccessTest.class" WIDTH=200 HEIGHT=200></APPLET>
</body>
</html>

499
jdk/test/java/awt/dnd/InterJVMGetDropSuccessTest/InterJVMGetDropSuccessTest.java Normal file
View File

@ -0,0 +1,499 @@
/*
* Copyright (c) 2014, 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 4658741
@summary verifies that getDropSuccess() returns correct value for inter-JVM DnD
@author das@sparc.spb.su area=dnd
@run applet InterJVMGetDropSuccessTest.html
*/
// Note there is no @ in front of test above. This is so that the
// harness will not mistake this file as a test file. It should
// only see the html file as a test file. (the harness runs all
// valid test files, so it would run this test twice if this file
// were valid as well as the html file.)
// Also, note the area= after Your Name in the author tag. Here, you
// should put which functional area the test falls in. See the
// AWT-core home page -> test areas and/or -> AWT team for a list of
// areas.
// Note also the 'InterJVMGetDropSuccessTest.html' in the run tag. This should
// be changed to the name of the test.
/**
* InterJVMGetDropSuccessTest.java
*
* summary: verifies that getDropSuccess() returns correct value for inter-JVM DnD
*/
import java.applet.Applet;
import java.awt.*;
import java.awt.datatransfer.*;
import java.awt.dnd.*;
import java.awt.event.*;
import java.io.*;
import javax.swing.*;
//Automated tests should run as applet tests if possible because they
// get their environments cleaned up, including AWT threads, any
// test created threads, and any system resources used by the test
// such as file descriptors. (This is normally not a problem as
// main tests usually run in a separate VM, however on some platforms
// such as the Mac, separate VMs are not possible and non-applet
// tests will cause problems). Also, you don't have to worry about
// synchronisation stuff in Applet tests they way you do in main
// tests...
public class InterJVMGetDropSuccessTest extends Applet {
private int returnCode = Util.CODE_NOT_RETURNED;
private boolean successCodes[] = { true, false };
private int dropCount = 0;
final Frame frame = new Frame("Target Frame");
final DropTargetListener dropTargetListener = new DropTargetAdapter() {
public void drop(DropTargetDropEvent dtde) {
dtde.acceptDrop(DnDConstants.ACTION_COPY);
dtde.dropComplete(successCodes[dropCount]);
dropCount++;
}
};
final DropTarget dropTarget = new DropTarget(frame, dropTargetListener);
public void init() {
//Create instructions for the user here, as well as set up
// the environment -- set the layout manager, add buttons,
// etc.
String[] instructions =
{
"This is an AUTOMATIC test",
"simply wait until it is done"
};
Sysout.createDialog( );
Sysout.printInstructions( instructions );
frame.setTitle("Test frame");
frame.setBounds(100, 100, 150, 150);
} // init()
public void start() {
frame.setVisible(true);
try {
Thread.sleep(Util.FRAME_ACTIVATION_TIMEOUT);
Point p = frame.getLocationOnScreen();
Dimension d = frame.getSize();
String javaPath = System.getProperty("java.home", "");
String command = javaPath + File.separator + "bin" +
File.separator + "java -cp " + System.getProperty("test.classes", ".") +
" Child " +
p.x + " " + p.y + " " + d.width + " " + d.height;
Process process = Runtime.getRuntime().exec(command);
returnCode = process.waitFor();
InputStream errorStream = process.getErrorStream();
int count = errorStream.available();
if (count > 0) {
byte[] b = new byte[count];
errorStream.read(b);
System.err.println("========= Child VM System.err ========");
System.err.print(new String(b));
System.err.println("======================================");
}
InputStream outputStream = process.getInputStream();
count = outputStream.available();
if (count > 0) {
byte[] b = new byte[count];
outputStream.read(b);
System.err.println("========= Child VM System.out ========");
System.err.print(new String(b));
System.err.println("======================================");
}
} catch (Throwable e) {
e.printStackTrace();
throw new RuntimeException(e);
}
switch (returnCode) {
case Util.CODE_NOT_RETURNED:
throw new RuntimeException("Child VM: failed to start");
case Util.CODE_FAILURE:
throw new RuntimeException("Child VM: abnormal termination");
default:
if (dropCount == 2) {
int expectedRetCode = 0;
if (successCodes[0]) {
expectedRetCode |= Util.CODE_FIRST_SUCCESS;
}
if (successCodes[1]) {
expectedRetCode |= Util.CODE_SECOND_SUCCESS;
}
if (expectedRetCode != returnCode) {
throw new RuntimeException("The test failed. Expected:" +
expectedRetCode + ". Returned:" +
returnCode);
}
}
break;
}
} // start()
} // class InterJVMGetDropSuccessTest
final class Util implements AWTEventListener {
public static final int CODE_NOT_RETURNED = -1;
public static final int CODE_FIRST_SUCCESS = 0x2;
public static final int CODE_SECOND_SUCCESS = 0x2;
public static final int CODE_FAILURE = 0x1;
public static final int FRAME_ACTIVATION_TIMEOUT = 3000;
static final Object SYNC_LOCK = new Object();
static final int MOUSE_RELEASE_TIMEOUT = 1000;
static final Util theInstance = new Util();
static {
Toolkit.getDefaultToolkit().addAWTEventListener(theInstance, AWTEvent.MOUSE_EVENT_MASK);
}
public static Point getCenterLocationOnScreen(Component c) {
Point p = c.getLocationOnScreen();
Dimension d = c.getSize();
p.translate(d.width / 2, d.height / 2);
return p;
}
public static int sign(int n) {
return n < 0 ? -1 : n == 0 ? 0 : 1;
}
private Component clickedComponent = null;
private void reset() {
clickedComponent = null;
}
public void eventDispatched(AWTEvent e) {
if (e.getID() == MouseEvent.MOUSE_RELEASED) {
clickedComponent = (Component)e.getSource();
synchronized (SYNC_LOCK) {
SYNC_LOCK.notifyAll();
}
}
}
public static boolean pointInComponent(Robot robot, Point p, Component comp)
throws InterruptedException {
return theInstance.pointInComponentImpl(robot, p, comp);
}
private boolean pointInComponentImpl(Robot robot, Point p, Component comp)
throws InterruptedException {
robot.waitForIdle();
reset();
robot.mouseMove(p.x, p.y);
robot.mousePress(InputEvent.BUTTON1_MASK);
synchronized (SYNC_LOCK) {
robot.mouseRelease(InputEvent.BUTTON1_MASK);
SYNC_LOCK.wait(MOUSE_RELEASE_TIMEOUT);
}
Component c = clickedComponent;
while (c != null && c != comp) {
c = c.getParent();
}
return c == comp;
}
}
class Child {
static class DragSourceDropListener extends DragSourceAdapter {
private boolean finished = false;
private boolean dropSuccess = false;
public void reset() {
finished = false;
dropSuccess = false;
}
public boolean isDropFinished() {
return finished;
}
public boolean getDropSuccess() {
return dropSuccess;
}
public void dragDropEnd(DragSourceDropEvent dsde) {
finished = true;
dropSuccess = dsde.getDropSuccess();
synchronized (Util.SYNC_LOCK) {
Util.SYNC_LOCK.notifyAll();
}
}
}
final Frame frame = new Frame("Source Frame");
final DragSource dragSource = DragSource.getDefaultDragSource();
final DragSourceDropListener dragSourceListener = new DragSourceDropListener();
final Transferable transferable = new StringSelection("TEXT");
final DragGestureListener dragGestureListener = new DragGestureListener() {
public void dragGestureRecognized(DragGestureEvent dge) {
dge.startDrag(null, transferable, dragSourceListener);
}
};
final DragGestureRecognizer dragGestureRecognizer =
dragSource.createDefaultDragGestureRecognizer(frame, DnDConstants.ACTION_COPY,
dragGestureListener);
public static void main(String[] args) {
Child child = new Child();
child.run(args);
}
public void run(String[] args) {
try {
if (args.length != 4) {
throw new RuntimeException("Incorrect command line arguments.");
}
int x = Integer.parseInt(args[0]);
int y = Integer.parseInt(args[1]);
int w = Integer.parseInt(args[2]);
int h = Integer.parseInt(args[3]);
frame.setBounds(300, 200, 150, 150);
frame.setVisible(true);
Thread.sleep(Util.FRAME_ACTIVATION_TIMEOUT);
Point sourcePoint = Util.getCenterLocationOnScreen(frame);
Point targetPoint = new Point(x + w / 2, y + h / 2);
Robot robot = new Robot();
robot.mouseMove(sourcePoint.x, sourcePoint.y);
robot.mousePress(InputEvent.BUTTON1_MASK);
for (Point p = new Point(sourcePoint); !p.equals(targetPoint);
p.translate(Util.sign(targetPoint.x - p.x),
Util.sign(targetPoint.y - p.y))) {
robot.mouseMove(p.x, p.y);
Thread.sleep(50);
}
synchronized (Util.SYNC_LOCK) {
robot.mouseRelease(InputEvent.BUTTON1_MASK);
Util.SYNC_LOCK.wait(Util.FRAME_ACTIVATION_TIMEOUT);
}
if (!dragSourceListener.isDropFinished()) {
throw new RuntimeException("Drop not finished");
}
boolean success1 = dragSourceListener.getDropSuccess();
dragSourceListener.reset();
robot.mouseMove(sourcePoint.x, sourcePoint.y);
robot.mousePress(InputEvent.BUTTON1_MASK);
for (Point p = new Point(sourcePoint); !p.equals(targetPoint);
p.translate(Util.sign(targetPoint.x - p.x),
Util.sign(targetPoint.y - p.y))) {
robot.mouseMove(p.x, p.y);
Thread.sleep(50);
}
synchronized (Util.SYNC_LOCK) {
robot.mouseRelease(InputEvent.BUTTON1_MASK);
Util.SYNC_LOCK.wait(Util.FRAME_ACTIVATION_TIMEOUT);
}
if (!dragSourceListener.isDropFinished()) {
throw new RuntimeException("Drop not finished");
}
boolean success2 = dragSourceListener.getDropSuccess();
int retCode = 0;
if (success1) {
retCode |= Util.CODE_FIRST_SUCCESS;
}
if (success2) {
retCode |= Util.CODE_SECOND_SUCCESS;
}
// This returns the diagnostic code from the child VM
System.exit(retCode);
} catch (Throwable e) {
e.printStackTrace();
// This returns the diagnostic code from the child VM
System.exit(Util.CODE_FAILURE);
}
} // run()
} // class child
/****************************************************
Standard Test Machinery
DO NOT modify anything below -- it's a standard
chunk of code whose purpose is to make user
interaction uniform, and thereby make it simpler
to read and understand someone else's test.
****************************************************/
/**
This is part of the standard test machinery.
It creates a dialog (with the instructions), and is the interface
for sending text messages to the user.
To print the instructions, send an array of strings to Sysout.createDialog
WithInstructions method. Put one line of instructions per array entry.
To display a message for the tester to see, simply call Sysout.println
with the string to be displayed.
This mimics System.out.println but works within the test harness as well
as standalone.
*/
class Sysout
{
private static TestDialog dialog;
public static void createDialogWithInstructions( String[] instructions )
{
dialog = new TestDialog( new Frame(), "Instructions" );
dialog.printInstructions( instructions );
dialog.show();
println( "Any messages for the tester will display here." );
}
public static void createDialog( )
{
dialog = new TestDialog( new Frame(), "Instructions" );
String[] defInstr = { "Instructions will appear here. ", "" } ;
dialog.printInstructions( defInstr );
dialog.show();
println( "Any messages for the tester will display here." );
}
public static void printInstructions( String[] instructions )
{
dialog.printInstructions( instructions );
}
public static void println( String messageIn )
{
dialog.displayMessage( messageIn );
}
}// Sysout class
/**
This is part of the standard test machinery. It provides a place for the
test instructions to be displayed, and a place for interactive messages
to the user to be displayed.
To have the test instructions displayed, see Sysout.
To have a message to the user be displayed, see Sysout.
Do not call anything in this dialog directly.
*/
class TestDialog extends Dialog
{
TextArea instructionsText;
TextArea messageText;
int maxStringLength = 80;
//DO NOT call this directly, go through Sysout
public TestDialog( Frame frame, String name )
{
super( frame, name );
int scrollBoth = TextArea.SCROLLBARS_BOTH;
instructionsText = new TextArea( "", 15, maxStringLength, scrollBoth );
add( "North", instructionsText );
messageText = new TextArea( "", 5, maxStringLength, scrollBoth );
add("South", messageText);
pack();
show();
}// TestDialog()
//DO NOT call this directly, go through Sysout
public void printInstructions( String[] instructions )
{
//Clear out any current instructions
instructionsText.setText( "" );
//Go down array of instruction strings
String printStr, remainingStr;
for( int i=0; i < instructions.length; i++ )
{
//chop up each into pieces maxSringLength long
remainingStr = instructions[ i ];
while( remainingStr.length() > 0 )
{
//if longer than max then chop off first max chars to print
if( remainingStr.length() >= maxStringLength )
{
//Try to chop on a word boundary
int posOfSpace = remainingStr.
lastIndexOf( ' ', maxStringLength - 1 );
if( posOfSpace <= 0 ) posOfSpace = maxStringLength - 1;
printStr = remainingStr.substring( 0, posOfSpace + 1 );
remainingStr = remainingStr.substring( posOfSpace + 1 );
}
//else just print
else
{
printStr = remainingStr;
remainingStr = "";
}
instructionsText.append( printStr + "\n" );
}// while
}// for
}//printInstructions()
//DO NOT call this directly, go through Sysout
public void displayMessage( String messageIn )
{
messageText.append( messageIn + "\n" );
}
}// TestDialog class

45
jdk/test/java/awt/dnd/NoFormatsCrashTest/NoFormatsCrashTest.html Normal file
View File

@ -0,0 +1,45 @@
<!--
Copyright (c) 2014, 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.
-->
<html>
<!--
@test
@bug 4870762
@summary tests that a drop target JVM doesn't crash if the source doesn't export
data in native formats.
@author das@sparc.spb.su area=dnd
@run applet NoFormatsCrashTest.html
-->
<head>
<title> </title>
</head>
<body>
<h1>NoFormatsCrashTest<br>Bug ID: 4870762</h1>
<p> This is an AUTOMATIC test, simply wait for completion </p>
<APPLET CODE="NoFormatsCrashTest.class" WIDTH=200 HEIGHT=200></APPLET>
</body>
</html>

488
jdk/test/java/awt/dnd/NoFormatsCrashTest/NoFormatsCrashTest.java Normal file
View File

@ -0,0 +1,488 @@
/*
* Copyright (c) 2014, 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 4870762
@summary tests that a drop target JVM doesn't crash if the source doesn't export
data in native formats.
@author das@sparc.spb.su area=dnd
@compile NoFormatsCrashTest.java
@run applet NoFormatsCrashTest.html
*/
// Note there is no @ in front of test above. This is so that the
// harness will not mistake this file as a test file. It should
// only see the html file as a test file. (the harness runs all
// valid test files, so it would run this test twice if this file
// were valid as well as the html file.)
// Also, note the area= after Your Name in the author tag. Here, you
// should put which functional area the test falls in. See the
// AWT-core home page -> test areas and/or -> AWT team for a list of
// areas.
// Note also the 'NoFormatsCrashTest.html' in the run tag. This should
// be changed to the name of the test.
/**
* NoFormatsCrashTest.java
*
* summary: tests that a drop target JVM doesn't crash if the source doesn't export
* data in native formats.
*/
import java.applet.Applet;
import java.awt.*;
import java.awt.datatransfer.*;
import java.awt.dnd.*;
import java.awt.event.*;
import java.io.*;
//Automated tests should run as applet tests if possible because they
// get their environments cleaned up, including AWT threads, any
// test created threads, and any system resources used by the test
// such as file descriptors. (This is normally not a problem as
// main tests usually run in a separate VM, however on some platforms
// such as the Mac, separate VMs are not possible and non-applet
// tests will cause problems). Also, you don't have to worry about
// synchronisation stuff in Applet tests they way you do in main
// tests...
public class NoFormatsCrashTest extends Applet {
final Frame frame = new Frame();
private volatile Process process;
static final int FRAME_ACTIVATION_TIMEOUT = 2000;
public static void main(String[] args) {
NoFormatsCrashTest test = new NoFormatsCrashTest();
test.run(args);
}
public void run(String[] args) {
try {
if (args.length != 4) {
throw new RuntimeException("Incorrect command line arguments.");
}
int x = Integer.parseInt(args[0]);
int y = Integer.parseInt(args[1]);
int w = Integer.parseInt(args[2]);
int h = Integer.parseInt(args[3]);
Panel panel = new DragSourcePanel();
frame.setTitle("Drag source frame");
frame.setLocation(500, 200);
frame.add(panel);
frame.pack();
frame.setVisible(true);
Thread.sleep(FRAME_ACTIVATION_TIMEOUT);
Point sourcePoint = panel.getLocationOnScreen();
Dimension d = panel.getSize();
sourcePoint.translate(d.width / 2, d.height / 2);
Point targetPoint = new Point(x + w / 2, y + h / 2);
Robot robot = new Robot();
robot.mouseMove(sourcePoint.x, sourcePoint.y);
robot.keyPress(KeyEvent.VK_CONTROL);
robot.mousePress(InputEvent.BUTTON1_MASK);
for (; !sourcePoint.equals(targetPoint);
sourcePoint.translate(sign(targetPoint.x - sourcePoint.x),
sign(targetPoint.y - sourcePoint.y))) {
robot.mouseMove(sourcePoint.x, sourcePoint.y);
Thread.sleep(50);
}
robot.mouseRelease(InputEvent.BUTTON1_MASK);
robot.keyRelease(KeyEvent.VK_CONTROL);
Thread.sleep(FRAME_ACTIVATION_TIMEOUT);
if (process.isAlive()) {
process.destroy();
}
} catch (Throwable e) {
e.printStackTrace();
throw new RuntimeException(e);
}
} // run()
public void init() {
//Create instructions for the user here, as well as set up
// the environment -- set the layout manager, add buttons,
// etc.
String[] instructions =
{
"This is an AUTOMATIC test",
"simply wait until it is done"
};
Sysout.createDialog( );
Sysout.printInstructions( instructions );
frame.setTitle("Drop target frame");
frame.setLocation(200, 200);
} // init()
public void start() {
DropTargetPanel panel = new DropTargetPanel();
frame.add(panel);
frame.pack();
frame.setVisible(true);
try {
Thread.sleep(FRAME_ACTIVATION_TIMEOUT);
Point p = frame.getLocationOnScreen();
Dimension d = frame.getSize();
String javaPath = System.getProperty("java.home", "");
String command = javaPath + File.separator + "bin" +
File.separator + "java -cp " + System.getProperty("test.classes", ".") +
" NoFormatsCrashTest " +
p.x + " " + p.y + " " + d.width + " " + d.height;
process = Runtime.getRuntime().exec(command);
ProcessResults pres = ProcessResults.doWaitFor(process);
System.err.println("Child VM return code: " + pres.exitValue);
if (pres.stderr != null && pres.stderr.length() > 0) {
System.err.println("========= Child VM System.err ========");
System.err.print(pres.stderr);
System.err.println("======================================");
}
if (pres.stdout != null && pres.stdout.length() > 0) {
System.err.println("========= Child VM System.out ========");
System.err.print(pres.stdout);
System.err.println("======================================");
}
} catch (Throwable e) {
e.printStackTrace();
throw new RuntimeException(e);
}
if (panel.isTestFailed()) {
throw new RuntimeException();
}
} // start()
public static int sign(int n) {
return n < 0 ? -1 : n > 0 ? 1 : 0;
}
} // class NoFormatsCrashTest
class TestTransferable implements Transferable {
public static DataFlavor dataFlavor = null;
static final Object data = new Object();
static {
DataFlavor df = null;
try {
df = new DataFlavor(DataFlavor.javaJVMLocalObjectMimeType +
"; class=java.lang.Object");
} catch (ClassNotFoundException e) {
throw new ExceptionInInitializerError(e);
}
dataFlavor = df;
}
public DataFlavor[] getTransferDataFlavors() {
return new DataFlavor[] { dataFlavor };
}
public boolean isDataFlavorSupported(DataFlavor df) {
return dataFlavor.equals(df);
}
public Object getTransferData(DataFlavor df)
throws UnsupportedFlavorException, IOException {
if (!isDataFlavorSupported(df)) {
throw new UnsupportedFlavorException(df);
}
return data;
}
}
class DragSourcePanel extends Panel {
public DragSourcePanel() {
final Transferable t = new TestTransferable();
final DragSourceListener dsl = new DragSourceAdapter() {
public void dragDropEnd(DragSourceDropEvent dtde) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
// This finishes child VM
System.exit(0);
}
};
final DragGestureListener dgl = new DragGestureListener() {
public void dragGestureRecognized(DragGestureEvent dge) {
dge.startDrag(null, t, dsl);
}
};
final DragSource ds = DragSource.getDefaultDragSource();
final DragGestureRecognizer dgr =
ds.createDefaultDragGestureRecognizer(this, DnDConstants.ACTION_COPY,
dgl);
}
public Dimension getPreferredSize() {
return new Dimension(100, 100);
}
}
class DropTargetPanel extends Panel {
private boolean testFailed = false;
public DropTargetPanel() {
final DropTargetListener dtl = new DropTargetAdapter() {
public void dragOver(DropTargetDragEvent dtde) {
try {
dtde.getCurrentDataFlavorsAsList();
} catch (Exception e) {
testFailed = true;
e.printStackTrace();
}
}
public void drop(DropTargetDropEvent dtde) {
dtde.rejectDrop();
}
};
final DropTarget dt = new DropTarget(this, dtl);
}
public boolean isTestFailed() {
return testFailed;
}
public Dimension getPreferredSize() {
return new Dimension(100, 100);
}
}
class ProcessResults {
public int exitValue;
public String stdout;
public String stderr;
public ProcessResults() {
exitValue = -1;
stdout = "";
stderr = "";
}
/**
* Method to perform a "wait" for a process and return its exit value.
* This is a workaround for <code>Process.waitFor()</code> never returning.
*/
public static ProcessResults doWaitFor(Process p) {
ProcessResults pres = new ProcessResults();
InputStream in = null;
InputStream err = null;
try {
in = p.getInputStream();
err = p.getErrorStream();
boolean finished = false;
while (!finished) {
try {
while (in.available() > 0) {
pres.stdout += (char)in.read();
}
while (err.available() > 0) {
pres.stderr += (char)err.read();
}
// Ask the process for its exitValue. If the process
// is not finished, an IllegalThreadStateException
// is thrown. If it is finished, we fall through and
// the variable finished is set to true.
pres.exitValue = p.exitValue();
finished = true;
}
catch (IllegalThreadStateException e) {
// Process is not finished yet;
// Sleep a little to save on CPU cycles
Thread.currentThread().sleep(500);
}
}
if (in != null) in.close();
if (err != null) err.close();
}
catch (Throwable e) {
System.err.println("doWaitFor(): unexpected exception");
e.printStackTrace();
throw new RuntimeException(e);
}
return pres;
}
}
/****************************************************
Standard Test Machinery
DO NOT modify anything below -- it's a standard
chunk of code whose purpose is to make user
interaction uniform, and thereby make it simpler
to read and understand someone else's test.
****************************************************/
/**
This is part of the standard test machinery.
It creates a dialog (with the instructions), and is the interface
for sending text messages to the user.
To print the instructions, send an array of strings to Sysout.createDialog
WithInstructions method. Put one line of instructions per array entry.
To display a message for the tester to see, simply call Sysout.println
with the string to be displayed.
This mimics System.out.println but works within the test harness as well
as standalone.
*/
class Sysout
{
private static TestDialog dialog;
public static void createDialogWithInstructions( String[] instructions )
{
dialog = new TestDialog( new Frame(), "Instructions" );
dialog.printInstructions( instructions );
dialog.show();
println( "Any messages for the tester will display here." );
}
public static void createDialog( )
{
dialog = new TestDialog( new Frame(), "Instructions" );
String[] defInstr = { "Instructions will appear here. ", "" } ;
dialog.printInstructions( defInstr );
dialog.show();
println( "Any messages for the tester will display here." );
}
public static void printInstructions( String[] instructions )
{
dialog.printInstructions( instructions );
}
public static void println( String messageIn )
{
dialog.displayMessage( messageIn );
}
}// Sysout class
/**
This is part of the standard test machinery. It provides a place for the
test instructions to be displayed, and a place for interactive messages
to the user to be displayed.
To have the test instructions displayed, see Sysout.
To have a message to the user be displayed, see Sysout.
Do not call anything in this dialog directly.
*/
class TestDialog extends Dialog
{
TextArea instructionsText;
TextArea messageText;
int maxStringLength = 80;
//DO NOT call this directly, go through Sysout
public TestDialog( Frame frame, String name )
{
super( frame, name );
int scrollBoth = TextArea.SCROLLBARS_BOTH;
instructionsText = new TextArea( "", 15, maxStringLength, scrollBoth );
add( "North", instructionsText );
messageText = new TextArea( "", 5, maxStringLength, scrollBoth );
add("South", messageText);
pack();
show();
}// TestDialog()
//DO NOT call this directly, go through Sysout
public void printInstructions( String[] instructions )
{
//Clear out any current instructions
instructionsText.setText( "" );
//Go down array of instruction strings
String printStr, remainingStr;
for( int i=0; i < instructions.length; i++ )
{
//chop up each into pieces maxSringLength long
remainingStr = instructions[ i ];
while( remainingStr.length() > 0 )
{
//if longer than max then chop off first max chars to print
if( remainingStr.length() >= maxStringLength )
{
//Try to chop on a word boundary
int posOfSpace = remainingStr.
lastIndexOf( ' ', maxStringLength - 1 );
if( posOfSpace <= 0 ) posOfSpace = maxStringLength - 1;
printStr = remainingStr.substring( 0, posOfSpace + 1 );
remainingStr = remainingStr.substring( posOfSpace + 1 );
}
//else just print
else
{
printStr = remainingStr;
remainingStr = "";
}
instructionsText.append( printStr + "\n" );
}// while
}// for
}//printInstructions()
//DO NOT call this directly, go through Sysout
public void displayMessage( String messageIn )
{
messageText.append( messageIn + "\n" );
}
}// TestDialog class

62
jdk/test/java/awt/regtesthelpers/process/ProcessCommunicator.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2007, 2014, 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
@ -25,21 +25,22 @@ package test.java.awt.regtesthelpers.process;
import java.io.*;
/** This class is created to solve interprocess communication problems.
/**
* This class is created to solve interprocess communication problems.
* When you need to write a regression test which should verify inter jvm
* behavior such as DnD data transfer, Clipboard data transfer, focus
* transfer etc., you could use the next scenario:
*
* 1. Write an implementation for the parent JVM, using applet test.
* 2. Write an implimentation for the child JVM or native application, using
* 2. Write an implementation for the child JVM or native application, using
* main() function.
* 3. Execute child process using ProcessCommunicator.executeChildProcess()
* method.
* 4. You can decide whetherthe test is passed on the basis of
* 4. You can decide whether the test is passed on the basis of
* ProcessResults class data.
*
* Note: The class is not thread safe. You should access its methods only from the same
* thread.
* Note: The class is not thread safe. You should access its methods only from
* the same thread.
*/
public class ProcessCommunicator {
@ -48,31 +49,34 @@ public class ProcessCommunicator {
private static final String javaPath = javaHome + File.separator + "bin" +
File.separator + "java ";
private static String command = "";
private static volatile Process process;
private ProcessCommunicator() {}
/** The same as {#link #executeChildProcess(Class,String)} except
* the {@code classPathArgument} parameter. The class path
* parameter is for the debug purposes
/**
* The same as {#link #executeChildProcess(Class,String)} except
* the {@code classPathArgument} parameter. The class path
* parameter is for the debug purposes
*
* @param classToExecute is passed to the child JVM
* @param classPathArguments class path for the child JVM
* @param args arguments that will be passed to the executed class
* @return results of the executed {@code Process}
* @param classToExecute is passed to the child JVM
* @param classPathArguments class path for the child JVM
* @param args arguments that will be passed to the executed class
* @return results of the executed {@code Process}
*/
public static ProcessResults executeChildProcess(final Class classToExecute,
final String classPathArguments, final String [] args)
{
try {
String command = buildCommand(classToExecute, classPathArguments, args);
Process process = Runtime.getRuntime().exec(command);
process = Runtime.getRuntime().exec(command);
return doWaitFor(process);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
/** Executes child {code Process}
/**
* Executes child {code Process}
*
* @param classToExecute class to be executed as a child java process
* @param args args to be passed in to the child process
@ -86,11 +90,11 @@ public class ProcessCommunicator {
/**
* Waits for a process and return its results.
* This is a workaround for <code>Process.waitFor()</code> never returning.
* This is a workaround for {@code Process.waitFor()} never returning.
*
* @return results of the executed {@code Process}
*/
private static ProcessResults doWaitFor(final Process p) {
public static ProcessResults doWaitFor(final Process p) {
ProcessResults pres = new ProcessResults();
final InputStream in;
@ -133,13 +137,14 @@ public class ProcessCommunicator {
return pres;
}
/** Builds command on the basis of the passed class name,
* class path and arguments.
/**
* Builds command on the basis of the passed class name,
* class path and arguments.
*
* @param classToExecute with class will be executed in the new JVM
* @param classPathArguments java class path (only for test purposes)
* @param args arguments for the new application. This could be used
* to pass some information from the parnent to child JVM.
* to pass some information from the parent to child JVM.
* @return command to execute the {@code Process}
*/
private static String buildCommand(final Class classToExecute,
@ -162,11 +167,24 @@ public class ProcessCommunicator {
return command;
}
/** Could be used for the debug purposes.
/**
* Could be used for the debug purposes.
*
* @return command that was build to execute the child process
* @return command that was build to execute the child process
*/
public static String getExecutionCommand () {
return command;
}
/**
* Terminates the process created by {@code executeChildProcess} methods.
*/
public static void destroyProcess() {
if (process != null) {
if (process.isAlive()) {
process.destroy();
}
process = null;
}
}
}