X-Git-Url: http://secure.phpeclipse.com

diff --git a/net.sourceforge.phpeclipse.test/src/net/sourceforge/phpdt/core/tests/util/Util.java b/net.sourceforge.phpeclipse.test/src/net/sourceforge/phpdt/core/tests/util/Util.java
new file mode 100644
index 0000000..5316029
--- /dev/null
+++ b/net.sourceforge.phpeclipse.test/src/net/sourceforge/phpdt/core/tests/util/Util.java
@@ -0,0 +1,504 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2004 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package net.sourceforge.phpdt.core.tests.util;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.net.ServerSocket;
+
+import net.sourceforge.phpdt.internal.compiler.batch.CompilationUnit;
+
+public class Util {
+	public static String OUTPUT_DIRECTORY = "comptest";
+
+	public static CompilationUnit[] compilationUnits(String[] testFiles) {
+		int length = testFiles.length / 2;
+		CompilationUnit[] result = new CompilationUnit[length];
+		int index = 0;
+		for (int i = 0; i < length; i++) {
+			result[i] = new CompilationUnit(testFiles[index + 1].toCharArray(),
+					testFiles[index], null);
+			index += 2;
+		}
+		return result;
+	}
+
+	public static String[] concatWithClassLibs(String classpath, boolean inFront) {
+		String[] classLibs = getJavaClassLibs();
+		final int length = classLibs.length;
+		String[] defaultClassPaths = new String[length + 1];
+		if (inFront) {
+			System.arraycopy(classLibs, 0, defaultClassPaths, 1, length);
+			defaultClassPaths[0] = classpath;
+		} else {
+			System.arraycopy(classLibs, 0, defaultClassPaths, 0, length);
+			defaultClassPaths[length] = classpath;
+		}
+		return defaultClassPaths;
+	}
+
+	public static String convertToIndependantLineDelimiter(String source) {
+		StringBuffer buffer = new StringBuffer();
+		for (int i = 0, length = source.length(); i < length; i++) {
+			char car = source.charAt(i);
+			if (car == '\r') {
+				buffer.append('\n');
+				if (i < length - 1 && source.charAt(i + 1) == '\n') {
+					i++; // skip \n after \r
+				}
+			} else {
+				buffer.append(car);
+			}
+		}
+		return buffer.toString();
+	}
+
+	/**
+	 * Copy the given source (a file or a directory that must exists) to the
+	 * given destination (a directory that must exists).
+	 */
+	public static void copy(String sourcePath, String destPath) {
+		sourcePath = toNativePath(sourcePath);
+		destPath = toNativePath(destPath);
+		File source = new File(sourcePath);
+		if (!source.exists())
+			return;
+		File dest = new File(destPath);
+		if (!dest.exists())
+			return;
+		if (source.isDirectory()) {
+			String[] files = source.list();
+			if (files != null) {
+				for (int i = 0; i < files.length; i++) {
+					String file = files[i];
+					File sourceFile = new File(source, file);
+					if (sourceFile.isDirectory()) {
+						File destSubDir = new File(dest, file);
+						destSubDir.mkdir();
+						copy(sourceFile.getPath(), destSubDir.getPath());
+					} else {
+						copy(sourceFile.getPath(), dest.getPath());
+					}
+				}
+			}
+		} else {
+			FileInputStream in = null;
+			FileOutputStream out = null;
+			try {
+				in = new FileInputStream(source);
+				File destFile = new File(dest, source.getName());
+				if (destFile.exists() && !destFile.delete()) {
+					throw new IOException(destFile + " is in use");
+				}
+				out = new FileOutputStream(destFile);
+				int bufferLength = 1024;
+				byte[] buffer = new byte[bufferLength];
+				int read = 0;
+				while (read != -1) {
+					read = in.read(buffer, 0, bufferLength);
+					if (read != -1) {
+						out.write(buffer, 0, read);
+					}
+				}
+			} catch (IOException e) {
+				throw new Error(e.toString());
+			} finally {
+				if (in != null) {
+					try {
+						in.close();
+					} catch (IOException e) {
+					}
+				}
+				if (out != null) {
+					try {
+						out.close();
+					} catch (IOException e) {
+					}
+				}
+			}
+		}
+	}
+
+	// public static void createJar(String[] pathsAndContents, Map options,
+	// String
+	// jarPath) throws IOException {
+	// String classesPath = getOutputDirectory() + File.separator + "classes";
+	// File classesDir = new File(classesPath);
+	// flushDirectoryContent(classesDir);
+	// compile(pathsAndContents, options, classesPath);
+	// zip(classesDir, jarPath);
+	// }
+	/**
+	 * Generate a display string from the given String.
+	 * 
+	 * @param indent
+	 *            number of tabs are added at the begining of each line.
+	 * 
+	 * Example of use:
+	 * [org.eclipse.jdt.core.tests.util.Util.displayString("abc\ndef\tghi")]
+	 */
+	public static String displayString(String inputString) {
+		return displayString(inputString, 0);
+	}
+
+	/**
+	 * Generate a display string from the given String. It converts:
+	 * <ul>
+	 * <li>\t to \t</li>
+	 * <li>\r to \\r</li>
+	 * <li>\n to \n</li>
+	 * <li>\b to \\b</li>
+	 * <li>\f to \\f</li>
+	 * <li>\" to \\\"</li>
+	 * <li>\' to \\'</li>
+	 * <li>\\ to \\\\</li>
+	 * <li>All other characters are unchanged.</li>
+	 * </ul>
+	 * This method doesn't convert \r\n to \n.
+	 * <p>
+	 * Example of use: <o>
+	 * <li>
+	 * 
+	 * <pre>
+	 *   input string = &quot;abc\ndef\tghi&quot;,
+	 *   indent = 3
+	 *   result = &quot;\&quot;\t\t\tabc\\n&quot; +
+	 *   			&quot;\t\t\tdef\tghi\&quot;&quot;
+	 * </pre>
+	 * 
+	 * </li>
+	 * <li>
+	 * 
+	 * <pre>
+	 *   input string = &quot;abc\ndef\tghi\n&quot;,
+	 *   indent = 3
+	 *   result = &quot;\&quot;\t\t\tabc\\n&quot; +
+	 *   			&quot;\t\t\tdef\tghi\\n\&quot;&quot;
+	 * </pre>
+	 * 
+	 * </li>
+	 * <li>
+	 * 
+	 * <pre>
+	 *   input string = &quot;abc\r\ndef\tghi\r\n&quot;,
+	 *   indent = 3
+	 *   result = &quot;\&quot;\t\t\tabc\\r\\n&quot; +
+	 *   			&quot;\t\t\tdef\tghi\\r\\n\&quot;&quot;
+	 * </pre>
+	 * 
+	 * </li>
+	 * </ol>
+	 * </p>
+	 * 
+	 * @param inputString
+	 *            the given input string
+	 * @param indent
+	 *            number of tabs are added at the begining of each line.
+	 * 
+	 * @return the displayed string
+	 */
+	public static String displayString(String inputString, int indent) {
+		int length = inputString.length();
+		StringBuffer buffer = new StringBuffer(length);
+		java.util.StringTokenizer tokenizer = new java.util.StringTokenizer(
+				inputString, "\n\r", true);
+		for (int i = 0; i < indent; i++)
+			buffer.append("\t");
+		buffer.append("\"");
+		while (tokenizer.hasMoreTokens()) {
+
+			String token = tokenizer.nextToken();
+			if (token.equals("\r")) {
+				buffer.append("\\r");
+				if (tokenizer.hasMoreTokens()) {
+					token = tokenizer.nextToken();
+					if (token.equals("\n")) {
+						buffer.append("\\n");
+						if (tokenizer.hasMoreTokens()) {
+							buffer.append("\" + \n");
+							for (int i = 0; i < indent; i++)
+								buffer.append("\t");
+							buffer.append("\"");
+						}
+						continue;
+					} else {
+						buffer.append("\" + \n");
+						for (int i = 0; i < indent; i++)
+							buffer.append("\t");
+						buffer.append("\"");
+					}
+				} else {
+					continue;
+				}
+			} else if (token.equals("\n")) {
+				buffer.append("\\n");
+				if (tokenizer.hasMoreTokens()) {
+					buffer.append("\" + \n");
+					for (int i = 0; i < indent; i++)
+						buffer.append("\t");
+					buffer.append("\"");
+				}
+				continue;
+			}
+
+			StringBuffer tokenBuffer = new StringBuffer();
+			for (int i = 0; i < token.length(); i++) {
+				char c = token.charAt(i);
+				switch (c) {
+				case '\r':
+					tokenBuffer.append("\\r");
+					break;
+				case '\n':
+					tokenBuffer.append("\\n");
+					break;
+				case '\b':
+					tokenBuffer.append("\\b");
+					break;
+				case '\t':
+					tokenBuffer.append("\t");
+					break;
+				case '\f':
+					tokenBuffer.append("\\f");
+					break;
+				case '\"':
+					tokenBuffer.append("\\\"");
+					break;
+				case '\'':
+					tokenBuffer.append("\\'");
+					break;
+				case '\\':
+					tokenBuffer.append("\\\\");
+					break;
+				default:
+					tokenBuffer.append(c);
+				}
+			}
+			buffer.append(tokenBuffer.toString());
+		}
+		buffer.append("\"");
+		return buffer.toString();
+	}
+
+	/**
+	 * Reads the content of the given source file and converts it to a display
+	 * string.
+	 * 
+	 * Example of use:
+	 * [org.eclipse.jdt.core.tests.util.Util.fileContentToDisplayString("c:/temp/X.java",
+	 * 0)]
+	 */
+	public static String fileContentToDisplayString(String sourceFilePath,
+			int indent, boolean independantLineDelimiter) {
+		File sourceFile = new File(sourceFilePath);
+		if (!sourceFile.exists()) {
+			System.out.println("File " + sourceFilePath + " does not exists.");
+			return null;
+		}
+		if (!sourceFile.isFile()) {
+			System.out.println(sourceFilePath + " is not a file.");
+			return null;
+		}
+		StringBuffer sourceContentBuffer = new StringBuffer();
+		FileInputStream input = null;
+		try {
+			input = new FileInputStream(sourceFile);
+		} catch (FileNotFoundException e) {
+			return null;
+		}
+		try {
+			int read;
+			do {
+				read = input.read();
+				if (read != -1) {
+					sourceContentBuffer.append((char) read);
+				}
+			} while (read != -1);
+			input.close();
+		} catch (IOException e) {
+			e.printStackTrace();
+			return null;
+		} finally {
+			try {
+				input.close();
+			} catch (IOException e2) {
+			}
+		}
+		String sourceString = sourceContentBuffer.toString();
+		if (independantLineDelimiter) {
+			sourceString = convertToIndependantLineDelimiter(sourceString);
+		}
+		return displayString(sourceString, indent);
+	}
+
+	/**
+	 * Reads the content of the given source file, converts it to a display
+	 * string. If the destination file path is not null, writes the result to
+	 * this file. Otherwise writes it to the console.
+	 * 
+	 * Example of use:
+	 * [org.eclipse.jdt.core.tests.util.Util.fileContentToDisplayString("c:/temp/X.java",
+	 * 0, null)]
+	 */
+	public static void fileContentToDisplayString(String sourceFilePath,
+			int indent, String destinationFilePath,
+			boolean independantLineDelimiter) {
+		String displayString = fileContentToDisplayString(sourceFilePath,
+				indent, independantLineDelimiter);
+		if (destinationFilePath == null) {
+			System.out.println(displayString);
+			return;
+		}
+		writeToFile(displayString, destinationFilePath);
+	}
+
+	/**
+	 * Flush content of a given directory (leaving it empty), no-op if not a
+	 * directory.
+	 */
+	public static void flushDirectoryContent(File dir) {
+		if (dir.isDirectory()) {
+			String[] files = dir.list();
+			if (files == null)
+				return;
+			for (int i = 0, max = files.length; i < max; i++) {
+				File current = new File(dir, files[i]);
+				if (current.isDirectory()) {
+					flushDirectoryContent(current);
+				}
+				current.delete();
+			}
+		}
+	}
+
+	/**
+	 * Search the user hard-drive for a Java class library. Returns null if none
+	 * could be found.
+	 * 
+	 * Example of use: [org.eclipse.jdt.core.tests.util.Util.getJavaClassLib()]
+	 */
+	public static String[] getJavaClassLibs() {
+		String jreDir = getJREDirectory();
+		if (jreDir == null) {
+			return new String[] {};
+		} else {
+			final String vmName = System.getProperty("java.vm.name");
+			if ("J9".equals(vmName)) {
+				return new String[] { toNativePath(jreDir
+						+ "/lib/jclMax/classes.zip") };
+			} else {
+				File file = new File(jreDir + "/lib/rt.jar");
+				if (file.exists()) {
+					return new String[] { toNativePath(jreDir + "/lib/rt.jar") };
+				} else {
+					return new String[] {
+							toNativePath(jreDir + "/lib/core.jar"),
+							toNativePath(jreDir + "/lib/security.jar"),
+							toNativePath(jreDir + "/lib/graphics.jar") };
+				}
+			}
+		}
+	}
+
+	public static String getJavaClassLibsAsString() {
+		String[] classLibs = getJavaClassLibs();
+		StringBuffer buffer = new StringBuffer();
+		for (int i = 0, max = classLibs.length; i < max; i++) {
+			buffer.append(classLibs[i]).append(File.pathSeparatorChar);
+
+		}
+		return buffer.toString();
+	}
+
+	/**
+	 * Returns the JRE directory this tests are running on. Returns null if none
+	 * could be found.
+	 * 
+	 * Example of use: [org.eclipse.jdt.core.tests.util.Util.getJREDirectory()]
+	 */
+	public static String getJREDirectory() {
+		return System.getProperty("java.home");
+	}
+
+	/**
+	 * Search the user hard-drive for a possible output directory. Returns null
+	 * if none could be found.
+	 * 
+	 * Example of use:
+	 * [org.eclipse.jdt.core.tests.util.Util.getOutputDirectory()]
+	 */
+	public static String getOutputDirectory() {
+		String container = System.getProperty("user.home");
+		if (container == null) {
+			return null;
+		} else {
+			return toNativePath(container) + File.separator + OUTPUT_DIRECTORY;
+		}
+	}
+
+	/**
+	 * Returns the next available port number on the local host.
+	 */
+	public static int getFreePort() {
+		ServerSocket socket = null;
+		try {
+			socket = new ServerSocket(0);
+			return socket.getLocalPort();
+		} catch (IOException e) {
+			// ignore
+		} finally {
+			if (socket != null) {
+				try {
+					socket.close();
+				} catch (IOException e) {
+					// ignore
+				}
+			}
+		}
+		return -1;
+	}
+
+	/**
+	 * Makes the given path a path using native path separators as returned by
+	 * File.getPath() and trimming any extra slash.
+	 */
+	public static String toNativePath(String path) {
+		String nativePath = path.replace('\\', File.separatorChar).replace('/',
+				File.separatorChar);
+		return nativePath.endsWith("/") || nativePath.endsWith("\\") ? nativePath
+				.substring(0, nativePath.length() - 1)
+				: nativePath;
+	}
+
+	public static void writeToFile(String contents, String destinationFilePath) {
+		File destFile = new File(destinationFilePath);
+		FileOutputStream output = null;
+		try {
+			output = new FileOutputStream(destFile);
+			PrintWriter writer = new PrintWriter(output);
+			writer.print(contents);
+			writer.flush();
+		} catch (IOException e) {
+			e.printStackTrace();
+			return;
+		} finally {
+			if (output != null) {
+				try {
+					output.close();
+				} catch (IOException e2) {
+				}
+			}
+		}
+	}
+}