--- /dev/null
+/*******************************************************************************
+ * 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 = "abc\ndef\tghi",
+ * indent = 3
+ * result = "\"\t\t\tabc\\n" +
+ * "\t\t\tdef\tghi\""
+ * </pre>
+ *
+ * </li>
+ * <li>
+ *
+ * <pre>
+ * input string = "abc\ndef\tghi\n",
+ * indent = 3
+ * result = "\"\t\t\tabc\\n" +
+ * "\t\t\tdef\tghi\\n\""
+ * </pre>
+ *
+ * </li>
+ * <li>
+ *
+ * <pre>
+ * input string = "abc\r\ndef\tghi\r\n",
+ * indent = 3
+ * result = "\"\t\t\tabc\\r\\n" +
+ * "\t\t\tdef\tghi\\r\\n\""
+ * </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) {
+ }
+ }
+ }
+ }
+}
git://secure.phpeclipse.com / phpeclipse.git / blobdiff