core/tests/org.eclipse.dltk.formatter.tests/src/org/eclipse/dltk/formatter/tests/ScriptedTest.java

/*******************************************************************************
 * Copyright (c) 2008 xored software, Inc.
 *
 * 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:
 *     xored software, Inc. - initial API and Implementation (Alex Panchenko)
 *******************************************************************************/
package org.eclipse.dltk.formatter.tests;

import java.io.IOException;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.eclipse.dltk.compiler.util.Util;
import org.eclipse.dltk.ui.formatter.FormatterException;
import org.eclipse.dltk.ui.formatter.IScriptFormatter;
import org.eclipse.dltk.utils.TextUtils;
import org.osgi.framework.Bundle;

import junit.framework.AssertionFailedError;
import junit.framework.TestCase;
import junit.framework.TestResult;
import junit.framework.TestSuite;

public class ScriptedTest extends AbstractFormatterTest {

	public static interface IScriptedTestContext {
		Bundle getResourceBundle();

		String getCharset();

		IScriptFormatter createFormatter(Map<String, Object> preferences);

		String validateOptionName(String name);

		String validateOptionValue(String name, String value);
	}

	private boolean ignored;
	private String input;
	private String expected;

	@Override
	public void run(TestResult result) {
		if (!ignored) {
			super.run(result);
		}
	}

	@Override
	protected void runTest() throws Throwable {
		final String output = format(input);
		assertEquals(expected, output);
		try {
			assertEquals("Reformatting", expected, format(output)); //$NON-NLS-1$
		} catch (FormatterException e) {
			AssertionFailedError fail = new AssertionFailedError(e.getMessage());
			fail.initCause(e);
			throw fail;
		}
	}

	private IScriptedTestContext context = null;
	private Map<String, Object> preferences = null;

	@Override
	protected Map<String, Object> getDefaultPreferences() {
		return preferences;
	}

	public void setPreference(String optionName, Object optionValue) {
		if (preferences == null) {
			preferences = new HashMap<String, Object>();
		}
		preferences.put(optionName, optionValue);
	}

	@Override
	protected IScriptFormatter createFormatter(Map<String, Object> preferences) {
		return context.createFormatter(preferences);
	}

	protected static char[] readResource(IScriptedTestContext context,
			String resourceName) throws IOException {
		final URL resource = context.getResourceBundle().getResource(
				resourceName);
		assertNotNull(resourceName + " is not found", resource); //$NON-NLS-1$
		return Util.getInputStreamAsCharArray(resource.openStream(), -1,
				context.getCharset());
	}

	private static final String TEST_MARKER = "===="; //$NON-NLS-1$
	private static final String IGNORE_PREFIX = "@IGNORE:"; //$NON-NLS-1$
	private static final String RESPONSE_MARKER = "=="; //$NON-NLS-1$
	private static final String OPTION_MARKER = "==>"; //$NON-NLS-1$

	public TestSuite createScriptedSuite(IScriptedTestContext context,
			String resourceName) {
		return createScriptedSuite(context, getClass().getName(), resourceName,
				0);
	}

	/**
	 * @param resourceName
	 * @return
	 */
	public TestSuite createScriptedSuite(IScriptedTestContext context,
			String suiteName, String resourceName, int beginTestIndex) {
		final TestSuite suite = new TestSuite(suiteName);
		try {
			final String content = new String(readResource(context,
					resourceName));
			final String[] lines = TextUtils.splitLines(content);
			String testName = "START";
			int testIndex = 0;
			int testBegin = 0;
			int responseBegin = -1;
			int i = 0;
			while (i < lines.length) {
				final String line = lines[i++];
				if (line.startsWith(TEST_MARKER)
						|| line.startsWith(OPTION_MARKER)) {
					final int testEnd = i - 1;
					if (testEnd > testBegin) {
						if (responseBegin < 0) {
							throw new IllegalArgumentException(
									"No response marker - next test started on line "
											+ testEnd);
						}
						if (testIndex >= beginTestIndex) {
							suite.addTest(createTest(context, preferences,
									testName, lines, testBegin, responseBegin,
									testEnd));
						}
						++testIndex;
					}
					testBegin = i;
					responseBegin = -1;
					if (line.startsWith(TEST_MARKER)) {
						testName = line.substring(TEST_MARKER.length()).trim();
					} else if (line.startsWith(OPTION_MARKER)) {
						final Matcher matcher = OPTION_PATTERN.matcher(line
								.substring(OPTION_MARKER.length()));
						if (matcher.matches()) {
							final String optionName = context
									.validateOptionName(matcher.group(1));
							if (optionName == null)
								throw new IllegalArgumentException(
										"Invalid option name: " + line);
							final String optionValue = context
									.validateOptionValue(optionName, matcher
											.group(2));
							if (optionValue == null)
								throw new IllegalArgumentException(
										"Invalid option value: " + line);
							setPreference(optionName, optionValue);
						} else {
							suite.addTest(new TestCase(resourceName + ":"
									+ testEnd) {
								@Override
								protected void runTest() throws Throwable {
									throw new IllegalArgumentException(line);
								}
							});
						}
					}
				} else if (line.startsWith(RESPONSE_MARKER)) {
					if (responseBegin >= 0) {
						throw new IllegalArgumentException(
								"Multiple response markers: line " + (i - 1)
										+ ", previous on line " + responseBegin);
					}
					responseBegin = i;
				}
			}
			if (lines.length > testBegin) {
				if (responseBegin < 0) {
					throw new IllegalArgumentException(
							"No response marker in last test");
				}
				if (testIndex >= beginTestIndex) {
					suite.addTest(createTest(context, preferences, testName,
							lines, testBegin, responseBegin, lines.length));
				}
			}
		} catch (final Throwable e) {
			suite.addTest(new TestCase(e.getClass().getName()) {
				@Override
				protected void runTest() throws Throwable {
					throw e;
				}
			});
		}
		return suite;
	}

	private static final Pattern OPTION_PATTERN = Pattern
			.compile("\\s*([\\w\\.]+)\\s*=\\s*(\\S+)\\s*"); //$NON-NLS-1$

	private ScriptedTest createTest(IScriptedTestContext context,
			Map<String, Object> preferences, String testName, String[] lines,
			int testBegin, int responseBegin, final int testEnd)
			throws Exception {
		final String input = joinLines(lines, testBegin, responseBegin - 1);
		final String expected = joinLines(lines, responseBegin, testEnd);
		ScriptedTest test = getClass().newInstance();
		if (testName.startsWith(IGNORE_PREFIX)) {
			test.ignored = true;
			test.setName(testName.substring(IGNORE_PREFIX.length()).trim());
		} else {
			test.setName(testName);
		}
		test.input = input;
		test.expected = expected;
		test.context = context;
		test.preferences = preferences != null ? new HashMap<String, Object>(
				preferences) : preferences;
		return test;
	}

}