[Phpeclipse-commits] net.sourceforge.phpeclipse.test/src/net/sourceforge/phpdt/core/tests/util Uti

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 454-5900

Update of /cvsroot/phpeclipse/net.sourceforge.phpeclipse.test/src/net/sourceforge/phpdt/core/tests/util
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv11399/src/net/sourceforge/phpdt/core/tests/util

Added Files:
	Util.java AbstractCompilerTest.java 
Log Message:
Moved the code in the "tests" plugin (plural) to the "test" fragment (singular). The tests plugin will be used for shared testing utilities. Each plugin will have its own ".test" fragment for junit tests going forward. 

--- NEW FILE: Util.java ---
/*******************************************************************************
 * 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) {
				}
			}
		}
	}
}

--- NEW FILE: AbstractCompilerTest.java ---
/*******************************************************************************
 * 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.PrintWriter;
import java.io.StringWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Locale;
import java.util.Map;

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import net.sourceforge.phpdt.core.compiler.IProblem;
import net.sourceforge.phpdt.internal.compiler.CompilationResult;
import net.sourceforge.phpdt.internal.compiler.DefaultErrorHandlingPolicies;
import net.sourceforge.phpdt.internal.compiler.batch.CompilationUnit;
import net.sourceforge.phpdt.internal.compiler.env.ICompilationUnit;
import net.sourceforge.phpdt.internal.compiler.impl.CompilerOptions;
import net.sourceforge.phpdt.internal.compiler.parser.Scanner;
import net.sourceforge.phpdt.internal.compiler.parser.UnitParser;
import net.sourceforge.phpdt.internal.compiler.problem.DefaultProblem;
import net.sourceforge.phpdt.internal.compiler.problem.DefaultProblemFactory;
import net.sourceforge.phpdt.internal.compiler.problem.ProblemReporter;

public class AbstractCompilerTest extends TestCase {

	protected String complianceLevel;

	public void checkParsePHP(char[] source, String expectedSyntaxErrorDiagnosis) {
		// String testName) {

		UnitParser parser = new UnitParser(new ProblemReporter(
				DefaultErrorHandlingPolicies.proceedWithAllProblems(),
				new CompilerOptions(getCompilerOptions()),
				new DefaultProblemFactory(Locale.getDefault())));

		ICompilationUnit sourceUnit = new CompilationUnit(source, "", null);
		CompilationResult compilationResult = new CompilationResult(sourceUnit,
				0, 0, 0);

		parser.dietParse(sourceUnit, compilationResult, true);
		StringBuffer buffer = new StringBuffer(100);
		if (compilationResult.hasProblems() || compilationResult.hasTasks()) {
			IProblem[] problems = compilationResult.getAllProblems();
			int count = problems.length;
			int problemCount = 0;
			char[] unitSource = compilationResult.compilationUnit.getContents();
			for (int i = 0; i < count; i++) {
				if (problems[i] != null) {
					if (problemCount == 0)
						buffer.append("----------\n");
					problemCount++;
					buffer
							.append(problemCount
									+ (problems[i].isError() ? ". ERROR"
											: ". WARNING"));
					buffer.append(" in "
							+ new String(problems[i].getOriginatingFileName())
									.replace('/', '\\'));
					try {
						buffer.append(((DefaultProblem) problems[i])
								.errorReportSource(unitSource));
						buffer.append("\n");
						buffer.append(problems[i].getMessage());
						buffer.append("\n");
					} catch (Exception e) {
						StringWriter stringWriter = new StringWriter();
						e.printStackTrace(new PrintWriter(stringWriter));
						buffer.append(stringWriter.getBuffer());
					}
					buffer.append("----------\n");
				}
			}
		}
		String computedSyntaxErrorDiagnosis = buffer.toString();
		if (!expectedSyntaxErrorDiagnosis.equals(computedSyntaxErrorDiagnosis)) {
			System.out
					.println(Util.displayString(computedSyntaxErrorDiagnosis));
		}
		assertEquals("Invalid syntax error diagnosis",
				expectedSyntaxErrorDiagnosis, computedSyntaxErrorDiagnosis);
	}

	public void checkParseHTML(char[] source,
			String expectedSyntaxErrorDiagnosis) {
		// String testName) {

		UnitParser parser = new UnitParser(new ProblemReporter(
				DefaultErrorHandlingPolicies.proceedWithAllProblems(),
				new CompilerOptions(getCompilerOptions()),
				new DefaultProblemFactory(Locale.getDefault())));

		ICompilationUnit sourceUnit = new CompilationUnit(source, "", null);
		CompilationResult compilationResult = new CompilationResult(sourceUnit,
				0, 0, 0);

		parser.dietParse(sourceUnit, compilationResult, false);

		StringBuffer buffer = new StringBuffer(100);
		if (compilationResult.hasProblems() || compilationResult.hasTasks()) {
			IProblem[] problems = compilationResult.getAllProblems();
			int count = problems.length;
			int problemCount = 0;
			char[] unitSource = compilationResult.compilationUnit.getContents();
			for (int i = 0; i < count; i++) {
				if (problems[i] != null) {
					if (problemCount == 0)
						buffer.append("----------\n");
					problemCount++;
					buffer
							.append(problemCount
									+ (problems[i].isError() ? ". ERROR"
											: ". WARNING"));
					buffer.append(" in "
							+ new String(problems[i].getOriginatingFileName())
									.replace('/', '\\'));
					try {
						buffer.append(((DefaultProblem) problems[i])
								.errorReportSource(unitSource));
						buffer.append("\n");
						buffer.append(problems[i].getMessage());
						buffer.append("\n");
					} catch (Exception e) {
						StringWriter stringWriter = new StringWriter();
						e.printStackTrace(new PrintWriter(stringWriter));
						buffer.append(stringWriter.getBuffer());
					}
					buffer.append("----------\n");
				}
			}
		}
		String computedSyntaxErrorDiagnosis = buffer.toString();
		if (!expectedSyntaxErrorDiagnosis.equals(computedSyntaxErrorDiagnosis)) {
			System.out
					.println(Util.displayString(computedSyntaxErrorDiagnosis));
		}
		assertEquals("Invalid syntax error diagnosis",
				expectedSyntaxErrorDiagnosis, computedSyntaxErrorDiagnosis);
	}

	/*
	 * Returns the possible compliance levels this VM instance can run.
	 */
	// public static int getPossibleComplianceLevels() {
	// if (possibleComplianceLevels == -1) {
	// String compliance = System.getProperty("compliance");
	// if (compliance != null) {
	// if (COMPLIANCE_1_3.equals(compliance)) {
	// possibleComplianceLevels = F_1_3;
	// } else if (COMPLIANCE_1_4.equals(compliance)) {
	// possibleComplianceLevels = F_1_4;
	// } else if (COMPLIANCE_1_5.equals(compliance)) {
	// possibleComplianceLevels = F_1_5;
	// } else {
	// System.out.println("Invalid compliance specified (" + compliance + ")");
	// System.out.println("Use one of " + COMPLIANCE_1_3 + ", " + COMPLIANCE_1_4
	// + ", " + COMPLIANCE_1_5);
	// System.out.println("Defaulting to all possible compliances");
	// }
	// }
	// if (possibleComplianceLevels == -1) {
	// possibleComplianceLevels = F_1_3;
	// String specVersion = System.getProperty("java.specification.version");
	// boolean canRun1_4 = !"1.0".equals(specVersion) &&
	// !"1.1".equals(specVersion) && !"1.2".equals(specVersion) &&
	// !"1.3".equals(specVersion);
	// if (canRun1_4) {
	// possibleComplianceLevels |= F_1_4;
	// }
	// boolean canRun1_5 = canRun1_4 && !"1.4".equals(specVersion);
	// if (canRun1_5) {
	// possibleComplianceLevels |= F_1_5;
	// }
	// }
	// }
	// return possibleComplianceLevels;
	// }
	/*
	 * Returns a test suite including the tests defined by the given classes for
	 * the given complianceLevel (see AbstractCompilerTest for valid values) and
	 * using the given setup class (CompilerTestSetup or a subclass)
	 */
	public static Test suiteForComplianceLevel(String complianceLevel,
			Class setupClass, ArrayList testClasses) {
		TestSuite suite;
		if (testClasses.size() == 1) {
			suite = new TestSuite((Class) testClasses.get(0), complianceLevel);
		} else {
			suite = new TestSuite(complianceLevel);
			for (int i = 0, length = testClasses.size(); i < length; i++) {
				Class testClass = (Class) testClasses.get(i);
				TestSuite innerSuite = new TestSuite(testClass);
				suite.addTest(innerSuite);
			}
		}

		// call the setup constructor with the suite and compliance level
		try {
			Constructor constructor = setupClass.getConstructor(new Class[] {
					Test.class, String.class });
			Test setUp = (Test) constructor.newInstance(new Object[] { suite,
					complianceLevel });
			return setUp;
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.getTargetException().printStackTrace();
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		}

		return null;
	}

	public AbstractCompilerTest(String name) {
		super(name);
	}

	protected Map getCompilerOptions() {
		Map options = new CompilerOptions().getMap();
		// ignore warnings
		options.put(CompilerOptions.OPTION_PHPVarDeprecatedWarning,
				CompilerOptions.IGNORE);
		options.put(CompilerOptions.OPTION_PHPBadStyleKeywordWarning,
				CompilerOptions.IGNORE);
		options.put(
				CompilerOptions.OPTION_PHPBadStyleUppercaseIdentifierWarning,
				CompilerOptions.IGNORE);
		options.put(CompilerOptions.OPTION_PHPIncludeNotExistWarning,
				CompilerOptions.IGNORE);
		options.put(CompilerOptions.OPTION_UninitializedLocalVariableWarning,
				CompilerOptions.IGNORE);
		options.put(CompilerOptions.OPTION_CodeCannotBeReachedWarning,
				CompilerOptions.IGNORE);
		return options;
	}

	public String getName() {
		String name = super.getName();
		if (this.complianceLevel != null) {
			name = this.complianceLevel + " - " + name;
		}
		return name;
	}

	protected void checkPHP(String strEval) {
		checkPHP(strEval, "");
	}

	protected void checkPHP(String strEval, String expectedSyntaxErrorDiagnosis) {
		if (Scanner.DEBUG) {
			System.out.println("\n------------------------------------");
			System.out.println(strEval);
		}
		checkParsePHP(strEval.toCharArray(), expectedSyntaxErrorDiagnosis);
	}

	protected void checkHTML(String strEval) {
		if (Scanner.DEBUG) {
			System.out.println("\n------------------------------------");
			System.out.println(strEval);
		}
		checkParseHTML(strEval.toCharArray(), "");
	}
}

[Phpeclipse-commits] net.sourceforge.phpeclipse.test/src/net/sourceforge/phpdt/core/tests/util Uti

[Phpeclipse-commits] net.sourceforge.phpeclipse.test/src/net/sourceforge/phpdt/core/tests/util Util.java, NONE, 1.1 AbstractCompilerTest.java, NONE, 1.1