tests/org.eclipse.rap.core.tests.harness/src/org/eclipse/core/tests/harness/CoreTest.java - rap/org.eclipse.rap - Git at Google

 /*******************************************************************************
  * Copyright (c) 2004, 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.core.tests.harness;

 import java.io.*;
 import junit.framework.TestCase;
 import org.eclipse.core.runtime.*;

 /**
  * @since 3.1
  */
 public class CoreTest extends TestCase {

 	/** counter for generating unique random file system locations */
 	protected static int nextLocationCounter = 0;

 	// plug-in identified for the core.tests.harness plug-in.
 	public static final String PI_HARNESS = "org.eclipse.core.tests.harness";

 	public static void debug(String message) {
 		String id = "org.eclipse.core.tests.harness/debug";
 		String option = Platform.getDebugOption(id);
 		if (Boolean.TRUE.toString().equalsIgnoreCase(option))
 			System.out.println(message);
 	}

 	/**
 	 * Fails the test due to the given throwable.
 	 */
 	public static void fail(String message, Throwable e) {
 		// If the exception is a CoreException with a multistatus
 		// then print out the multistatus so we can see all the info.
 		if (e instanceof CoreException) {
 			IStatus status = ((CoreException) e).getStatus();
 			//if the status does not have an exception, print the stack for this one
 			if (status.getException() == null)
 				e.printStackTrace();
 			write(status, 0);
 		} else
 			e.printStackTrace();
 		fail(message + ": " + e);
 	}

 	private static void indent(OutputStream output, int indent) {
 		for (int i = 0; i < indent; i++)
 			try {
 				output.write("\t".getBytes());
 			} catch (IOException e) {
 				// ignore
 			}
 	}

 	public static void log(String pluginID, IStatus status) {
 		Platform.getLog(Platform.getBundle(pluginID)).log(status);
 	}

 	public static void log(String pluginID, Throwable e) {
 		log(pluginID, new Status(IStatus.ERROR, pluginID, IStatus.ERROR, "Error", e)); //$NON-NLS-1$
 	}

 	private static void write(IStatus status, int indent) {
 		PrintStream output = System.out;
 		indent(output, indent);
 		output.println("Severity: " + status.getSeverity());

 		indent(output, indent);
 		output.println("Plugin ID: " + status.getPlugin());

 		indent(output, indent);
 		output.println("Code: " + status.getCode());

 		indent(output, indent);
 		output.println("Message: " + status.getMessage());

 		if (status.getException() != null) {
 			indent(output, indent);
 			output.print("Exception: ");
 			status.getException().printStackTrace(output);
 		}

 		if (status.isMultiStatus()) {
 			IStatus[] children = status.getChildren();
 			for (int i = 0; i < children.length; i++)
 				write(children[i], indent + 1);
 		}
 	}

 	public CoreTest() {
 		super();
 	}

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

 	/**
 	 * Asserts that a stream closes successfully. Null streams
 	 * are ignored, but failure to close the stream is reported as
 	 * an assertion failure.
 	 * @since 3.2
 	 */
 	protected void assertClose(InputStream stream) {
 		if (stream == null)
 			return;
 		try {
 			stream.close();
 		} catch (IOException e) {
 			fail("Failed close in assertClose", e);
 		}
 	}

 	/**
 	 * Asserts that a stream closes successfully. Null streams
 	 * are ignored, but failure to close the stream is reported as
 	 * an assertion failure.
 	 * @since 3.2
 	 */
 	protected void assertClose(OutputStream stream) {
 		if (stream == null)
 			return;
 		try {
 			stream.close();
 		} catch (IOException e) {
 			fail("Failed close in assertClose", e);
 		}
 	}

 	protected void assertEquals(String message, Object[] expected, Object[] actual) {
 		if (expected == null && actual == null)
 			return;
 		if (expected == null || actual == null)
 			fail(message);
 		if (expected.length != actual.length)
 			fail(message);
 		for (int i = 0; i < expected.length; i++)
 			assertEquals(message, expected[i], actual[i]);
 	}

 	protected void assertEquals(String message, Object[] expected, Object[] actual, boolean orderImportant) {
 		// if the order in the array must match exactly, then call the other method
 		if (orderImportant) {
 			assertEquals(message, expected, actual);
 			return;
 		}
 		// otherwise use this method and check that the arrays are equal in any order
 		if (expected == null && actual == null)
 			return;
 		if (expected == actual)
 			return;
 		if (expected == null || actual == null)
 			assertTrue(message + ".1", false);
 		if (expected.length != actual.length)
 			assertTrue(message + ".2", false);
 		boolean[] found = new boolean[expected.length];
 		for (int i = 0; i < expected.length; i++) {
 			for (int j = 0; j < expected.length; j++) {
 				if (!found[j] && expected[i].equals(actual[j]))
 					found[j] = true;
 			}
 		}
 		for (int i = 0; i < found.length; i++)
 			if (!found[i])
 				assertTrue(message + ".3." + i, false);
 	}

 	/**
 	 * Create the given file in the file system.
 	 */
 	public void createFileInFileSystem(File file, InputStream contents) throws IOException {
 		file.getParentFile().mkdirs();
 		FileOutputStream output = new FileOutputStream(file);
 		transferData(contents, output);
 	}

 	protected void ensureDoesNotExistInFileSystem(java.io.File file) {
 		FileSystemHelper.clear(file);
 	}

 	public InputStream getContents(java.io.File target, String errorCode) {
 		try {
 			return new FileInputStream(target);
 		} catch (IOException e) {
 			fail(errorCode, e);
 		}
 		return null; // never happens
 	}

 	/**
 	 * Return an input stream with some the specified text to use
 	 * as contents for a file resource.
 	 */
 	public InputStream getContents(String text) {
 		return new ByteArrayInputStream(text.getBytes());
 	}

 	public IProgressMonitor getMonitor() {
 		return new FussyProgressMonitor();
 	}

 	/**
 	 * Return an input stream with some random text to use
 	 * as contents for a file resource.
 	 */
 	public InputStream getRandomContents() {
 		return new ByteArrayInputStream(getRandomString().getBytes());
 	}

 	/**
 	 * Returns a unique location on disk.  It is guaranteed that no file currently
 	 * exists at that location.  The returned location will be unique with respect
 	 * to all other locations generated by this method in the current session.
 	 * If the caller creates a folder or file at this location, they are responsible for
 	 * deleting it when finished.
 	 */
 	public IPath getRandomLocation() {
 		return FileSystemHelper.getRandomLocation(getTempDir());
 	}

 	/**
 	 * Return String with some random text to use
 	 * as contents for a file resource.
 	 */
 	public String getRandomString() {
 		switch ((int) Math.round(Math.random() * 10)) {
 			case 0 :
 				return "este e' o meu conteudo (portuguese)";
 			case 1 :
 				return "ho ho ho";
 			case 2 :
 				return "I'll be back";
 			case 3 :
 				return "don't worry, be happy";
 			case 4 :
 				return "there is no imagination for more sentences";
 			case 5 :
 				return "customize yours";
 			case 6 :
 				return "foo";
 			case 7 :
 				return "bar";
 			case 8 :
 				return "foobar";
 			case 9 :
 				return "case 9";
 			default :
 				return "these are my contents";
 		}
 	}

 	public IPath getTempDir() {
 		return FileSystemHelper.getTempDir();
 	}

 	public String getUniqueString() {
 		return System.currentTimeMillis() + "-" + Math.random();
 	}

 	/**
 	 * Copy the data from the input stream to the output stream.
 	 * Close both streams when finished.
 	 */
 	public void transferData(InputStream input, OutputStream output) {
 		try {
 			try {
 				int c = 0;
 				while ((c = input.read()) != -1)
 					output.write(c);
 			} finally {
 				input.close();
 				output.close();
 			}
 		} catch (IOException e) {
 			e.printStackTrace();
 			assertTrue(e.toString(), false);
 		}
 	}

 	/**
 	 * Copy the data from the input stream to the output stream.
 	 * Do not close either of the streams.
 	 */
 	public void transferDataWithoutClose(InputStream input, OutputStream output) {
 		try {
 			int c = 0;
 			while ((c = input.read()) != -1)
 				output.write(c);
 		} catch (IOException e) {
 			e.printStackTrace();
 			assertTrue(e.toString(), false);
 		}
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2004, 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.core.tests.harness;

	import java.io.*;
	import junit.framework.TestCase;
	import org.eclipse.core.runtime.*;

	/**
	* @since 3.1
	*/
	public class CoreTest extends TestCase {

	/** counter for generating unique random file system locations */
	protected static int nextLocationCounter = 0;

	// plug-in identified for the core.tests.harness plug-in.
	public static final String PI_HARNESS = "org.eclipse.core.tests.harness";

	public static void debug(String message) {
	String id = "org.eclipse.core.tests.harness/debug";
	String option = Platform.getDebugOption(id);
	if (Boolean.TRUE.toString().equalsIgnoreCase(option))
	System.out.println(message);
	}

	/**
	* Fails the test due to the given throwable.
	*/
	public static void fail(String message, Throwable e) {
	// If the exception is a CoreException with a multistatus
	// then print out the multistatus so we can see all the info.
	if (e instanceof CoreException) {
	IStatus status = ((CoreException) e).getStatus();
	//if the status does not have an exception, print the stack for this one
	if (status.getException() == null)
	e.printStackTrace();
	write(status, 0);
	} else
	e.printStackTrace();
	fail(message + ": " + e);
	}

	private static void indent(OutputStream output, int indent) {
	for (int i = 0; i < indent; i++)
	try {
	output.write("\t".getBytes());
	} catch (IOException e) {
	// ignore
	}
	}

	public static void log(String pluginID, IStatus status) {
	Platform.getLog(Platform.getBundle(pluginID)).log(status);
	}

	public static void log(String pluginID, Throwable e) {
	log(pluginID, new Status(IStatus.ERROR, pluginID, IStatus.ERROR, "Error", e)); //$NON-NLS-1$
	}

	private static void write(IStatus status, int indent) {
	PrintStream output = System.out;
	indent(output, indent);
	output.println("Severity: " + status.getSeverity());

	indent(output, indent);
	output.println("Plugin ID: " + status.getPlugin());

	indent(output, indent);
	output.println("Code: " + status.getCode());

	indent(output, indent);
	output.println("Message: " + status.getMessage());

	if (status.getException() != null) {
	indent(output, indent);
	output.print("Exception: ");
	status.getException().printStackTrace(output);
	}

	if (status.isMultiStatus()) {
	IStatus[] children = status.getChildren();
	for (int i = 0; i < children.length; i++)
	write(children[i], indent + 1);
	}
	}

	public CoreTest() {
	super();
	}

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

	/**
	* Asserts that a stream closes successfully. Null streams
	* are ignored, but failure to close the stream is reported as
	* an assertion failure.
	* @since 3.2
	*/
	protected void assertClose(InputStream stream) {
	if (stream == null)
	return;
	try {
	stream.close();
	} catch (IOException e) {
	fail("Failed close in assertClose", e);
	}
	}

	/**
	* Asserts that a stream closes successfully. Null streams
	* are ignored, but failure to close the stream is reported as
	* an assertion failure.
	* @since 3.2
	*/
	protected void assertClose(OutputStream stream) {
	if (stream == null)
	return;
	try {
	stream.close();
	} catch (IOException e) {
	fail("Failed close in assertClose", e);
	}
	}

	protected void assertEquals(String message, Object[] expected, Object[] actual) {
	if (expected == null && actual == null)
	return;
	if (expected == null \|\| actual == null)
	fail(message);
	if (expected.length != actual.length)
	fail(message);
	for (int i = 0; i < expected.length; i++)
	assertEquals(message, expected[i], actual[i]);
	}

	protected void assertEquals(String message, Object[] expected, Object[] actual, boolean orderImportant) {
	// if the order in the array must match exactly, then call the other method
	if (orderImportant) {
	assertEquals(message, expected, actual);
	return;
	}
	// otherwise use this method and check that the arrays are equal in any order
	if (expected == null && actual == null)
	return;
	if (expected == actual)
	return;
	if (expected == null \|\| actual == null)
	assertTrue(message + ".1", false);
	if (expected.length != actual.length)
	assertTrue(message + ".2", false);
	boolean[] found = new boolean[expected.length];
	for (int i = 0; i < expected.length; i++) {
	for (int j = 0; j < expected.length; j++) {
	if (!found[j] && expected[i].equals(actual[j]))
	found[j] = true;
	}
	}
	for (int i = 0; i < found.length; i++)
	if (!found[i])
	assertTrue(message + ".3." + i, false);
	}

	/**
	* Create the given file in the file system.
	*/
	public void createFileInFileSystem(File file, InputStream contents) throws IOException {
	file.getParentFile().mkdirs();
	FileOutputStream output = new FileOutputStream(file);
	transferData(contents, output);
	}

	protected void ensureDoesNotExistInFileSystem(java.io.File file) {
	FileSystemHelper.clear(file);
	}

	public InputStream getContents(java.io.File target, String errorCode) {
	try {
	return new FileInputStream(target);
	} catch (IOException e) {
	fail(errorCode, e);
	}
	return null; // never happens
	}

	/**
	* Return an input stream with some the specified text to use
	* as contents for a file resource.
	*/
	public InputStream getContents(String text) {
	return new ByteArrayInputStream(text.getBytes());
	}

	public IProgressMonitor getMonitor() {
	return new FussyProgressMonitor();
	}

	/**
	* Return an input stream with some random text to use
	* as contents for a file resource.
	*/
	public InputStream getRandomContents() {
	return new ByteArrayInputStream(getRandomString().getBytes());
	}

	/**
	* Returns a unique location on disk. It is guaranteed that no file currently
	* exists at that location. The returned location will be unique with respect
	* to all other locations generated by this method in the current session.
	* If the caller creates a folder or file at this location, they are responsible for
	* deleting it when finished.
	*/
	public IPath getRandomLocation() {
	return FileSystemHelper.getRandomLocation(getTempDir());
	}

	/**
	* Return String with some random text to use
	* as contents for a file resource.
	*/
	public String getRandomString() {
	switch ((int) Math.round(Math.random() * 10)) {
	case 0 :
	return "este e' o meu conteudo (portuguese)";
	case 1 :
	return "ho ho ho";
	case 2 :
	return "I'll be back";
	case 3 :
	return "don't worry, be happy";
	case 4 :
	return "there is no imagination for more sentences";
	case 5 :
	return "customize yours";
	case 6 :
	return "foo";
	case 7 :
	return "bar";
	case 8 :
	return "foobar";
	case 9 :
	return "case 9";
	default :
	return "these are my contents";
	}
	}

	public IPath getTempDir() {
	return FileSystemHelper.getTempDir();
	}

	public String getUniqueString() {
	return System.currentTimeMillis() + "-" + Math.random();
	}

	/**
	* Copy the data from the input stream to the output stream.
	* Close both streams when finished.
	*/
	public void transferData(InputStream input, OutputStream output) {
	try {
	try {
	int c = 0;
	while ((c = input.read()) != -1)
	output.write(c);
	} finally {
	input.close();
	output.close();
	}
	} catch (IOException e) {
	e.printStackTrace();
	assertTrue(e.toString(), false);
	}
	}

	/**
	* Copy the data from the input stream to the output stream.
	* Do not close either of the streams.
	*/
	public void transferDataWithoutClose(InputStream input, OutputStream output) {
	try {
	int c = 0;
	while ((c = input.read()) != -1)
	output.write(c);
	} catch (IOException e) {
	e.printStackTrace();
	assertTrue(e.toString(), false);
	}
	}

	}