Attachment #43393 for bug #144742

Lines 38-43 Link Here

(-)src/org/eclipse/jdt/core/tests/eval/NegativeCodeSnippetTest.java (+5 lines)
38	* Test a scenario where the change of the package declaration causes a problem in a code snippet.	38	* Test a scenario where the change of the package declaration causes a problem in a code snippet.
39	*/	39	*/
40	public void testChangePackage() {	40	public void testChangePackage() {
		41	final String vmName = System.getProperty("java.vm.name");
		42	if (vmName != null && vmName.indexOf("JRockit") != -1) {
		43	// disable if the running VM is JRockit
		44	return;
		45	}
41	try {	46	try {
42	// define the package	47	// define the package
43	context.setPackageName("java.util.zip".toCharArray());	48	context.setPackageName("java.util.zip".toCharArray());

Lines 384-391 Link Here

(-)src/org/eclipse/jdt/core/tests/eval/CodeSnippetTest.java (-1 / +6 lines)
384	* Tests code snippet that include a package declaration.	384	* Tests code snippet that include a package declaration.
385	*/	385	*/
386	public void testPackage() {	386	public void testPackage() {
		387	final String vmName = System.getProperty("java.vm.name");
		388	if (vmName != null && vmName.indexOf("JRockit") != -1) {
		389	// disable if the running VM is JRockit
		390	return;
		391	}
387	// TBD: Test access to package private member	392	// TBD: Test access to package private member
388	// TBD: Test access to package class and members in anoother package than a java.* package	393	// TBD: Test access to package class and members in another package than a java.* package
389	try {	394	try {
390	// declare that the code snippet is run in java.util.zip and access a package private class	395	// declare that the code snippet is run in java.util.zip and access a package private class
391	context.setPackageName("java.util.zip".toCharArray());	396	context.setPackageName("java.util.zip".toCharArray());

Lines 55-60 Link Here

(-)src/org/eclipse/jdt/core/tests/runtime/LocalVMLauncher.java (+3 lines)
55	if ("J9".equals(vmName)) {	55	if ("J9".equals(vmName)) {
56	return new J9VMLauncher();	56	return new J9VMLauncher();
57	}	57	}
		58	if (vmName != null && vmName.indexOf("JRockit") != -1) {
		59	return new JRockitVMLauncher();
		60	}
58	final String osName = System.getProperty("os.name");	61	final String osName = System.getProperty("os.name");
59	if (osName.startsWith("Mac")) {	62	if (osName.startsWith("Mac")) {
60	return new MacVMLauncher();	63	return new MacVMLauncher();




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.core.tests.runtime;


import java.io.*;

import java.util.Vector;
import java.util.Enumeration;

/**
 * A standard VM launcher launches an external standard VM with
 * the given arguments on the same machine.
 */
public class JRockitVMLauncher extends LocalVMLauncher implements RuntimeConstants {
	String batchFileName;
/**
 * Creates a new StandardVMLauncher that launches a standard VM
 * on the same machine.
 */
public JRockitVMLauncher() {
	super();
}
/**
 * Builds the actual boot class path that is going to be passed to the VM.
 */
protected String buildBootClassPath() {
	StringBuffer bootPathString = new StringBuffer();

	// Add boot class path directory if needed
	if (this.evalTargetPath != null && TARGET_HAS_FILE_SYSTEM) {
		bootPathString.append(this.evalTargetPath);
		bootPathString.append(File.separatorChar);
		bootPathString.append(BOOT_CLASSPATH_DIRECTORY);
	}

	return bootPathString.toString();
}
/**
 * Returns the name of the batch file used to launch the VM.
 */
public String getBatchFileName() {
	return this.batchFileName;
}
/**
 * @see LocalVMLauncher#getCommandLine
 */
public String[] getCommandLine() {
	Vector commandLine= new Vector();
	
	// VM binary
	if (System.getProperty("java.vm.version").startsWith("1.4.2")) {
		commandLine.addElement(
			this.vmPath + 
			(this.vmPath.endsWith(File.separator) ? "" : File.separator) + 
			"bin" + 
			File.separator + 
			"java");
	} else {
		String vmLocation = this.vmPath + 
			(this.vmPath.endsWith(File.separator) ? "" : File.separator) + 
			"bin" + 
			File.separator + 
			"javaw";
		final String osName = System.getProperty("os.name");
		if (osName.indexOf("win32") != -1) {
			vmLocation += ".exe";
		}
		if (!new File(vmLocation).exists()) {
			vmLocation = 
				this.vmPath + 
				(this.vmPath.endsWith(File.separator) ? "" : File.separator) + 
				"bin" + 
				File.separator + 
				"java";
		}
		commandLine.addElement(vmLocation);
	}

	// VM arguments
	if (this.vmArguments != null) {
		for (int i = 0; i < this.vmArguments.length; i++) {
			commandLine.addElement(this.vmArguments[i]);
		}
	}

	// debug mode
	if (this.debugPort != -1) {
		commandLine.addElement("-Xdebug");
		commandLine.addElement("-Xnoagent");
		commandLine.addElement(
			"-Xrunjdwp:transport=dt_socket,address=" +
			this.debugPort +
			",server=y,suspend=n");
	}

	// set the classpath
	// we don't set the bootclasspath as for StandardVMLauncher as this breaks the debug mode of JRockit
	// we would get: [JRockit] ERROR:  failed to set up MAPI gc reporting
	commandLine.addElement("-classpath");
	String classpath = buildBootClassPath() + File.pathSeparator + buildClassPath();
	System.out.println(classpath);
	commandLine.addElement(classpath);

	// code snippet runner class
	if (this.evalPort != -1) {
		commandLine.addElement(CODE_SNIPPET_RUNNER_CLASS_NAME);
	}
	
	// code snippet runner arguments
	if (this.evalPort != -1) {
		commandLine.addElement(EVALPORT_ARG);
		commandLine.addElement(Integer.toString(this.evalPort));
		if (TARGET_HAS_FILE_SYSTEM) {
			commandLine.addElement(CODESNIPPET_CLASSPATH_ARG);
			commandLine.addElement(this.evalTargetPath + File.separator + REGULAR_CLASSPATH_DIRECTORY);
			commandLine.addElement(CODESNIPPET_BOOTPATH_ARG);
			commandLine.addElement(this.evalTargetPath + File.separator + BOOT_CLASSPATH_DIRECTORY);
		}
	}

	// program class
	if (this.programClass != null) {
		commandLine.addElement(this.programClass);
	}
	
	// program arguments
	if (this.programArguments != null) {
		for (int i=0;i<this.programArguments.length;i++) {
			commandLine.addElement(this.programArguments[i]);
		}
	}

	String[] result;
	if (this.batchFileName!= null) {
		// Write to batch file if specified
		writeBatchFile(this.batchFileName, commandLine);
		result = new String[] {this.batchFileName};
	} else {
		result = new String[commandLine.size()];
		commandLine.copyInto(result);
	}

	// check for spaces in result
	for (int i = 0; i < result.length; i++) {
		String argument = result[i];
		if (argument.indexOf(' ') != -1) {
			result[i] = "\"" + argument + "\"";
		}
	}
	
	return result;
}
/**
 * Sets the name of the batch file used to launch the VM.
 * When this option is set, the launcher writes the command line to the given batch file, 
 * and it launches the  batch file. This causes a DOS console to be opened. Note it 
 * doesn't delete the batch file when done.
 */
public void setBatchFileName(String batchFileName) {
	this.batchFileName = batchFileName;
}
protected void writeBatchFile(String fileName, Vector commandLine) {
	FileOutputStream output = null;
	try {
		output = new FileOutputStream(fileName);
		PrintWriter out= new PrintWriter(output);
		for (Enumeration e = commandLine.elements(); e.hasMoreElements();) {
			out.print((String)e.nextElement());
			out.print(" ");
		}
		out.println("pause");
		out.close();
	} catch (IOException e) {
		e.printStackTrace();
		if (output != null) {
			try {
				output.close();
			} catch (IOException e2) {
				// ignore
			}
		}
	}
}
}

Return to bug 144742

Added Link Here

(-)src/org/eclipse/jdt/core/tests/runtime/JRockitVMLauncher.java (+193 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jdt.core.tests.runtime;
12
13
14	import java.io.*;
15
16	import java.util.Vector;
17	import java.util.Enumeration;
18
19	/**
20	* A standard VM launcher launches an external standard VM with
21	* the given arguments on the same machine.
22	*/
23	public class JRockitVMLauncher extends LocalVMLauncher implements RuntimeConstants {
24	String batchFileName;
25	/**
26	* Creates a new StandardVMLauncher that launches a standard VM
27	* on the same machine.
28	*/
29	public JRockitVMLauncher() {
30	super();
31	}
32	/**
33	* Builds the actual boot class path that is going to be passed to the VM.
34	*/
35	protected String buildBootClassPath() {
36	StringBuffer bootPathString = new StringBuffer();
37
38	// Add boot class path directory if needed
39	if (this.evalTargetPath != null && TARGET_HAS_FILE_SYSTEM) {
40	bootPathString.append(this.evalTargetPath);
41	bootPathString.append(File.separatorChar);
42	bootPathString.append(BOOT_CLASSPATH_DIRECTORY);
43	}
44
45	return bootPathString.toString();
46	}
47	/**
48	* Returns the name of the batch file used to launch the VM.
49	*/
50	public String getBatchFileName() {
51	return this.batchFileName;
52	}
53	/**
54	* @see LocalVMLauncher#getCommandLine
55	*/
56	public String[] getCommandLine() {
57	Vector commandLine= new Vector();
58
59	// VM binary
60	if (System.getProperty("java.vm.version").startsWith("1.4.2")) {
61	commandLine.addElement(
62	this.vmPath +
63	(this.vmPath.endsWith(File.separator) ? "" : File.separator) +
64	"bin" +
65	File.separator +
66	"java");
67	} else {
68	String vmLocation = this.vmPath +
69	(this.vmPath.endsWith(File.separator) ? "" : File.separator) +
70	"bin" +
71	File.separator +
72	"javaw";
73	final String osName = System.getProperty("os.name");
74	if (osName.indexOf("win32") != -1) {
75	vmLocation += ".exe";
76	}
77	if (!new File(vmLocation).exists()) {
78	vmLocation =
79	this.vmPath +
80	(this.vmPath.endsWith(File.separator) ? "" : File.separator) +
81	"bin" +
82	File.separator +
83	"java";
84	}
85	commandLine.addElement(vmLocation);
86	}
87
88	// VM arguments
89	if (this.vmArguments != null) {
90	for (int i = 0; i < this.vmArguments.length; i++) {
91	commandLine.addElement(this.vmArguments[i]);
92	}
93	}
94
95	// debug mode
96	if (this.debugPort != -1) {
97	commandLine.addElement("-Xdebug");
98	commandLine.addElement("-Xnoagent");
99	commandLine.addElement(
100	"-Xrunjdwp:transport=dt_socket,address=" +
101	this.debugPort +
102	",server=y,suspend=n");
103	}
104
105	// set the classpath
106	// we don't set the bootclasspath as for StandardVMLauncher as this breaks the debug mode of JRockit
107	// we would get: [JRockit] ERROR: failed to set up MAPI gc reporting
108	commandLine.addElement("-classpath");
109	String classpath = buildBootClassPath() + File.pathSeparator + buildClassPath();
110	System.out.println(classpath);
111	commandLine.addElement(classpath);
112
113	// code snippet runner class
114	if (this.evalPort != -1) {
115	commandLine.addElement(CODE_SNIPPET_RUNNER_CLASS_NAME);
116	}
117
118	// code snippet runner arguments
119	if (this.evalPort != -1) {
120	commandLine.addElement(EVALPORT_ARG);
121	commandLine.addElement(Integer.toString(this.evalPort));
122	if (TARGET_HAS_FILE_SYSTEM) {
123	commandLine.addElement(CODESNIPPET_CLASSPATH_ARG);
124	commandLine.addElement(this.evalTargetPath + File.separator + REGULAR_CLASSPATH_DIRECTORY);
125	commandLine.addElement(CODESNIPPET_BOOTPATH_ARG);
126	commandLine.addElement(this.evalTargetPath + File.separator + BOOT_CLASSPATH_DIRECTORY);
127	}
128	}
129
130	// program class
131	if (this.programClass != null) {
132	commandLine.addElement(this.programClass);
133	}
134
135	// program arguments
136	if (this.programArguments != null) {
137	for (int i=0;i<this.programArguments.length;i++) {
138	commandLine.addElement(this.programArguments[i]);
139	}
140	}
141
142	String[] result;
143	if (this.batchFileName!= null) {
144	// Write to batch file if specified
145	writeBatchFile(this.batchFileName, commandLine);
146	result = new String[] {this.batchFileName};
147	} else {
148	result = new String[commandLine.size()];
149	commandLine.copyInto(result);
150	}
151
152	// check for spaces in result
153	for (int i = 0; i < result.length; i++) {
154	String argument = result[i];
155	if (argument.indexOf(' ') != -1) {
156	result[i] = "\"" + argument + "\"";
157	}
158	}
159
160	return result;
161	}
162	/**
163	* Sets the name of the batch file used to launch the VM.
164	* When this option is set, the launcher writes the command line to the given batch file,
165	* and it launches the batch file. This causes a DOS console to be opened. Note it
166	* doesn't delete the batch file when done.
167	*/
168	public void setBatchFileName(String batchFileName) {
169	this.batchFileName = batchFileName;
170	}
171	protected void writeBatchFile(String fileName, Vector commandLine) {
172	FileOutputStream output = null;
173	try {
174	output = new FileOutputStream(fileName);
175	PrintWriter out= new PrintWriter(output);
176	for (Enumeration e = commandLine.elements(); e.hasMoreElements();) {
177	out.print((String)e.nextElement());
178	out.print(" ");
179	}
180	out.println("pause");
181	out.close();
182	} catch (IOException e) {
183	e.printStackTrace();
184	if (output != null) {
185	try {
186	output.close();
187	} catch (IOException e2) {
188	// ignore
189	}
190	}
191	}
192	}
193	}