apitools/org.eclipse.pde.api.tools.tests/src/org/eclipse/pde/api/tools/builder/tests/compatibility/CompatibilityTest.java - pde/eclipse.pde.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2008, 2009 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.pde.api.tools.builder.tests.compatibility;

 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.jar.JarFile;

 import junit.framework.Test;
 import junit.framework.TestSuite;

 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.Path;
 import org.eclipse.jdt.core.tests.junit.extension.TestCase;
 import org.eclipse.pde.api.tools.builder.tests.ApiBuilderTest;
 import org.eclipse.pde.api.tools.builder.tests.ApiProblem;
 import org.eclipse.pde.api.tools.builder.tests.ApiTestingEnvironment;
 import org.eclipse.pde.api.tools.internal.model.ApiModelFactory;
 import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;
 import org.eclipse.pde.api.tools.internal.provisional.IApiBaselineManager;
 import org.eclipse.pde.api.tools.internal.provisional.model.IApiBaseline;
 import org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent;
 import org.eclipse.pde.api.tools.tests.ApiTestsPlugin;

 /**
  * Base class for binary compatibility tests
  *
  * @since 1.0
  */
 public abstract class CompatibilityTest extends ApiBuilderTest {

 	/**
 	 * Constructor
 	 * @param name
 	 */
 	public CompatibilityTest(String name) {
 		super(name);
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.pde.api.tools.builder.tests.ApiBuilderTests#getTestSourcePath()
 	 */
 	protected IPath getTestSourcePath() {
 		return new Path("compat");
 	}


 	/* (non-Javadoc)
 	 * @see org.eclipse.pde.api.tools.builder.tests.ApiBuilderTests#setBuilderOptions()
 	 */
 	protected void setBuilderOptions() {
 		enableUnsupportedTagOptions(false);
 		enableBaselineOptions(false);
 		enableCompatibilityOptions(true);
 		enableLeakOptions(false);
 		enableSinceTagOptions(false);
 		enableUsageOptions(false);
 		enableVersionNumberOptions(false);
 	}

 	/**
 	 * @return all of the child test classes of this class
 	 */
 	private static Class[] getAllTestClasses() {
 		Class[] classes = new Class[] {
 			ProjectTypeContainerTests.class,
 			BundleCompatibilityTests.class,
 			AnnotationCompatibilityTests.class,
 			InterfaceCompatibilityTests.class,
 			EnumCompatibilityTests.class,
 			ClassCompatibilityTests.class,
 			FieldCompatibilityTests.class,
 			MethodCompatibilityTests.class,
 			ConstructorCompatibilityTests.class,
 			SinceTagTest.class,
 			VersionTest.class,
 			BundleMergeSplitTests.class,
 			BundleVersionTests.class,
 		};
 		return classes;
 	}

 	/**
 	 * Collects tests from the getAllTestClasses() method into the given suite
 	 * @param suite
 	 */
 	private static void collectTests(TestSuite suite) {
 		// Hack to load all classes before computing their suite of test cases
 		// this allow to reset test cases subsets while running all Builder tests...
 		Class[] classes = getAllTestClasses();

 		// Reset forgotten subsets of tests
 		TestCase.TESTS_PREFIX = null;
 		TestCase.TESTS_NAMES = null;
 		TestCase.TESTS_NUMBERS = null;
 		TestCase.TESTS_RANGE = null;
 		TestCase.RUN_ONLY_ID = null;

 		/* tests */
 		for (int i = 0, length = classes.length; i < length; i++) {
 			Class clazz = classes[i];
 			Method suiteMethod;
 			try {
 				suiteMethod = clazz.getDeclaredMethod("suite", new Class[0]);
 			} catch (NoSuchMethodException e) {
 				e.printStackTrace();
 				continue;
 			}
 			Object test;
 			try {
 				test = suiteMethod.invoke(null, new Object[0]);
 			} catch (IllegalAccessException e) {
 				e.printStackTrace();
 				continue;
 			} catch (InvocationTargetException e) {
 				e.printStackTrace();
 				continue;
 			}
 			suite.addTest((Test) test);
 		}
 	}

 	/**
 	 * @return the tests for this class
 	 */
 	public static Test suite() {
 		TestSuite suite = new TestSuite(CompatibilityTest.class.getName());
 		collectTests(suite);
 		return suite;
 	}

 	/* (non-Javadoc)
 	 *
 	 * Ensure a baseline has been created to compare against.
 	 *
 	 * @see org.eclipse.pde.api.tools.builder.tests.ApiBuilderTest#setUp()
 	 */
 	@Override
 	protected void setUp() throws Exception {
 		// for the first compatibility test create workspace projects
 		ApiTestingEnvironment env = getEnv();
 		if (env != null) {
 			env.setRevert(true);
 		}
 		super.setUp();
 		IProject[] projects = getEnv().getWorkspace().getRoot().getProjects();
 		if (projects.length == 0) {
 			// populate the workspace with initial plug-ins/projects
 			createExistingProjects(BASELINE, true, true, false);
 		} else {
 			// build after revert
 			incrementalBuild();
 		}
 		IApiBaselineManager manager = ApiPlugin.getDefault().getApiBaselineManager();
 		IApiBaseline baseline = manager.getDefaultApiBaseline();
 		if (baseline == null) {
 			// create the API baseline
 			IApiBaseline profile = manager.getWorkspaceBaseline();
 			projects = getEnv().getWorkspace().getRoot().getProjects();
 			IPath baselineLocation = ApiTestsPlugin.getDefault().getStateLocation().append(BASELINE);
 			IApiComponent component = null;
 			for (int i = 0; i < projects.length; i++) {
 				component = profile.getApiComponent(projects[i].getName());
 					exportApiComponent(
 							projects[i],
 							component,
 							baselineLocation);
 			}
 			baseline = ApiModelFactory.newApiBaseline("API-baseline");
 			IApiComponent[] components = new IApiComponent[projects.length];
 			for (int i = 0; i < projects.length; i++) {
 				IProject project = projects[i];
 				IPath location = baselineLocation.append(project.getName());
 				components[i] = ApiModelFactory.newApiComponent(baseline, location.toOSString());
 			}
 			baseline.addApiComponents(components);
 			manager.addApiBaseline(baseline);
 			manager.setDefaultApiBaseline(baseline.getName());
 		}
 		getEnv().setRevertSourcePath(new Path(BASELINE));
 	}

 	@Override
 	protected void tearDown() throws Exception {
 		super.tearDown();
 		getEnv().setRevert(false);
 	}

 	/**
 	 * Performs a compatibility test. The workspace file at the specified (full workspace path)
 	 * location is updated with a corresponding file from test data. A build is performed
 	 * and problems are compared against the expected problems for the associated resource.
 	 *
 	 * @param workspaceFile file to update
 	 * @param incremental whether to perform an incremental (<code>true</code>) or
 	 * 	full (<code>false</code>) build
 	 * @throws Exception
 	 */
 	protected void performCompatibilityTest(IPath workspaceFile, boolean incremental) throws Exception {
 			updateWorkspaceFile(
 					workspaceFile,
 					getUpdateFilePath(workspaceFile.lastSegment()));
 			if (incremental) {
 				incrementalBuild();
 			} else {
 				fullBuild();
 			}
 			expectingNoJDTProblemsFor(workspaceFile);
 			ApiProblem[] problems = getEnv().getProblemsFor(workspaceFile, null);
 			assertProblems(problems);
 	}

 	/**
 	 * Performs a compatibility test. The workspace file at the specified (full workspace path)
 	 * location is updated with a corresponding file from test data. A build is performed
 	 * and problems are compared against the expected problems for the associated resource.
 	 *
 	 * @param workspaceFile file to update
 	 * @param incremental whether to perform an incremental (<code>true</code>) or
 	 * 	full (<code>false</code>) build
 	 * @throws Exception
 	 */
 	protected void performVersionTest(IPath workspaceFile, boolean incremental) throws Exception {
 			updateWorkspaceFile(
 					workspaceFile,
 					getUpdateFilePath(workspaceFile.lastSegment()));
 			if (incremental) {
 				incrementalBuild();
 			} else {
 				fullBuild();
 			}
 			ApiProblem[] problems = getEnv().getProblemsFor(new Path(workspaceFile.segment(0)).append(JarFile.MANIFEST_NAME), null);
 			assertProblems(problems);
 	}

 	/**
 	 * Performs a compatibility test. The workspace file at the specified (full workspace path)
 	 * location is deleted. A build is performed and problems are compared against the expected
 	 * problems for the associated resource.
 	 *
 	 * @param workspaceFile file to update
 	 * @param incremental whether to perform an incremental (<code>true</code>) or
 	 * 	full (<code>false</code>) build
 	 * @throws Exception
 	 */
 	protected void performDeletionCompatibilityTest(IPath workspaceFile, boolean incremental) throws Exception {
 			deleteWorkspaceFile(workspaceFile, true);
 			if (incremental) {
 				incrementalBuild();
 			} else {
 				fullBuild();
 			}
 			ApiProblem[] problems = getEnv().getProblems();
 			assertProblems(problems);
 	}

 	/**
 	 * Performs a compatibility test. The workspace file at the specified (full workspace path)
 	 * location is created. A build is performed and problems are compared against the expected
 	 * problems for the associated resource.
 	 *
 	 * @param workspaceFile file to update
 	 * @param incremental whether to perform an incremental (<code>true</code>) or
 	 * 	full (<code>false</code>) build
 	 * @throws Exception
 	 */
 	protected void performCreationCompatibilityTest(IPath workspaceFile, boolean incremental) throws Exception {
 		createWorkspaceFile(
 				workspaceFile,
 				getUpdateFilePath(workspaceFile.lastSegment()));
 		if (incremental) {
 			incrementalBuild();
 		} else {
 			fullBuild();
 		}
 		ApiProblem[] problems = getEnv().getProblems();
 		assertProblems(problems);
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2008, 2009 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.pde.api.tools.builder.tests.compatibility;

	import java.lang.reflect.InvocationTargetException;
	import java.lang.reflect.Method;
	import java.util.jar.JarFile;

	import junit.framework.Test;
	import junit.framework.TestSuite;

	import org.eclipse.core.resources.IProject;
	import org.eclipse.core.runtime.IPath;
	import org.eclipse.core.runtime.Path;
	import org.eclipse.jdt.core.tests.junit.extension.TestCase;
	import org.eclipse.pde.api.tools.builder.tests.ApiBuilderTest;
	import org.eclipse.pde.api.tools.builder.tests.ApiProblem;
	import org.eclipse.pde.api.tools.builder.tests.ApiTestingEnvironment;
	import org.eclipse.pde.api.tools.internal.model.ApiModelFactory;
	import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;
	import org.eclipse.pde.api.tools.internal.provisional.IApiBaselineManager;
	import org.eclipse.pde.api.tools.internal.provisional.model.IApiBaseline;
	import org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent;
	import org.eclipse.pde.api.tools.tests.ApiTestsPlugin;

	/**
	* Base class for binary compatibility tests
	*
	* @since 1.0
	*/
	public abstract class CompatibilityTest extends ApiBuilderTest {

	/**
	* Constructor
	* @param name
	*/
	public CompatibilityTest(String name) {
	super(name);
	}

	/* (non-Javadoc)
	* @see org.eclipse.pde.api.tools.builder.tests.ApiBuilderTests#getTestSourcePath()
	*/
	protected IPath getTestSourcePath() {
	return new Path("compat");
	}



	/* (non-Javadoc)
	* @see org.eclipse.pde.api.tools.builder.tests.ApiBuilderTests#setBuilderOptions()
	*/
	protected void setBuilderOptions() {
	enableUnsupportedTagOptions(false);
	enableBaselineOptions(false);
	enableCompatibilityOptions(true);
	enableLeakOptions(false);
	enableSinceTagOptions(false);
	enableUsageOptions(false);
	enableVersionNumberOptions(false);
	}

	/**
	* @return all of the child test classes of this class
	*/
	private static Class[] getAllTestClasses() {
	Class[] classes = new Class[] {
	ProjectTypeContainerTests.class,
	BundleCompatibilityTests.class,
	AnnotationCompatibilityTests.class,
	InterfaceCompatibilityTests.class,
	EnumCompatibilityTests.class,
	ClassCompatibilityTests.class,
	FieldCompatibilityTests.class,
	MethodCompatibilityTests.class,
	ConstructorCompatibilityTests.class,
	SinceTagTest.class,
	VersionTest.class,
	BundleMergeSplitTests.class,
	BundleVersionTests.class,
	};
	return classes;
	}

	/**
	* Collects tests from the getAllTestClasses() method into the given suite
	* @param suite
	*/
	private static void collectTests(TestSuite suite) {
	// Hack to load all classes before computing their suite of test cases
	// this allow to reset test cases subsets while running all Builder tests...
	Class[] classes = getAllTestClasses();

	// Reset forgotten subsets of tests
	TestCase.TESTS_PREFIX = null;
	TestCase.TESTS_NAMES = null;
	TestCase.TESTS_NUMBERS = null;
	TestCase.TESTS_RANGE = null;
	TestCase.RUN_ONLY_ID = null;

	/* tests */
	for (int i = 0, length = classes.length; i < length; i++) {
	Class clazz = classes[i];
	Method suiteMethod;
	try {
	suiteMethod = clazz.getDeclaredMethod("suite", new Class[0]);
	} catch (NoSuchMethodException e) {
	e.printStackTrace();
	continue;
	}
	Object test;
	try {
	test = suiteMethod.invoke(null, new Object[0]);
	} catch (IllegalAccessException e) {
	e.printStackTrace();
	continue;
	} catch (InvocationTargetException e) {
	e.printStackTrace();
	continue;
	}
	suite.addTest((Test) test);
	}
	}

	/**
	* @return the tests for this class
	*/
	public static Test suite() {
	TestSuite suite = new TestSuite(CompatibilityTest.class.getName());
	collectTests(suite);
	return suite;
	}

	/* (non-Javadoc)
	*
	* Ensure a baseline has been created to compare against.
	*
	* @see org.eclipse.pde.api.tools.builder.tests.ApiBuilderTest#setUp()
	*/
	@Override
	protected void setUp() throws Exception {
	// for the first compatibility test create workspace projects
	ApiTestingEnvironment env = getEnv();
	if (env != null) {
	env.setRevert(true);
	}
	super.setUp();
	IProject[] projects = getEnv().getWorkspace().getRoot().getProjects();
	if (projects.length == 0) {
	// populate the workspace with initial plug-ins/projects
	createExistingProjects(BASELINE, true, true, false);
	} else {
	// build after revert
	incrementalBuild();
	}
	IApiBaselineManager manager = ApiPlugin.getDefault().getApiBaselineManager();
	IApiBaseline baseline = manager.getDefaultApiBaseline();
	if (baseline == null) {
	// create the API baseline
	IApiBaseline profile = manager.getWorkspaceBaseline();
	projects = getEnv().getWorkspace().getRoot().getProjects();
	IPath baselineLocation = ApiTestsPlugin.getDefault().getStateLocation().append(BASELINE);
	IApiComponent component = null;
	for (int i = 0; i < projects.length; i++) {
	component = profile.getApiComponent(projects[i].getName());
	exportApiComponent(
	projects[i],
	component,
	baselineLocation);
	}
	baseline = ApiModelFactory.newApiBaseline("API-baseline");
	IApiComponent[] components = new IApiComponent[projects.length];
	for (int i = 0; i < projects.length; i++) {
	IProject project = projects[i];
	IPath location = baselineLocation.append(project.getName());
	components[i] = ApiModelFactory.newApiComponent(baseline, location.toOSString());
	}
	baseline.addApiComponents(components);
	manager.addApiBaseline(baseline);
	manager.setDefaultApiBaseline(baseline.getName());
	}
	getEnv().setRevertSourcePath(new Path(BASELINE));
	}

	@Override
	protected void tearDown() throws Exception {
	super.tearDown();
	getEnv().setRevert(false);
	}

	/**
	* Performs a compatibility test. The workspace file at the specified (full workspace path)
	* location is updated with a corresponding file from test data. A build is performed
	* and problems are compared against the expected problems for the associated resource.
	*
	* @param workspaceFile file to update
	* @param incremental whether to perform an incremental (<code>true</code>) or
	* full (<code>false</code>) build
	* @throws Exception
	*/
	protected void performCompatibilityTest(IPath workspaceFile, boolean incremental) throws Exception {
	updateWorkspaceFile(
	workspaceFile,
	getUpdateFilePath(workspaceFile.lastSegment()));
	if (incremental) {
	incrementalBuild();
	} else {
	fullBuild();
	}
	expectingNoJDTProblemsFor(workspaceFile);
	ApiProblem[] problems = getEnv().getProblemsFor(workspaceFile, null);
	assertProblems(problems);
	}

	/**
	* Performs a compatibility test. The workspace file at the specified (full workspace path)
	* location is updated with a corresponding file from test data. A build is performed
	* and problems are compared against the expected problems for the associated resource.
	*
	* @param workspaceFile file to update
	* @param incremental whether to perform an incremental (<code>true</code>) or
	* full (<code>false</code>) build
	* @throws Exception
	*/
	protected void performVersionTest(IPath workspaceFile, boolean incremental) throws Exception {
	updateWorkspaceFile(
	workspaceFile,
	getUpdateFilePath(workspaceFile.lastSegment()));
	if (incremental) {
	incrementalBuild();
	} else {
	fullBuild();
	}
	ApiProblem[] problems = getEnv().getProblemsFor(new Path(workspaceFile.segment(0)).append(JarFile.MANIFEST_NAME), null);
	assertProblems(problems);
	}

	/**
	* Performs a compatibility test. The workspace file at the specified (full workspace path)
	* location is deleted. A build is performed and problems are compared against the expected
	* problems for the associated resource.
	*
	* @param workspaceFile file to update
	* @param incremental whether to perform an incremental (<code>true</code>) or
	* full (<code>false</code>) build
	* @throws Exception
	*/
	protected void performDeletionCompatibilityTest(IPath workspaceFile, boolean incremental) throws Exception {
	deleteWorkspaceFile(workspaceFile, true);
	if (incremental) {
	incrementalBuild();
	} else {
	fullBuild();
	}
	ApiProblem[] problems = getEnv().getProblems();
	assertProblems(problems);
	}

	/**
	* Performs a compatibility test. The workspace file at the specified (full workspace path)
	* location is created. A build is performed and problems are compared against the expected
	* problems for the associated resource.
	*
	* @param workspaceFile file to update
	* @param incremental whether to perform an incremental (<code>true</code>) or
	* full (<code>false</code>) build
	* @throws Exception
	*/
	protected void performCreationCompatibilityTest(IPath workspaceFile, boolean incremental) throws Exception {
	createWorkspaceFile(
	workspaceFile,
	getUpdateFilePath(workspaceFile.lastSegment()));
	if (incremental) {
	incrementalBuild();
	} else {
	fullBuild();
	}
	ApiProblem[] problems = getEnv().getProblems();
	assertProblems(problems);
	}
	}